【IO 流】Java 中常见的 IO 流

红太狼 2023-10-03 11:42 40阅读 0赞

## 1. IO 流简介 ##

> 何为 IO 流？

在计算机中，内存和磁盘需要进行数据传输（内存从磁盘中读入数据，进行处理，然后写入磁盘中），而数据传输需要通道。所以，这里的 “IO 流”就是数据传输的通道。

内存和磁盘数据交互图如下：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0x1Y2t5X0JveV9MdWNr_size_16_color_FFFFFF_t_70]  
大致意思：内存通过输入流从磁盘中读取数据，这个过程也称为读；内存通过输出流将数据保存到磁盘中，这个过程也称为写。

所以，简单来说，IO 流的作用就是 通过 IO 流，可以完成对磁盘文件的读和写。

## 2. IO 流的分类 ##

1.  按流的方向分（以内存为参照物）：输入流（往内存中去）、输出流（从内存中出来）
2.  按数据的读取方式：字节流、字符流

> 字节流和字符流的区别？

1.  字节流：按照字节方式读取，一次读一个字节，可以读取任意类型的文件。如：文本文件、图片、视频文件，等…
2.  字符流：按照字符方式读取，一次读取一个字符。它是为了更方便读取**普通的文本文件**，无法读取图片、word文件、视频文件等…

**举个例子：**

> 有一个 test.txt 文件，它里面的内容是：a中国

用字节流读：

> 第一次读：读一个字节，正好读到 ‘a’  
> 第二次读：读一个字节，正好读到 ‘中’ 的一半  
> 第三次读：读一个字节，读到 ‘中’ 的另一半

Tips:在 Windows 系统中，字母只占一个字节（在 Java 中，字母(char) 占用两个字节，但这个文件与 Java 无关，它只是 Windows 操作系统上的一个文件），而汉字占两个字节。

用字符流读：

> 第一次读：读一个字符，正好读到 ‘a’  
> 第二次读：读一个字节，正好读到 ‘中’

## 3. Java 中的 IO 流 ##

Java 中的 IO 流都在 java.io.\* 包下，这块被称为“四大家族”（所有的 IO 类只有四类），四大家族的首领（这四类 IO 流的顶级父类）如下：

*  `java.io.InputStream`:字节输入流
 *  `java.io.OutputStream`:字节输出流
 *  `java.io.Reader`:字符输入流
 *  `java.io.Writer`:字符输出流

**特点：**

1.  四大家族的首领都是抽象类
2.  所有的 IO 流都实现了 `java.io.Closeable` 接口，都是可关闭的（`close()`方法），用完之后要关闭，不然会占用很多资源
3.  所有的输出流都实现了 `java.io.Flushable` 接口，都是可刷新的（`flush()` 方法），用完之后，记得刷新

> Java 中需要掌握的 IO 流有16个，如下：

**文件专属（操作文件）：**

*  `java.io.FileInputStream`
 *  `java.io.FileOutputStream`
 *  `java.io.FileReader`
 *  `java.io.FileWriter`

**转换流（将字节流转换为字符流）：**

*  `java.io.InputStreamReader`
 *  `java.io.OutputStreamWriter`

**缓冲专属：**

*  `java.io.BufferedInputStream`
 *  `java.io.BufferedOutputStream`
 *  `java.io.BufferedReader`
 *  `java.io.BufferedWriter`

**数据流专属：**

*  `java.io.DataInputStream`
 *  `java.io.DataOutputStream`

**标准输出流：**

*  `java.io.PrintStream`
 *  `java.io.PrintWriter`

**对象专属流：**

*  `java.io.ObjectInputStream`
 *  `java.io.ObjectOutputStream`

这里重点以“FileInputStream/FileOutputStream”举例，因为其它流与之相似

### 3.1 FileInputStream/FileOutputStream ###

#### 3.1.1 FileInputStream ####

`FileInputStream`：文件字节输入流

`FileInputStream` 类的 `read()` 方法有三个重载形式：

