2022/08/08 吉软 Java基础(22) IO流

一、什么是IO流

• I : Input
• O : Output
• 通过IO可以完成硬盘文件的读和写。

二、IO流的分类

1. 按照流的方向进行分类：

以内存作为参照物：

• 往内存中去：叫做输入(Input)。或者叫做读(Read)。
• 从内存中出来：叫做输出(Output)。或者叫做写(Write)。

2. 按照读取数据方式不同进行分类：

• 按照字节的方式读取数据，一次读取1个字节byte，等同于一次读取8个二进制位

这种流是万能的，什么类型的文件都可以读取。包括：文本文件，图片，声音文件，视频文件 等…

• 按照字符的方式读取数据的，一次读取一个字符

这种流是为了方便读取 普通文本文件 而存在的，这种流不能读取：图片、声音、视频等文件。只能读取 纯文本文件，连word文件都无法读取。

3. 按照角色划分：

• 节点流：直接操作一个特定的IO设备。

• 处理流：在节点流的基础上，做进一步的处理。

注意：
纯文本文件，不单单是.txt文件，还包括 .java、.ini、.py 。总之只要 能用记事本打开 的文件都是普通文本文件。

Java中输入输出流常用的流：

	字节输入流	字节输出流	字符输入流	字符输出流
抽象基类	InputStream	OutputStream	Reader	Writer
访问文件 （节点流）	FileInputStream	FileOutputStream	FileReader	FileWriter
缓冲流 （处理流）	BufferedInputStream	BufferedOutputStream	BufferedReader	BufferedWriter
操作对象	ObjectInputStream	ObjectOutputStream

三、IO流四大家族首领

• 字节流

1. java.io.InputStream 字节输入流
2. java.io.OutputStream 字节输出流

• 字符流

1. java.io.Reader 字符输入流

2. java.io.Writer 字符输出流

注意：

四大家族的首领都是抽象类。(abstract class)

所有的流都实现了：

1. java.io.Closeable接口，都是可关闭的，都有 close() 方法。
2. 流是一个管道，这个是内存和硬盘之间的通道，用完之后一定要关闭，不然会耗费(占用)很多资源。养成好习惯，用完流一定要关闭。
3. 所有的 输出流 都实现了：
4. java.io.Flushable接口，都是可刷新的，都有 flush() 方法。
5. 养成一个好习惯，输出流在最终输出之后，一定要记得flush()刷新一下。这个刷新表示将通道/管道当中剩余未输出的数据强行输出完（清空管道！）刷新的作用就是清空管道。
6. ps：如果没有flush()可能会导致丢失数据。
7. 在java中只要“类名”以 Stream 结尾的都是字节流。以“ Reader/Writer ”结尾的都是字符流。

四、Java要掌握的流（16个）

1.文件专属：

• java.io.FileInputStream（掌握）

• java.io.FileOutputStream（掌握）

• java.io.FileReader

• java.io.FileWriter

2.转换流：（将字节流转换成字符流）

• java.io.InputStreamReader
• java.io.OutputStreamWriter

4.缓冲流专属：

• java.io.BufferedReader

• java.io.BufferedWriter

• java.io.BufferedInputStream

• java.io.BufferedOutputStream

5.数据流专属：

• java.io.DataInputStream

• java.io.DataOutputStream

6.标准输出流：

• java.io.PrintWriter

• java.io.PrintStream（掌握）

7.对象专属流：

• java.io.ObjectInputStream（掌握）

• java.io.ObjectOutputStream（掌握）

8.File文件类

• java.io.File

补充：Windows/Linux小知识点

        Windows：D:\Soft\QQ\Plugin

        Linux：      D:/Soft/QQ/Plugin

注意： Windows各个文件之间分隔符为：” \ “；Linux各个文件之间分割符为：” / “

补充：IDEA默认的当前路径是？
        工程Project的根就是IDEA的默认当前路径

五、如何创建字节输入流：

• 1.创建一个FileInputStream对象
• 2.定义一个标记，用来控制输入流的读取
• 3.循环读取，如果读取到了-1，说明读取到了文件的末尾，循环结束
• 4.关闭资源。

具体代码如下：

@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);
            }
        }
    }

注意：

我们发现一个流读完了就没有了，不能再读了。

当一个流读完之后会默认调用mark和reset方法来进行记录和重置，

这个流就已经重置到了上次读完的位置，所以就无法再次读取内容。并不是读完一次之后就关闭了流。

 六、如何创建字节输出流

1. ileOutputStream构造器：
2. boolean append参数：如果传入true，则代表在原有基础上追加，不覆盖
3. 如果传入false，或者不传，覆盖原有内容
4. 写的操作，目标文件如果不存在，会自动新建。

具体代码如下： 

@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：把对应文件的内容读取出来
• FileOutputStream：把读到的内容写出去
• read(byte[])
• write(byte[])

 具体代码如下

@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);
            }

        }
    }

多个流同时使用时：流的关闭顺序的问题？

先用的流后关，后用的先关！！！

八. 字符处理流:

缓冲流:

        利用缓冲字符流来写一个文件的复制

具体代码如下：

    @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文件，但随着项目的升级，class文件也会升级序列化保证升级前后的兼容性。

        Java序列化提供了一个版本号版本号是可以自由指定，如果不指定，JVM会根据类信息自己计算一个版本号，所以无法匹配，则报错！！！不指定版本号，还有一个隐患，不利于JVM的移植，可能class文件没有改，但是不同的jvm计算规则不一样，导致无法反序列化如果只修改了方法，反序列化是不受影响，无需修改版本号修改了静态变量static，瞬态变量transient，反序列化也不受影响，无需修改版本号

总结：

• 1.所有需要网络传输的对象都需要实现序列化接口

• 2.对象的类名、实例变量都会被序列化；方法、类变量、transient变量不会被序列化

• 3.如果想让某个变量不被序列化，可以用transient修饰

• 4.序列化对象的引用类型成员变量，也必须是可序列化的，否则会报错

• 5.反序列化时必须有序列化对象的class文件

• 6.同一个对象被序列化多次，只有第一次序列化为二进制流，以后都只是保存序列化的版本号

• 7.建议所有可序列化的类加上版本号，方便项目升级。