Day21--IO流

对象的序列化

import java.io.*;
class Person implements Serializable
{
    public static final long serialVersionUID = 42L;

    private String name;
    int age;
    Person(String name,int age)
    {
        this.name = name;
        this.age = age;
    }

    public String toString()
    {
        return name+":"+age;
    }
}

import java.io.*;
class ObjectStreamDemo
{
    public static void main(String[] args) throws IOException
    {
        readObj();
    }

    //读取序列化后的对象（反序列化）
    public static void readObj() throws IOException
    {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.txt"));

        Person p = (Person)ois.readObject();

        System.out.println(p);

        ois.close();
    }

    //对象序列化
    public static void writeObj() throws IOException
    {
        ObjectOutputStream oos =
                new ObjectOutputStream(new FileOutputStream("obj.txt"));

        oos.writeObject(new Person("lisi",39));

        oos.close();
    }
}

管道流

import java.io.*;
class Read implements Runnable
{
    private PipedInputStream in;
    Read(PipedInputStream in)
    {
        this.in = in;
    }

    public void run()
    {
        try
        {
            byte[] buf = new byte[1024];

            System.out.println("读取前。。没有数据阻塞");
            int len = in.read(buf);
            System.out.println("读到数据。。阻塞结束");

            String s = new String(buf,0,len);

            System.out.println(s);

            in.close();
        }
        catch(IOException e)
        {
            throw new RuntimeException("管道读取流失败");
        }
    }
}

class Write implements Runnable
{
    private PipedOutputStream out;
    Write(PipedOutputStream out)
    {
        this.out = out;
    }

    public void run()
    {
        try
        {
            System.out.println("开始写入数据，等待6秒后。");
            Thread.sleep(6000);
            out.write("piped lai la".getBytes());
            out.close();
        }
        catch(IOException e)
        {
            throw new RuntimeException("管道流输出失败");
        }
    }
}

class PipedStreamDemo
{
    public static void main(String[] args) throws IOException
    {
        PipedInputStream in = new PipedInputStream();
        PipedOutputStream out = new PipedOutputStream();
        in.connect(out);

        Read r = new Read(in);
        Write w = new Write(out);
        new Thread(r).start();
        new Thread(out).start();
    }
}

RandomAccessFile

• RandomAccessFile：该类不是算是IO体系中子类。而是直接继承自Object。但是它是IO包中成员。因为它具备读和写功能。内部封装了一个数组，而且通过指针对数组的元素进行操作。可以通过getFilePointer获取指针位置，同时可以通过seek改变指针的位置。其实完成读写的原理就是内部封装了字节输入流和输出流。通过构造函数可以看出，该类只能操作文件。而且操作文件还有模式：只读r、读写rw等。如果模式为只读r，不会创建文件，会去读取一个已经存在的文件，如果该文件不存在，则会出现异常。如果模式为rw，操作的文件不存在，会自动创建。如果存在则不会覆盖。

import java.io.*;
class RandomAccessFileDemo
{
    public static void main(String[] args) throws IOException
    {
        writeFile();
        readFile();
    }

    public static void readFile() throws IOException
    {
        RandomAccessFile raf = new RandomAccessFile("ran.txt","r");

        //调整对象中的指针
        raf.seek(8*1);

        //跳过指定的字节数
        raf.skipBytes(8);

        byte[] buf = new byte[4];
        
        raf.read(buf);

        String name = new String(buf);

        int age = raf.readInt();

        System.out.println("name:"+name);
        System.out.println("age:"+age);

        raf.close();
    }

    public static void readFile_2() throws IOException
    {
        RandomAccessFile raf = new RandomAccessFile("ran.txt","rw");
        
        raf.seek(8*3);
        raf.write("周期".getBytes());
        raf.writeInt(103);

        raf.close();
    }

    public static void writeFile() throws IOException
    {
        RandomAccessFile raf = new RandomAccessFile("ran.txt","rw");

        raf.write("李四".getBytes());
        raf.writeInt(97);

        raf.close();
    }
}

DataStream

• DataInputStream与DataOutputStream：可以用于操作基本数据类型的数据的流对象。

import java.io.*;
class DataStreamDemo
{
    public static void main(String[] args) throws IOException
    {
        writeData();
        readData();
    }

    public static void readUTFDemo() throws IOException
    {
        DataInputStrem dis = new DataInputStrem(new FileInputStream("utfdata.txt"));

        String s = dis.readUTF();

        System.out.println(S);
        dis.close();
    }

    public static void writeUTFDemo() throws IOException
    {
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("utfdata.txt"));

        dos.writeUTF("你好");

        dos.close();
    }

    public static void readData() throws IOException
    {
        DataInputStrem dis = new DataInputStrem(new FileInputStream("data.txt"));

        int num = dis.readInt();
        boolean b = dis.readBoolean();
        double d = dis.readDouble();

        System.out.println("num="+num);
        System.out.println("b="+b);
        System.out.println("d="+d);

        dis.close();
    }

    public static void writeData() throws IOException
    {
        DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));
        
        dos.writeInt(234);
        dos.writeBoolean(true);
        dos.writeDouble(9887.543);

        dos.close();
    }
}

ByteArrayStream

用于操作字节数组的流对象。
ByteArrayInputStream：在构造的时候，需要接受数据源，而且数据源是一个字节数组。
ByteArrayOutputStream：在构造的时候，不用定义数据目的，因为该对象中已经内部封装了可变长度的字节数组。这就是数据目的地。
因为这两个流对象都操作的数组，并没有使用系统资源。所以，不用进行close关闭。
在流操作讲解时：
源设备：
 键盘 System.in、硬盘 FileStream、内存 ArrayStream。
目的设备：
 控制台 System.out、硬盘 FileStream、内存 ArrayStream。
用流的读写思想来操作数据。

import java.io.*;
class ByteArrayStreamDemo
{
    public static void main(String[] args) 
    {
        //数据源
        ByteArrayInputStream bis = new ByteArrayInputStream("ABCDEFG0".getBytes());

        //数据目的
        ByteArrayOutputStream bos = new ByteArrayOutputStream();

        int by = 0;

        while((by=bis.read())!=-1)
        {
            bos.write(by);
        }

        System.out.println(bos.size());
        System.out.println(bos.toString());

        //bos.writeTo(new FileOutputStream("a.txt"));
    }
}

转换流的字符编码

编码：字符串变成字节数组。
解码：字节数组变成字符串。
String --> byte[]；str.getBytes(charsetName);
byte[] ---> String：new String(byte[], charsetName);