1.  `public int read()`：读取单个字节，返回值为 int 类型，代表用该字节编码的的 ascii 码值
2.  `public int read(byte [] b, int offset, int len)`：读取若干字节到字节数组中，返回值为读取的字节数
3.  `public int read(char cbuf[])`：它的父类 `Reader`的方法。读取若干字节到字节数组中，返回值为读取的字节数

场景：使用文件字节流读取磁盘中的一个文件temp.txt,其内容为：abcdef

**示例一：** 读取文件内容（英文），一个字节一个字节地读取。

public class FileStreamDemo {
        
    
        public static void main(String[] args) {
        
            // 文件绝对路径名
            String name = "E:\\zzc\\temp.txt";
            FileInputStream fis = null;
            try {
        
                fis = new FileInputStream(name);
    
                // 开始读
                // read() 方法返回的是：读取到的“字节”本身。
                // 例如：读取到的字符是'a'，则返回97
                int data = fis.read();
                System.out.println(data); // 97
    
                data = fis.read();
                System.out.println(data); // 98
    
                data = fis.read();
                System.out.println(data); // 99
    
                data = fis.read();
                System.out.println(data); // 100
    
                data = fis.read();
                System.out.println(data); // 101
    
                data = fis.read();
                System.out.println(data); // 102
    
                // 读取到文件末尾返回 -1
                data = fis.read();
                System.out.println(data); // -1
            } catch (Exception e) {
        
                e.printStackTrace();
            } finally {
        
                if (null != fis) {
        
                    try {
        
                        fis.close();
                    } catch (IOException e) {
        
                        e.printStackTrace();
                    }
                }
            }
        }
    }

注意：如果文件中的内容包含中文，再一个字节一个字节地读取，那么输出出来会出现乱码。因为，在 Java 中，汉字至少用了 2 个字节编码。如果按照上面示例，一个字节一个字节地输出，那么，这样只是截取了汉字的一部分，肯定会乱码。

**【扩展知识】：**

**内码**：`String`、`char` 运行在内存中的编码  
**外码**：!内码。如：class 文件中的 `char/String` 类型、序列化的 `char/String` 类型

UTF-8：英文字符占用一个字节；绝大多数汉字占用三个字节，个别汉字占用四个字节  
UTF-16：英文字符占两个字节；绝大多数汉字(尤其是常用汉字)占用两个字节，个别汉字占用四个字节

在 Java 中，内码使用 UTF-16；外码使用 UTF-8。`char` 类型数据占用 2 个字节是针对内码的。

temp.txt 文件中只有一个汉字“我”，然后用

try (FileInputStream in = new FileInputStream("temp.txt")) {
        
        int len = in.read();
        System.out.println(len);
        len = in.read();
        System.out.println(len);
        len = in.read();
        System.out.println(len);
    } catch (IOException e) {
        
        e.printStackTrace();
    }

它会输出：

230
    136
    145

结果表明：汉字“我”用了3个字节编码，每一个字节对应的 ASCII 码值分别为：230、136、145。

**示例二：** 读取文件内容（英文）。循环地一个字节一个字节地读取。

如果一个文件内容巨多，照上面那种方式肯定就不行了。所以，下面用循环的方式进行读取。

public class FileStreamDemo {
        
    
        public static void main(String[] args) {
        
            // 文件绝对路径名
            String name = "E:\\zzc\\temp.txt";
            FileInputStream fis = null;
            try {
        
                fis = new FileInputStream(name);
                int data = 0;
                while ((data = fis.read()) != -1) {
        
                    System.out.println(data);
                }
            } catch (Exception e) {
        
                e.printStackTrace();
            } finally {
        
                if (null != fis) {
        
                    try {
        
                        fis.close();
                    } catch (IOException e) {
        
                        e.printStackTrace();
                    }
                }
            }
        }
    }

但是，上面还会有一个问题：就是一次只读取一个字节，那么要读取所有字节，就要读取多次。这就会意味着内存要和磁盘频繁交互，这样性能会严重降低。所以，就要考虑一次能否读取多个字节。

查看 API 文档，可知：调用 `read(byte[] b)` 方法

**示例三：** 读取文件内容（英文）。多个字节多个字节地读取

