2022-08-09 第六小组 张宁杰 IO流（2）

昨日遗留：

file类不能操作文件的内容

IO流（输入输出流）

1、按照流向分
输入流：从硬盘读取数据到内存（读）
输出流：从内存写出数据到硬盘（写）
一个文件在传出过程中经历了多次复制粘贴，IO的性能本身很低，所以打印输出语句是非常低的（禁止使用）
新技术：零拷贝、Nio
2、按照操作单元分：
字节流：逐个字节操作，二进制操作，操作任意类型的文件
字符流：逐个字符操作，一个字符两个字节，主要用来处理文本文件（.txt,.java,.py,.xml
3、按照角色划分：
节点流：直接操作一个特定的IO设备
处理流：在节点流的基础上，做进一步的处理

public class Ch01 {

    public static void main(String[] args) {
        File file = new File("e:/aaa.txt");
        try {
            file.createNewFile();
            System.out.println("文件创建完成！");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

}

如何使用流

输入流：一点一点往内存读数据
字节输入流：
1.创建一个FileStream对象
2.定义一个标记，用来控制输入流的读取
3.循环读取，如果读取到了-1，说明读取到了文件的末尾，循环结束
4.关闭资源
注意：一个流读完了就没有了，不能再读了
当一个流读完以后会默认调用mark和reset方法来进行记录和重置，这个流就已经重置到了上次读完的位置，所以就无法再读取内容，并不是读完一次以后就关闭了流

public class Ch02 {

    @Test
    public void test02() {
        InputStream inputStream = null;
        try {
            inputStream = new FileInputStream("e:/aaa.txt");
            int read;
            byte [] buf = new byte[1024];
            while((read = inputStream.read(buf)) != -1) {
//                System.out.print(Arrays.toString(buf) + " ");
                System.out.println(new String(buf));
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            IOUtil.closeIO(inputStream,null);
//            try {
//                if(Objects.nonNull(inputStream)){
//                    // 关闭流
//                    inputStream.close();
//                }
//            } catch (IOException e) {
//                throw new RuntimeException(e);
//            }
        }
    }

    @Test
    public void test01() {
        InputStream inputStream = null;
        try {
            inputStream = new FileInputStream("e:/aaa.txt");
            // 开始读的操作，read方法，返回值是int，当返回值为-1时，说明文件读取到了末尾
            // 读取文件是否结束的标记
            int read;
            // 字节流读数据的时候一个字节一个字节去读
            // 循环读取
            while((read = inputStream.read()) != -1) {
                System.out.print(read + " ");
            }
            System.out.println();
            System.out.println("读取完毕，再读一次。。。。");
            // 字节流读数据的时候一个字节一个字节去读
            // 循环读取
            while((read = inputStream.read()) != -1) {
                System.out.print(read + " ");
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            try {
                // 关闭流
                inputStream.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

字节输出流：
FileOutPutStream的构造器：
boolean append参数：如果传入true，则代表在原有的基础上追加，不覆盖
如果传入false，或者不传，覆盖原有内容
写的操作，如果目标文件不存在，会自动新建

public class Ch03 {

    @Test
    public void test03(){
        System.out.println(Objects.nonNull("null"));
    }

    @Test
    public void test02() {
        OutputStream outputStream = null;
        try {
            outputStream = new FileOutputStream("e:/aaa.txt",true);
            // 一个字节一个字节的写
            outputStream.write("\r\n".getBytes());
            outputStream.write("八月正午的阳光都没你耀眼".getBytes());
            System.out.println("数据写出成功...");
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            closeIO(null,outputStream);
//            try {
//                if(Objects.nonNull(outputStream)){
//                    outputStream.close();
//                }
//            } catch (IOException e) {
//                throw new RuntimeException(e);
//            }
        }
    }

    @Test
    public void test01() {
        OutputStream outputStream = null;
        try {
             outputStream = new FileOutputStream("e:/aaa.txt",true);
             // 一个字节一个字节的写
            outputStream.write(98);
            System.out.println("数据写出成功...");
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            try {
                outputStream.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

文件的复制：
两个流：
FileInputStream:把对应的文件的内容读取出来
FileOutStream:把读到的内容写出去
read(byte[]) write(byte[])
多个流同时使用时：
流的关闭顺序的问题？先用的流后关，后用的先关！！！

public class Ch04 {

    @Test
    public void test01(){
        InputStream inputStream = null;
        OutputStream outputStream = null;
        try {
            inputStream = new FileInputStream("E:\\workspace\\vscode\\HTML\\20220709\\img\\lijian.jpeg");
            outputStream = new FileOutputStream("e:/lijian.jpeg");

            byte [] buf = new byte[3];
            int len;

            // 循环读进来
            while((len = inputStream.read(buf)) != -1){
                // 写出去
                outputStream.write(buf,0,len);
            }
            System.out.println("文件复制完毕...");
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
//            IOUtil.closeIO(inputStream,outputStream);
            try {
                if(Objects.nonNull(outputStream)){
                    outputStream.close();
                    int i = 10 / 0;
                }
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
            try {
                if(Objects.nonNull(inputStream)){
                    inputStream.close();
                }
            } catch (Exception e) {
                throw new RuntimeException(e);
            }

        }
    }

}

在jdk1.7之后，很多资源类实现了AutoCloseable接口
包括我们常见的流，FileInputStream,FileOutputStream....
可以在try中定义资源，并会主动释放资源
了解即可！！
字符流：纯文本文件

public class Ch06 {

    @Test
    public void test02() {
        Writer writer = null;
        try {
            writer = new FileWriter("e:/bbb.txt");
            writer.write("阿里巴巴规约手册...");
            System.out.println("数据写出成功...");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            IOUtil.closeIO(null,writer);
        }
    }

    @Test
    public void test01() {
        Reader reader = null;
        try {
            reader = new FileReader("e:/aaa.txt");
            int len;
            char [] buf = new char[10];
            while((len = reader.read(buf)) != -1){
                System.out.println(new String(buf,0,len));
            }
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            IOUtil.closeIO(reader,null);
        }
    }
}

字符处理流（用的最多）
缓冲流
只能处理纯文本文件：
.txt,.java,.html,.css.........
利用缓冲字符流来写一个文件的复制

public class Ch07 {

    @Test
    public void test02() {
        BufferedWriter bufferedWriter = null;
        try {
            bufferedWriter = new BufferedWriter(new FileWriter("e:/xxx.txt"));
            bufferedWriter.write("今天是星期二，天气凉爽！");
            System.out.println("数据写出成功！");
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            IOUtil.closeIO(null,bufferedWriter);
        }
    }

    @Test
    public void test01() {
        BufferedReader bufferedReader = null;
        try {
            bufferedReader = new BufferedReader(new FileReader("e:/aaa.txt"));
            String str;
            while((str = bufferedReader.readLine()) != null) {
                System.out.println(str);
            }
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            IOUtil.closeIO(bufferedReader,null);
        }
    }
}

序列化与反序列化：操作对象
序列化：将对象写入到IO流中，将内存模型的对象变成字节数字，可以进行存储和传输。
反序列号：从IO流中恢复对象，将存储在硬盘上或者从网络中接收的数据恢复成对象模型
使用场景：所有可在网络上 传输的对象必须是可序列化的。否则会报错，所有保存在硬盘上的对象也必须可序列化。
序列化版本号：
反序列化必须拥有class文件，但随着项目的升级
java序列化提供了一个版本号
版本号是可以自由指定，如果不指定，JVM会根据类信息自己计算一个版本号，所以无法匹配，则报错
不指定版本号，可能会有一个隐患，不利于JVM的移植，可能class文件没有改，但是不同的JVM计算规则不一样，导致无法反序列化
如果只修改了方法，反序列化是不受影响，无需修改版本号
修改了静态变量static。瞬态变量transient，反序列化也不受影响，无需修改版本号
总结：
1.所有需要网络传输的对象都需要实现序列化接口
2.对象的类名，实例化变量都会被序列化：方法、类变量、transient变量不会被序列化
3.如果想让某个变量不被序列化，可以用transient修饰
4.序列化对象的引用类型成员变量，也必须是可序列化的，否则会报错
5.反序列化时必须有序列化对象的class文件
6.同一个对象被序列化多次，只有第一次序列化为二进制流，以后都只是保存序列化的版本号
7.建议所有可序列化的类加上版本号，方便项目升级。

public class Ch02 {

    @Test
    public void test02() {
        ObjectInputStream objectInputStream = null;
        // 先锁定一个文件
        try {
            objectInputStream = new ObjectInputStream(new FileInputStream("e:/user.txt"));
            User user = (User) objectInputStream.readObject();
            System.out.println("对象读取成功：" + user);
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        } catch (ClassNotFoundException e) {
            throw new RuntimeException(e);
        } finally {
            IOUtil.closeIO(objectInputStream,null);
        }

    }

    @Test
    public void test01() {
        ObjectOutputStream objectOutputStream = null;
        // 先锁定一个文件
        try {
            objectOutputStream = new ObjectOutputStream(new FileOutputStream("e:/user.txt"));
            User user = new User("张三",25,1);
            objectOutputStream.writeObject(user);
            System.out.println("对象写出成功...");
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            IOUtil.closeIO(null,objectOutputStream);
        }

    }
}