高级流介绍

转换流：

将字节流和字符流进行相互转换

OutputStreamWriter：将字节输出流转换为字符输出流

InputStreamReader：将字节输入流转换为字符输入流

public class OutputStreamWriter extends Writer

public OutputStreamWriter(OutputStream out) {
        super(out);
        try {
            se = StreamEncoder.forOutputStreamWriter(out, this, (String)null);
        } catch (UnsupportedEncodingException e) {
            throw new Error(e);
        }
    }

public class InputStreamReader extends Reader

public InputStreamReader(InputStream in) {
        super(in);
        try {
            sd = StreamDecoder.forInputStreamReader(in, this, (String)null); // ## check lock object
        } catch (UnsupportedEncodingException e) {
            // The default encoding should always be available
            throw new Error(e);
        }
    }

public static void main(String[] args) throws FileNotFoundException {
        String path = "E:\\java\\IO\\IOTest\\test1.txt";

        //字节输入流
        
        //原始流
        FileInputStream fileInputStream = new FileInputStream(path);
        
        //高级流，通过封装原始流提供高级特征
        InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream);
        
    }

缓冲流：

作用：提高IO读写速度

缓冲流的划分：字节缓冲流，字符缓冲流

字节缓冲流：BufferedInputStream、BufferedOutputStream

字符缓冲流：BufferedReader、BufferedWriter

已字符缓冲流为例介绍：

字符输出流：

String readLine() //分行读取，读取数据为null时结束

字符输入流：

 bufferedWriter.newLine();  //根据当前系统，写入一个换行符

对象流：

序列化和反序列化：

序列化：将对象转化为字节流的过程，可以将流进行保存到磁盘或者是发送到网络中（rpc）

反序列化：将字节流转化为对象的过程

序列化的特点：

1.在Java中，只要一个类实现了Serializable接口，就可以支持序列化和反序列化

2.通过ObjectInputStream和ObjectOutputStream对对象进行序列化和反序列化

3.transient关键字用于控制变量的序列化，在变量前添加该关键字，可以阻止该字段被序列化到文件中，在反序列化后，transient关键字修饰的变量给定的就是初始值，对象类型初始值是 null ，int类型初始值是0

4.虚拟机是否允许反序列化，不仅仅取决于类路径和代码是否一致，还要看两个类的序列化ID是否一致

什么是serialVersionUID：称之为版本标识符，使用对象的哈希码序列化标记在对象上

两种生成方式：

1.一种是默认的1L

2.一种是通过类名、接口名、成员变量及属性等生成的64位的哈希字段，UID的生成的默认值是依赖JAVA编译器的，对于同一个类，不同的编译器生成的结果UID可能是不同

 

版本号的作用：

1.确保不同的版本有不同的UID

2.在类中新增或者修改属性，不设置UID，会抛出异常

对象流的处理使用ObjectInputStream和ObjectOutputStream类

以ArrayList为例介绍序列化和反序列化

在ArrayList中定义了writeObject和readObject方法

在序列化的过程中，如果被定义的类中定义类writeObject，虚拟机会试图来调用类中writeObject方法来进行序列化，如果没有这个存在，调用默认的ObjectOutputStream中defaultWriteObject方法来序列化

反序列化的类似

对ArrayList集合进行序列化和反序列代码如下：

 public static void objectReader() {
        String path="E:\\java\\IO\\IOTest\\test2.txt";

        try {
            ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream(path));
            ArrayList list = (ArrayList) inputStream.readObject();
            Iterator iterator = list.iterator();
            while (iterator.hasNext()) {
                System.out.println(iterator.next());
            }

        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

    }

    public static void objectWrite() {
        String path="E:\\java\\IO\\IOTest\\test2.txt";

        ArrayList <Integer> list = new ArrayList <>(100);
        list.add(11);
        list.add(22);
        list.add(33);

        try {
            ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream(path));

            outputStream.writeObject(list);

            outputStream.close();

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

源码实现思路

在ArrayList中显性实现了WriteObject和ReadObject方法。

在对ArrayList的对象进行序列化和反序列化过程中，会自动调用到ArrayList中定义的WriteObject和ReadObject方法，

在ArrayList中存储数据的属性定义为ElementData属性，该属性是通过transient关键字修饰

该关键字的目的是不让修改的属性参与序列化，而ArrayList中数据就存储在elementData中，如果不参与序列化，则ArrayList中的数据则无法持久化

这就需要进行特殊处理

private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        elementData = EMPTY_ELEMENTDATA;

        // Read in size, and any hidden stuff
        s.defaultReadObject();

        // Read in capacity
        s.readInt(); // ignored

        if (size > 0) {
            // be like clone(), allocate array based upon size not capacity
            ensureCapacityInternal(size);

            Object[] a = elementData;
            // Read in all elements in the proper order.
            for (int i=0; i<size; i++) {
                a[i] = s.readObject();
            }
        }
    }

private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException{
        // Write out element count, and any hidden stuff
        int expectedModCount = modCount;
        s.defaultWriteObject();

        // Write out size as capacity for behavioural compatibility with clone()
        s.writeInt(size);

        // Write out all elements in the proper order.
        for (int i=0; i<size; i++) {
            s.writeObject(elementData[i]);
        }

        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
    }

通过源码实现可知：在序列化的过程中（WriteObject），只对有效的数据参与了序列化，所以反序列化拿到的是有效的数据

ArrayList中中writeObject或者readObject方法是如何调用的？

writeObject->writeObject0->writeOrdinaryObject->writeSerialData->invokeWriteObject