public class FileStreamDemo {
        
    
        public static void main(String[] args) throws Exception{
        
            // 文件绝对路径名
            String name = "E:\\zzc\\temp.txt";
            FileInputStream fis = new FileInputStream(name);
            byte[] bytes = new byte[4];
            
            int length = 0;
            while ((length = fis.read(bytes)) != -1) {
        
                // 将 byte 数组转换成字符串
                System.out.print(new String(bytes, 0, length));
            }
    
            if (null != fis) {
        
                fis.close();
            }
        }
    }

说明：

1.  `new String(bytes, 0, length)`：将字节转换为字符串

【总结】：使用文件字节输入流读取文件有三种：

1.  `int len = in.read();` ：一次只读取一个字节，返回值是该字节对应的 ASCII 码值。如：读取了一个英文字符 `I`，则它返回 `73`。因为大写的 `I` 对应的 ASCII 码为 73。但是，如果读取的是一个汉字，则需要读取三次才能读完，因为常用的汉字用 3 个字节编码，不常用的汉字用 4 个字节编码。
2.  `while ((len = in.read()) != -1) {}`：一次只读一个字节，然后，循环读取。
3.  `byte[] bytes = new byte[1024]; while ((len = in.read(bytes)) != -1) {}`：循环多个字节读取

#### 3.1.2 FileOutputStream ####

`FileOutputStream`：文件字节输出流

`FileOutputStream` 类的 `write()` 方法有四个重载形式：

1.  `public void write(int b)`：将指定的字节写入到文件输出流
2.  `private native void write(int b, boolean append)`：是否追加
3.  `public void write(byte b[])`：将字节数组写入到文件输出流
4.  `public void write(byte b[], int off, int len)`：将字节数组中的一部分写入到文件输出流

场景：使用文件输出流向磁盘某个文件写入数据

**示例一：**

public class FileOutputStreamDemo {
        
    
        public static void main(String[] args) throws Exception{
        
            // temp.txt 文件不存在时，会自动新建
            FileOutputStream fos = new FileOutputStream("temp.txt");
            byte[] bytes = {
        97, 98, 99, 100};
    
            fos.write(bytes);
            // 写完之后，一定要刷新
            fos.flush();
            fos.close();
        }
    }

注意：如果文件不存在，则会新建文件。但是有一个前提，此文件所在的父级目录必须存在，否则，就会报错！！

如：`FileOutputStream fos = new FileOutputStream("E:/zzc/temp.txt");`

如果 E 盘下面没有 zzc 文件夹，那么，这行代码就会报错 `java.io.FileNotFoundException: E:\zzc\temp.txt (系统找不到指定的路径。)`。所以，必须保证文件的父级目录存在。

而且每次向此文件中写入数据之前，都会清空此文件。

> 那么，每次向此文件写入数据时，能不能向此文件中追加内容呢？

使用这个构造方法：

*  FileOutputStream(String name, boolean append):创建一个向具有指定 name 的文件中写入数据的输出文件流。如果第二个参数为 true，则将字节写入文件末尾处，而不是写入文件开始处。

> 如何向文件中写入汉字呢？

使用如下方式：

String data = "我爱中国";
    // 将字符串转换为字节数组
    byte[] bytes = data.getBytes();
    fos.write(bytes);

说明：

1.  `byte[] bytes = data.getBytes();` 将 `String` 转换为字节类型

#### 3.1.3 使用文件字节流 ####

场景：使用文件字节流实现文件的赋值：把文件 temp.txt 中的内容复制到 test.txt 文件中去。

**示例：**

public class FileStreamDemo {
        
    
        public static void main(String[] args) throws Exception{
        
            FileInputStream fis = new FileInputStream("E:\\zzc\\temp.txt");
            FileOutputStream fos = new FileOutputStream("E:\\zzc\\test.txt");
    
            byte[] bytes = new byte[1024];
            int len = 0;
            while ((len = fis.read(bytes)) != -1) {
        
                fos.write(bytes, 0, len);
            }
    
            if (null != fos) {
        
                fos.flush();
            }
            if (null != fis) {
        
                fis.close();
            }
            fos.close();
        }
    }

