【第十三章 转换流，对象流，对象的序列化机制，随机读取文件流】

第十三章 转换流，对象流，对象的序列化机制，随机读取文件流

1.转换流（处理流）：属于字符流
（1）①InputStreamReader:将一个字节的输入流转换为字符的输入流（将InputStream转换为Reader）
②OutputStreamWriter：将一个字符的输出流转换为字节的输出流（将Writer转换为OutputStream）
（2）作用：提供字节流与字符流之间的转换。
（3）解码：字节、字节数组---->字符数组、字符串
编码：字符数组、字符串----->字节、字节数组
2.InputStreamReader的使用

 @Test
    public void test(){
        FileInputStream fis= null;
        InputStreamReader isr= null;
        try {
            fis = new FileInputStream("fighting.txt");
            //isr=new InputStreamReader(fis);//使用系统默认的字符集
            //参数2指明了字符集，具体使用哪个字符集，取决于文件fighting.txt保存时使用的字符集
            isr = new InputStreamReader(fis,"utf-8");
            char[] cbuffer=new char[5];
            int len;
            while ((len=isr.read(cbuffer))!=-1){
                String str=new String(cbuffer,0,len);
                System.out.println(str);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(isr!=null){
                try {
                    isr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(fis!=null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

3.综合使用InputStreamReader，OutputStreamWriter

@Test
    public void test1(){
        InputStreamReader isr= null;
        OutputStreamWriter osw= null;
        try {
            File file1=new File("fighting.txt");
            File file2=new File("fighting_gbk.txt");
            FileInputStream fis=new FileInputStream(file1);
            FileOutputStream fos=new FileOutputStream(file2);
            isr = new InputStreamReader(fis,"utf-8");
            osw = new OutputStreamWriter(fos,"gbk");
            char[] cbuffer=new char[5];
            int len;
            while ((len=isr.read(cbuffer))!=-1){
                osw.write(cbuffer,0,len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(osw!=null){
                try {
                    osw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(isr!=null){
                try {
                    isr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

4.对象流（ObjectInputStream、ObjectOutputStream）：
（1）对象的序列化机制：允许内存中的java对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点。当其他程序获取了这种二进制流，就可以恢复成原来的java对象。
（2）序列化：用ObjectOutputStream类保存基本类型数据或对象的机制。
反序列化：用ObjectInputStream类读取基本类型数据或对象的机制。
（3）作用：用于存储和读取基本数据类型数据或对象的处理流。它的强大之处就是可以把java中的对象写入到数据源中，也能把对象从数据源中还原回来。

/**
     * 序列化过程：将内存中的java对象保存到磁盘中或通过网络传输出去
     * 使用ObjectOutputStream实现
     */
    @Test
    public void testObjectOutputStream(){
        ObjectOutputStream oos= null;
        try {
            //1.
            oos = new ObjectOutputStream(new FileOutputStream("object.dat"));
            //2.
            oos.writeObject(new String("我爱北京天安门!"));
            oos.flush();//刷新操作
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(oos!=null){
                try {
                    //3.
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    /**
     * 反序列化过程：将磁盘文件中的对象还原为内存中的一个java对象
     * 使用：ObjectInputStream实现
     */
    @Test
    public void testObjectInputStream(){
        ObjectInputStream ois= null;
        try {
            ois = new ObjectInputStream(new FileInputStream("object.dat"));
            Object object=ois.readObject();
            String str=(String)object;
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            if(ois!=null){
                try {
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

（4）要想一个java对象时可序列化的，需要满足相应的要求
a.需要实现接口：Serializable。
b.需要当前类提供一个全局常量：serialVersionUID。serialVersionUID用来表明类的不同版本间的兼容性。
c.除了当前类需要实现Serialzable接口之外，还必须保证其内部所有属性也必须时可序列化的。（默认情况下，基本数据类型是可序列化的。）
d.补充：ObjectInputStream、ObjectOutputStream不能序列化static和transient修饰的成员。

public class Person implements Serializable {
    private static final long serialVersionUID=45768828L;
    private  String name;
    private int age;
    public Person() {
    }
    public Person(String name,int age) {
        this.name = name;
        this.age=age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

 /**
     * 序列化过程：将内存中的java对象保存到磁盘中或通过网络传输出去
     * 使用ObjectOutputStream实现
     */
    @Test
    public void testObjectOutputStream(){
        ObjectOutputStream oos= null;
        try {
            //1.
            oos = new ObjectOutputStream(new FileOutputStream("object.dat"));
            //2.
            oos.writeObject(new Person("王涛",20));
            oos.flush();//刷新操作
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(oos!=null){
                try {
                    //3.
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    /**
     * 反序列化过程：将磁盘文件中的对象还原为内存中的一个java对象
     * 使用：ObjectInputStream实现
     */
    @Test
    public void testObjectInputStream(){
        ObjectInputStream ois= null;
        try {
            ois = new ObjectInputStream(new FileInputStream("object.dat"));
            Person p=(Person)ois.readObject();
            System.out.println(p);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            if(ois!=null){
                try {
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

5.随机读取文件流（RandomAccessFile）
（1）RandomAccessFile 声明在java.io包下，但直接继承于java.lang.Object类。并且它实现了DataInput、DataOutput这两个接口，也就意味着这个类既可以读也可以写。
（2）构造器
public RandomAccessFile(File file, String mode)
public RandomAccessFile(String name, String mode)
（3）创建 RandomAccessFile 类实例需要指定一个 mode 参数，该参数指定 RandomAccessFile 的访问模式：

r: 以只读方式打开
rw：打开以便读取和写入
rwd:打开以便读取和写入；同步文件内容的更新
rws:打开以便读取和写入；同步文件内容和元数据的更新

（4）如果模式为只读r。则不会创建文件，而是会去读取一个已经存在的文件，如果读取的文件不存在则会出现异常。 如果模式为rw读写。如果文件不存在则会去创建文件，如果存在则不会创建。
（5）RandomAccessFile作为输出流时，写出到的文件如果不存在，则在执行过程中自动创建，如果写出的文件存在，则会对原有文件内容进行覆盖，默认情况下，从头覆盖。