JAVA11_24学习总结(IO,序列化)

今日内容

1. IO(结尾)

1.1 字节缓冲流

字节缓冲输出流/输入流 (高效字节流)
    BuffedOutputStream/BufferedInputStream
        ---只是提供一个字节缓冲区,本身就是一个字节数组,不会直接操作文件
            --操作具体的文件使用都是基本字节流FileInputStream/FileOutputStream
 
    public BufferedOutputStream(OutputStream out)
        ---创建一个字节缓冲输出流对象,默认缓冲区大小(8192)
    public BufferedInputStream(InputStream in)
        ---创建一个字节缓冲输入流对象,默认缓冲大小

1.2 字符流

字符流--字节流之后出现,用记事本打开能看懂,就用字符流
    字符输出流
        Write-写
          --具体的子类
            public OutputStreamWrite(OutputStream out)
                --字符转换输出流-使用平台默认的编码字符集-推荐,不容易造成编码错误
            public OutputStreamWrite(OutputStream out , String charsetName)
                --字符转换输出流-使用自定义的编码字符集-不推荐,一般使用默认
          --写功能
            void write(char[] cbuf)
                --写入一个字符数组。
            abstract void write(char[] cbuf, int off, int len) 
                --写入字符数组的一部分。
            void write(int c)  
                --写一个字符
            void write(String str)--一般常用!
                --写一个字符串
            void write(String str, int off, int len) 
                --写入字符串的一部分
            void newLine()
                --写入一个空行--相当于换行
        Reader-读功能
          --具体的子类
            public InputStreamReader(InputStream in)
                --字符转换输入流-使用平台默认的编码字符集--推荐,不容易造成编码错误
            public InputStreamReader(InputStream in , String charsetName)
                --字符转换输入流-使用自定义的编码字符集-不推荐,一般使用默认
          --读功能
             public int read(char[] cbuf)
                --读取字符数组
             public int read()
                --读一个字符
             public String readLine()
                --读取一行

便捷的字符输入输出流
    以上的字符输入输出方式都依赖字节输入输出流 
        InputStreamReader(InputStream in)
        public OutputStreamWrite(OutputStream out)
      --提供了他们具体的子类 
        ---字符转换流的便捷类,跟平台默认字符集一致
           FileReader(File/String pathname)
              ---字符快捷输入流
           FileWriter(File/String pathname)
              ---字符快捷输出流
           FileWriter(File/String pathname,boolean append)
              ---第二个参数为true,追加内容

字符缓冲输出流/输入流 (高效字符流)
    BufferedReader
        --字符缓冲输入流
    BufferedWriter
        --字符缓冲输出流
    注意
        他们不能直接操作文件,提供缓冲区让读写效率更高,特有方式--借助FileReader/FileWrite

import java.io.*;
​
//测试便捷字符读写和告诉字符输入输出流
public class Test {
    public static void main(String[] args) throws IOException {
        //创建reader字符流访问磁盘文件--老方法
        /*
            BufferedReader reader = new BufferedReader( //字符高效
                new InputStreamReader( //字符流转换器
                        new FileInputStream("Demo.txt") //字节输入流
                )
        );
        */
        //输出流同理
        BufferedWriter writer = new BufferedWriter(
                new FileWriter("Demo.txt",true)
        );
        //创建reader字符流访问磁盘文件--新方法
        BufferedReader reader = new BufferedReader( //字符高效
                new FileReader("Demo.txt") //字符输入流
        );
        //写方法,追加内容
        int i = 5 ;
        while (i>0){
            writer.write("我爱学习Java");
            writer.newLine();//换行
            i--;
        }
        writer.flush();//刷新,使缓存全部进去
        //读方法
        String str = null ;//用来接收读的结果
        while ((str=reader.readLine())!=null){ //不断读取直到为空---加上---非空判断
            System.out.println(str);
        }
        reader.close();
        writer.close(); //释放资源
        /*
            我爱学习Java
            我爱学习Java
            我爱学习Java
            我爱学习Java
            我爱学习Java
         */
    }
}

2.序列化与反序列化

序列化
    在网络上数据只能以流的形式传递和获取
        序列化就是把我们需要传播的文件变成"流数据"!
        前提条件
            被转换的数据必须实现serializable序列化接口!--类比clone的标记接口!
                Java中大部分类都实现了这个接口,自定义接口要自行实现
                    实现了这个接口的类才能被序列化
                      --产生固定serialVersionUID唯一的标识ID
    构造方法
        public ObjectOutputStream(OutputStream out)
    格式
        ObjectOutputStream 名 = new ObjectOutputStream(new FileOutputStream("路径名"))
            ---将我们写的文件进行序列化--相当于发送端
    方法
        名.writeObject(还原的对象名);
反序列化
    将序列化的流数据--->还原成数据
    构造方法
        public ObjectInputStream(InputStream in)
    格式
        ObjectInputStream 名 = new ObjectInputStream(new FileInputStream("路径名"))
            ---相当于是接收端
    方法
        名.inputObject();
            ---用相对应的类型来接受--Object要强转

import java.io.*;
​
public class Test {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //分开使用
        write() ;
        read() ;
    }
​
    //反序列化操作
    private static void read() throws IOException, ClassNotFoundException {
        //创建反序列化流对象
        ObjectInputStream bis = new ObjectInputStream(
                new FileInputStream("Demo1.txt")) ;
​
        //将序列化的流数据--->还原成Java对象
        Person p = (Person)bis.readObject();
        System.out.println(p);
    }
​
    //序列化操作
    private static void write() throws IOException {
        //创建一个Java对象
        Person p = new Person("钟离",500) ;
        //创建序列化流对象
        ObjectOutputStream oos = new ObjectOutputStream(
                new FileOutputStream("Demo1.txt")) ;
        oos.writeObject(p);
        //释放资源
        oos.close();
​
    }
}