不想手动关闭流，即：调用 `close()` 方法，可使用 `try-with-resources` 结构改进，如下：

public class FileStreamDemo {
        
    
        public static void main(String[] args) throws Exception{
        
            FileInputStream fis = new FileInputStream("E:\\zzc\\temp.txt");
            FileOutputStream fos = new FileOutputStream("E:\\zzc\\test.txt");
    
            try (FileInputStream in = new FileInputStream("E:\\zzc\\temp.txt");
            FileOutputStream out = new FileOutputStream("E:\\zzc\\test.txt")) {
        
                int length = 0;
                byte[] bytes = new byte[1024];
                while ((length = in.read(bytes)) != -1) {
        
                    out.write(bytes, 0 , length);
                }
            } catch (IOException e) {
        
                e.printStackTrace();
            }
        }
    }

如果还有不清楚 `try-with-resources` 结构的同学，可查看博文：[【Exception】如何使用 try-with-resources 优雅地关闭资源][Exception_ try-with-resources]

### 3.2 FileReader/FileWriter ###

#### 3.2.1 FileReader ####

FileReader：文件字符输入流，只能读取普通文本，方便、快捷

`FileReader` 类的 `read()` 方法有两个重载形式：

1.  `public int read()`：读取单个字符，返回值为 int 类型，代表该字符的 ascii 码值
2.  `public int read(char [] c, int offset, int len)`：读取若干字符到字符数组中，返回值为读取的字符数
3.  `public int read(char cbuf[])`：它的父类 `Reader`的方法。读取若干字符到字符数组中，返回值为读取的字符数

场景：使用文件字符输入流读取一个txt文件（包含中文）

**示例：**

public class FileReaderDemo {
        
    
        public static void main(String[] args) throws Exception{
        
            FileReader fr = new FileReader("temp.txt");
    
            char[] chars = new char[4];
            int length = 0;
            while ((length = fr.read(chars)) != -1) {
        
                System.out.print(new String(chars, 0, length));
            }
            fr.close();
        }
    }

#### 3.2.2 FileWriter ####

`FileWriter`：文件字符输出流，只能写普通文本

`FileWriter` 的父类 `Writer` 的 `write()` 方法重载形式：

1.  `public void write(int c)`：
2.  `public void write(char cbuf[])`：
3.  `public void write(char cbuf[], int off, int len)`：
4.  `public void write(String str)`：
5.  `public void write(String str, int off, int len)`：

场景：使用文件字符输出流向一个txt文件写入数据（包含中文）

public class FileWriterDemo {
        
    
        public static void main(String[] args) throws Exception {
        
            FileWriter fw = new FileWriter("fw.txt");
            
            char[] chars = {
        '我', '是', '中', '国', '人'};
            fw.write(chars);
            fw.flush();
            fw.close();
        }
    }

### 3.3 BufferedReader/BufferedWriter ###

#### 3.3.1 BufferedReader ####

BufferedReader：带有缓冲区的字符输入流。使用此流时，不需要自定义 byte/char 数组。自带缓冲。

**示例一：**

public class BufferedReaderDemo {
        
    
        public static void main(String[] args) throws Exception {
        
            BufferedReader br = new BufferedReader(new FileReader("temp.txt"));
    
            String line = null;
            while (null != (line = br.readLine())) {
        
                System.out.print(line);
            }
    
            br.close();
        }
    }

**示例二：**

public class BufferedReaderDemo {
        
    
        public static void main(String[] args) throws Exception {
        
            BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("temp.txt")));
    
            String line = null;
            while (null != (line = br.readLine())) {
        
                System.out.print(line);
            }
    
            br.close();
        }
    }

**示例一与示例二的区别**：示例二中使用了字节流来读取 temp.txt，但 BufferedReader 的构造方法中只能传入 Reader 类型的参数。所以，这里使用了 字节输入流来转换。

这里 BufferedWriter 就不说了。

### 3.4 DataOutputStream/DataInputStream ###

DataOutputStream：此流可以将数据以及数据类型写入文件中。  
注意：此文件不是普通文件（无法用记事本打开）

