IO流

IO流【输入输出流】：
        按照流向划分：
            输入流：外部数据 -> java程序
            输出流：java程序 -> 外部数据

        按照数据类型划分【根据使用记事本打开是否能够看懂来决定】：
            字节流【万能流】：
                字节输出流：
                    OutputStream（抽象类）
                        - FileOutputStream（实现子类）【普通的字节输出流】
                        构造方法：
                          FileOutputStream(File file)
                          FileOutputStream(String name)

                        - BufferedOnputStream【字节缓冲输出流】:
                          构造方法：
                            BufferedOnputStream（FileOutputStream fos）

                字节输入流：
                    InputStream（抽象类）
                        FileInputStream【普通的字节输入流】:
                          构造方法：
                            FileInputStream(File file)
                            FileInputStream(String name)
                          成员方法：
                            public int read()
                            public int read(byte[] b)

                        BufferedInputStream【字节缓冲输入流】:
                        构造方法
                          BufferedInputStream（FileIutputStream fis）
            字符流：
              字符输入流：
                  Reader【抽象类】
                      - InputStreamReader【具体实现子类】
                          构造方法：
                            IutputStreamWriter(FileIutputStream fos)
                          - FileReader【继承自InputStreamReader】
                           构造方法：
                              FileReader(String name)等同于IutputStreamReader(new FileIutputStream(String name))
              字符输出流：
                  Writer【抽象类】
                      - OutputStreamWriter【具体实现子类】
                          构造方法：
                            OutputStreamWriter(FileOutputStream fos)

                          - FileWriter【继承自OutputStreamWriter】
                           构造方法：
                              FileWriter(String name)等同于OutputStreamWriter(new FileOutputStream(String name))

读取

// public int read() 一次读取一个字符
//        System.out.print((char) isr.read());
//        System.out.print((char) isr.read());
//        int i = 0;
//        while ((i = isr.read()) != -1) {
//            System.out.print((char) i);
//        }

        //public int read(char[] cbuf) 一次读取一个字符数组
        char[] chars = new char[1024];
        int length = 0;
        while ((length= isr.read(chars))!=-1){
            String s = new String(chars, 0, length);
            System.out.print(s);
        }

序列化及反序列化

序列化：将对象转化成数据流一样在网络中传输
        对象输出流：ObjectOutputStream
        只有实现了Serializable接口的类的对象才可以进行序列化

    反序列化：将网络中数据流还原成一个对象
        对象输入流：ObjectInputStream

   我们正常写一个对象之后，读取一个对象都是没有问题的。
   但是当我们修改了原来的类的时候，再次读取存储的对象就报错了
   java.io.InvalidClassException:
    com.shujia.day16.Teacher;
    local class incompatible:
        stream class desc serialVersionUID = -4530247781226673719,
        local class serialVersionUID = -4180828856871739850

   若不想让某一个成员序列化的话，只需要在该成员前面加上transient关键字
public class ObjectOutputStreamDemo1 {
    public static void main(String[] args) throws Exception{
//        write();

        read();
    }
    public static void read() throws Exception{
        //ObjectInputStream(InputStream in)
        //创建从指定的InputStream读取的ObjectInputStream
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("java/src/com/shujia/day16/obj.txt"));
        Object o = ois.readObject(); //Object o = new Teacher("小虎", 18)
        Teacher t1 = (Teacher)o;
        System.out.println(t1);


        ois.close();
    }

    public static void write() throws Exception{
        Teacher t1 = new Teacher("小虎", 18);
        //创建ObjectOutputStream对象
        //ObjectOutputStream(OutputStream out)
        //创建一个写入指定的OutputStream的ObjectOutputStream。
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("java/src/com/shujia/day16/obj.txt"));
        oos.writeObject(t1);
        oos.flush();

        //释放资源
        oos.close();
    }
}