### 3.5 PrintStream/PrintWriter ###

此类流是标准输出流。

#### 3.5.1 PrintStream ####

PrintStream 是字节输出流，默认输出到控制台。

**示例：**

public class PrintStreamDemo {
        
    
        public static void main(String[] args) {
        
            String msg = "Hello PS";
            PrintStream out = System.out;
            // System.out.println(msg);
            out.println(msg);
        }
    }

> 既然是默认输出到控制台。那么可以改变标准输出流的方向吗？

当然可以。

public class PrintWriterDemo {
        
    
        public static void main(String[] args) throws Exception{
        
            // 标准输出流不再指向控制台，而是指向 log 文件
            PrintStream ps = new PrintStream(new FileOutputStream("log"));
            // 修改输出方向，将输出方向从控制台修改为 log 文件
            System.setOut(ps);
            ps.print("我是中国人");
        }
    }

#### 3.5.2 PrintWriter ####

**示例：**

public class PrintWriterDemo {
        
    
        public static void main(String[] args) throws Exception{
        
            // 若此文件不存在，则创建
            PrintWriter pw = new PrintWriter("pw.txt");
            String data = "Hello PrintWriter";
            pw.write(data);
    
            // 使用字符输出流，则需要调用 flush() 方法
            // 字符内部也是用字节。相当于字符内部有缓存区，如果不调用 flush() 方法，那么数据只会存留在缓冲区中，
            // 并不会输出到文本中去
            pw.flush();
            // 当调用 close() 时，它会先调用 flush() 方法。即使不显示调用 flush() 方法
            pw.close();
        }
    }

### 3.6 ObjectOutputStream/ObjectInputStream ###

主要用于：对象的序列化和反序列化

**示例（序列化）：**

public class User implements Serializable {
        
        private static final long serialVersionUID = -2002612691013855369L;
    
        private String name;
        private int age;
    
        public User(String name, int age) {
        
            this.name = name;
            this.age = age;
        }
        ...
    }

User 类实现了 Serializable 接口

public class ObjectOutputStreamDemo {
        
    
        public static void main(String[] args) throws Exception{
        
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("users.txt"));
            User user = new User("zzc", 18);
            oos.writeObject(user);
    
            oos.flush();
            oos.close();
        }
    }

注意：参与序列化和反序列化的对象都要实现 Serializable 接口。

### 3.7 关于内存的流 ###

public class MemoryStream {
        
    
        public static void main(String[] args) throws Exception{
        
            // 1. 内存字节流
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            String data = "Hello Memory";
            // 将数据写入内存
            baos.write(data.getBytes());
            // 获取内存中的数据
            byte[] bytes = baos.toByteArray();
            //System.out.println(new String(bytes));
            baos.close();
    
            ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
            int ch;
            while ((ch = bais.read()) != -1) {
        
                System.out.print((char) ch);
            }
            bais.close();
    
    
            // 2. 内存字符数组流
            CharArrayWriter caw = new CharArrayWriter();
            char[] chs = {
        'H', 'e', 'l', 'l', 'o'};
            caw.write(chs);
            caw.close();
    
            // 返回内存中数据的引用
            char[] data = caw.toCharArray();
            CharArrayReader car = new CharArrayReader(data);
            int ch;
            while ((ch = car.read()) != -1) {
        
                System.out.print((char) ch);
            }
            car.close();
    
    
            // 3. 内存字符串流
            StringWriter sw = new StringWriter();
            String data = "Hello World";
            sw.write(data);
            sw.close();
    
            String s = sw.toString();
            StringReader sr = new StringReader(s);
            int ch;
            while((ch = sr.read()) != -1) {
        
                System.out.print((char) ch);
            }
            sr.close();
        }
    }

好了，一些流的基本使用就到这儿了。多看看它们的 API 文档吧。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0x1Y2t5X0JveV9MdWNr_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20201022214520892.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0x1Y2t5X0JveV9MdWNr,size_16,color_FFFFFF,t_70
[Exception_ try-with-resources]: https://blog.csdn.net/sco5282/article/details/119116440