一文搞定Java IO流，输入流、输出流、字符流、缓冲流，附详细代码示例

妖狐艹你老母 2023-10-14 02:59 17阅读 0赞

很多朋友问我，如何才能学好IO流，对各种流的概念，云里雾里的，不求甚解。用到的时候，现百度，功能虽然实现了，但是为什么用这个？不知道。更别说效率问题了~

下次再遇到，再百度，“良性循环”。

今天，我就用一天的时间，整理一下关于Java I/O流的知识点，分享给大家。

每一种IO流，都配有示例代码，大家可以跟着敲一遍，找找感觉~

## 一、InputStream ##

InputStream 代表一个输入流，它是一个抽象类，不能被实例化。InputStream 定义了一些通用方法，如 read() 和 skip() 等，用于从输入流中读取数据。常用的 InputStream 实现类包括：

## 1、FileInputStream的代码示例 ##

下面是使用 FileInputStream 读取文件内容的示例代码：

java复制代码import java.io.*;
    
    public class FileInputStreamExample {
    
        public static void main(String[] args) {
            // 要读取的文件路径和名称
            String filePath = "C:/example/file.txt";
            // 创建输入流对象
            FileInputStream fis = null;
    
            try {
                fis = new FileInputStream(filePath);
                byte[] buffer = new byte[1024];
                int len;
                // 使用 while 循环读取文件，每次最多读取 1024 个字节
                while ((len = fis.read(buffer)) != -1) {
                    // 将读取的字节转换为字符串，并输出到控制台
                    String content = new String(buffer, 0, len, "UTF-8");
                    System.out.println(content);
                }
            } catch (FileNotFoundException e) {
                System.out.println("File not found: " + filePath);
            } catch (IOException e) {
                System.out.println("Error reading file: " + e.getMessage());
            } finally {
                // 关闭输入流
                try {
                    if (fis != null) {
                        fis.close();
                    }
                } catch (IOException e) {
                    System.out.println("Error closing file: " + e.getMessage());
                }
            }
        }
    }

示例代码说明：

*  在示例中，我们首先指定要读取的文件路径和名称。在实际使用中，您应该将其替换为实际的文件路径和名称。
 *  然后，我们使用文件路径创建一个FileInputStream对象。注意，在创建FileInputStream对象时，我们必须提供要读取的文件的路径和名称。
 *  接着，我们使用while循环从FileInputStream对象中读取数据。每次循环中，我们使用read()方法读取最多1024字节，并将读取的字节存储在一个缓冲区中。然后，我们将读取的字节转换为字符串，并在控制台上输出。在while循环结束后，我们关闭FileInputStream对象。
 *  **注意**：在使用FileInputStream类时，我们需要确保文件存在，并且我们有读取文件的权限。此外，在实际应用中，可能需要根据需要使用更高效的方法读取大型文件，以避免IO开销的问题。

## 2、ByteArrayInputStream的代码示例 ##

下面是使用 ByteArrayInputStream 读取字节数组内容的示例代码：

java复制代码import java.io.*;
    
    public class ByteArrayInputStreamExample {
    
        public static void main(String[] args) {
            byte[] bytes = { 72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33 };
            // 创建字节输入流对象
            ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
    
            try {
                byte[] buffer = new byte[1024];
                int len;
                // 使用 while 循环读取字节数组中的内容，每次最多读取 1024 个字节
                while ((len = bais.read(buffer)) != -1) {
                    // 将读取的字节转换为字符串，并输出到控制台
                    String content = new String(buffer, 0, len, "UTF-8");
                    System.out.println(content);
                }
            } catch (IOException e) {
                System.out.println("Error reading byte array: " + e.getMessage());
            } finally {
                // 关闭输入流
                try {
                    if (bais != null) {
                        bais.close();
                    }
                } catch (IOException e) {
                    System.out.println("Error closing byte array input stream: " + e.getMessage());
                }
            }
        }
    }

**示例代码说明:**

*  在示例中，我们首先创建了一个字节数组，其中包含ASCII码为72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33的字符序列"Hello World!"。
 *  然后，我们使用字节数组创建了一个ByteArrayInputStream对象。注意，在创建ByteArrayInputStream对象时，我们必须提供要从中读取的字节数组。
 *  接着，我们使用while循环从ByteArrayInputStream对象中读取数据。每次循环中，我们使用read()方法读取最多1024字节，并将读取的字节存储在一个缓冲区中。然后，我们将读取的字节转换为字符串，并在控制台上输出。在while循环结束后，我们关闭ByteArrayInputStream对象。
 *  **注意**：在使用ByteArrayInputStream类时，字节数组是一次性全部加载到内存中的，如果字节数组较大，可能会导致内存不足的问题。此外，在实际应用中，可能需要使用更高效的数据源（如文件或网络流）来存储数据，以避免内存限制的问题。

## 3、PipedInputStream的代码示例 ##

PipedInputStream：管道输入流，用于线程之间的通信。

java复制代码import java.io.IOException;
    import java.io.PipedInputStream;
    import java.io.PipedOutputStream;
    
    public class PipedInputStreamExample {
    
        public static void main(String[] args) throws Exception {
            
            // 创建一对PipedInputStream和PipedOutputStream
            PipedInputStream input = new PipedInputStream();
            PipedOutputStream output = new PipedOutputStream(input);
    
            // 创建一个写线程
            Thread writerThread = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        // 写入一些数据到PipedOutputStream
                        output.write("Hello, World!".getBytes());
                        output.close(); // 关闭PipedOutputStream
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            });
    
            // 创建一个读线程
            Thread readerThread = new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        // 读取PipedInputStream中的数据
                        int data;
                        while ((data = input.read()) != -1) {
                            System.out.print((char) data); // 将数据打印到控制台
                        }
                        input.close(); // 关闭PipedInputStream
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            });
    
            // 启动写线程和读线程
            writerThread.start();
            readerThread.start();
    
            // 等待写线程和读线程完成
            writerThread.join();
            readerThread.join();
        }
    }

**代码说明**

PipedInputStream和PipedOutputStream是Java IO库提供的一对**管道流**，可以用于数据的发送和接收。

*  在示例中，我们首先创建了一个PipedInputStream和一个PipedOutputStream。它们被连接在一起，使得我们可以像使用一个普通的输入流- 和输出流一样进行读写操作。
 *  接着，我们创建一个写线程来向管道中写入数据。在这个例子中，我们写入了字符串"Hello, World!"。
 *  然后，我们创建一个读线程来从管道中读取数据。我们使用了一个while循环来读取数据，直到遇到了流的末尾。
 *  **最后**，我们启动写线程和读线程，等待它们完成，然后关闭流。
 *  **注意**：如果读线程在数据被写入管道之前就开始读取流，它将会阻塞（即等待数据被写入）。
 *  **另外**，还要注意线程之间的同步问题。在这个例子中，我们使用了一个简单的join()方法来等待写线程和读线程完成。在实际使用中，您可能需要使用更高级的同步机制来确保线程之间的正确协作。

## 二、 OutputStream ##

OutputStream 代表一个输出流，它也是一个抽象类，不能被实例化。OutputStream 定义了一些通用方法，如 write() 和 flush() 等，用于向输出流中写入数据。常用的 OutputStream 实现类包括：

## 1、FileOutputStream代码示例 ##

文件输出流，用于向文件中写入数据。

java复制代码import java.io.*;
    
    public class FileOutputStreamExample {
    
        public static void main(String[] args) {
            // 要写入的文件路径和名称
            String filePath = "C:/example/output.txt";
            // 要写入文件的内容
            String content = "Hello, World!";
            // 创建输出流对象
            FileOutputStream fos = null;
    
            try {
                fos = new FileOutputStream(filePath);
                // 将字符串转换为字节数组，并将其写入文件
                fos.write(content.getBytes("UTF-8"));
                // 刷新输出流
                fos.flush();
                // 输出提示信息
                System.out.println("Content has been written to " + filePath);
            } catch (FileNotFoundException e) {
                System.out.println("File not found: " + filePath);
            } catch (IOException e) {
                System.out.println("Error writing file: " + e.getMessage());
            } finally {
                // 关闭输出流
                try {
                    if (fos != null) {
                        fos.close();
                    }
                } catch (IOException e) {
                    System.out.println("Error closing file: " + e.getMessage());
                }
            }
        }
    }

**示例代码说明:**

*  在示例中，我们首先指定要写入的文件路径和名称。在实际使用中，您应该将其替换为实际的文件路径和名称。
 *  **然后**，我们创建一个用于写入文件的输出流对象。在创建**FileOutputStream**对象时，如果文件不存在，Java将会自动创建它。
 *  **接着**，我们将要写入的内容转换为字节数组，并使用**write**()方法将其写入文件。
 *  **然后**，我们使用flush()方法刷新输出流。在文件操作完成后，我们应该始终调用flush()方法以确保所有数据都被写入到磁盘上的文件中。
 *  **最后**，我们关闭**FileOutputStream**对象，即使在发生异常时也应该关闭。
 *  **注意**：在使用**FileOutputStream**类时，我们需要确保文件存在，并且我们有写入文件的权限。此外，在实际应用中，可能需要使用更高效的方法来写入大型文件，以避免**IO开销**的问题。

## 2、ByteArrayOutputStream代码示例： ##

字节数组输出流，用于将数据写入内存中的字节数组中。

java复制代码import java.io.*;
    
    public class ByteArrayOutputStreamExample {
    
        public static void main(String[] args) {
            // 创建字节数组输出流对象
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
    
            try {
                // 将字符串转换为字节数组，并写入到字节数组输出流中
                baos.write("Hello, World!".getBytes("UTF-8"));
                // 将字节数组输出流中的数据转换为字节数组
                byte[] bytes = baos.toByteArray();
                // 将字节数组转换为字符串，并输出到控制台
                String content = new String(bytes, "UTF-8");
                System.out.println(content);
            } catch (IOException e) {
                System.out.println("Error writing to byte array: " + e.getMessage());
            } finally {
                // 关闭字节数组输出流
                try {
                    if (baos != null) {
                        baos.close();
                    }
                } catch (IOException e) {
                    System.out.println("Error closing byte array output stream: " + e.getMessage());
                }
            }
        }
    }

**示例代码说明:**

*  在示例中，我们首先创建了一个**ByteArrayOutputStream**对象，用于向内存中的字节数组中写入数据。
 *  **然后**，我们将要写入的内容转换为字节数组，并使用write()方法将其写入**ByteArrayOutputStream**对象。
 *  **接着**，我们调用toByteArray()方法将**ByteArrayOutputStream**对象中的数据转换为字节数组。需要注意的是，要在调用toByteArray()方法之前先关闭**ByteArrayOutputStream**。
 *  **最后**，我们将字节数组转换为字符串，并将其输出到控制台。
 *  **注意**：在使用**ByteArrayOutputStream**类时，需要注意内存占用问题。BytesArrayOutputStream类主要用于在内存中临时存储数据。对于**大数据**，可能需要使用其他方式存储。

## 3、PipedOutputStream代码示例： ##

管道输出流，用于线程之间的通信。

java复制代码import java.io.*;
    
    public class PipedOutputStreamExample {
    
        public static void main(String[] args) {
            // 创建一对PipedInputStream和PipedOutputStream
            PipedInputStream input = new PipedInputStream();
            PipedOutputStream output = new PipedOutputStream();
    
            try {
                // 将输入流和输出流连接起来
                input.connect(output);
    
                // 创建一个写线程
                Thread writerThread = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            // 写入一些数据到PipedOutputStream
                            output.write("Hello, World!".getBytes("UTF-8"));
                            // 刷新PipedOutputStream
                            output.flush();
                            // 关闭PipedOutputStream
                            output.close();
                        } catch (IOException e) {
                            System.out.println("Error writing to pipe: " + e.getMessage());
                        }
                    }
                });
    
                // 创建一个读线程
                Thread readerThread = new Thread(new Runnable() {
                    @Override
                    public void run() {
                        try {
                            // 读取PipedInputStream中的数据
                            byte[] buffer = new byte[1024];
                            int len = input.read(buffer);
                            // 将读取的字节转换为字符串，并输出到控制台
                            String content = new String(buffer, 0, len, "UTF-8");
                            System.out.println(content);
                            // 关闭PipedInputStream
                            input.close();
                        } catch (IOException e) {
                            System.out.println("Error reading from pipe: " + e.getMessage());
                        }
                    }
                });
    
                // 启动写线程和读线程
                writerThread.start();
                readerThread.start();
    
                // 等待写线程和读线程完成
                writerThread.join();
                readerThread.join();
            } catch (IOException | InterruptedException e) {
                System.out.println("Error communicating between threads: " + e.getMessage());
            }
        }
    }

**示例代码说明:**

*  在示例中，我们首先创建了一对**PipedInputStream**和**PipedOutputStream**，用于在线程之间进行通信。
 *  **接着**，我们使用connect()方法将**PipedInputStream**和**PipedOutputStream**连接起来。
 *  **然后**，我们创建一个**写线程**和一个**读线程**。在写线程中，我们向**PipedOutputStream**写入数据，并使用flush()和close()方法刷新和关闭输出流。在读线程中，我们从**PipedInputStream**读取数据，并将其转换为字符串并打印到控制台。在读操作完成后，我们关闭输入流
 *  **最后**，我们启动**写线程**和**读线程**，并等待它们完成。
 *  **注意**：在使用**PipedInputStream**和**PipedOutputStream**类时，需要考虑线程同步问题，以确保在线程之间正确地交换数据。在实际应用中，您可能需要使用更高级的同步机制来确保线程之间的协作。

## 三、字符输入流Reader ##

除了字节流，Java 还提供字符流，字符流类似于字节流，不同之处在于字符流是按字符读写数据，而不是按字节。Java 中最基本的字符流是 Reader 和 Writer，它们是基于 InputStream 和 OutputStream 的转换类，用于完成字节流与字符流之间的转换。

常用的实现类包括 FileReader 和 InputStreamReader等

## 1、FileReader 代码示例 ##

java复制代码import java.io.FileReader;  // 引入 FileReader 类
    import java.io.IOException; // 引入 IOException 类
    
    public class FileReaderExample {
        public static void main(String[] args) {
            // 定义文件路径
            String filePath = "example.txt";
    
            try {
                // 创建 FileReader 对象
                FileReader fileReader = new FileReader(filePath);
    
                // 读取字符
                int character;
                while ((character = fileReader.read()) != -1) {
                    // 打印字符
                    System.out.print((char) character);
                }
    
                // 关闭 FileReader 对象
                fileReader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

## 2、InputStreamReader 代码示例 ##

java复制代码import java.io.BufferedReader; // 引入 BufferedReader 类
    import java.io.IOException;    // 引入 IOException 类
    import java.io.InputStreamReader; // 引入 InputStreamReader 类
    
    public class InputStreamReaderExample {
        public static void main(String[] args) {
    
            try {
                // 创建 InputStreamReader 对象
                InputStreamReader inputStreamReader = new InputStreamReader(System.in);
    
                // 创建 BufferedReader 对象
                BufferedReader bufferedReader = new BufferedReader(inputStreamReader);
    
                // 获取用户输入
                System.out.println("请输入字符串：");
                String inputString = bufferedReader.readLine();
    
                // 打印用户输入
                System.out.println("您输入的字符串是：" + inputString);
    
                // 关闭 BufferedReader 对象
                bufferedReader.close();
    
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

## 四、字符输出流Writer ##

## 1、FileWriter代码示例 ##

java复制代码import java.io.*;
    
    public class FileWriterExample {
        public static void main(String[] args) {
            FileWriter writer = null;
    
            try {
                writer = new FileWriter("example.txt");
                writer.write("Hello World!");
                writer.close();
            } catch (IOException e) {
                System.out.println("Error: " + e.getMessage());
            } finally {
                try {
                    if (writer != null)
                        writer.close();
                } catch (IOException e) {
                    System.out.println("Error: " + e.getMessage());
                }
            }
        }
    }

**示例代码说明:**

*  在这个例子中，创建了一个**FileWriter**对象 writer，并将字符串"Hello World!"写入文件 "example.txt"。然后，我们使用close()方法关闭写入器以确保所有的数据都被刷新到磁盘。
 *  **注意**：在使用FileWriter时，要确保在不再需要它时关闭它以确保所有的字符都被刷新到文件中。如果您使用**Java7**或更高版本，可以考虑使用try-with-resources语句，这样您就不需要显式地关闭写入器。

## 2、OutputStreamWriter代码示例 ##

java复制代码import java.io.*;
    
    public class OutputStreamWriterExample {
        public static void main(String[] args) {
            FileOutputStream outputStream = null;
            OutputStreamWriter writer = null;
    
            try {
                outputStream = new FileOutputStream("example.txt");
                writer = new OutputStreamWriter(outputStream, "UTF-8");
                writer.write("Hello World!");
                writer.close();
            } catch (IOException e) {
                System.out.println("Error: " + e.getMessage());
            } finally {
                try {
                    if (writer != null)
                        writer.close();
                    if (outputStream != null)
                        outputStream.close();
                } catch (IOException e) {
                    System.out.println("Error: " + e.getMessage());
                }
            }
        }
    }

**示例代码说明:**

*  在这个例子中，创建了一个**FileOutputStream**对象 **outputStream** 用于写入文件 "example.txt"。接着，创建了一个**OutputStreamWriter**对象 writer，它被用于将字符串"Hello World!"写入到文件中。指定了"UTF-8"作为字符编码。
 *  **最后**，使用close()方法关闭写入器和输出流以确保所有的数据都被刷新到磁盘上。
 *  **注意**：在使用**OutputStreamWriter**时，要确保在不再需要它时关闭它以确保所有的字符都被刷新到文件中。如果您使用Java 7或更高版本，可以考虑使用try-with-resources语句，这样您就不需要显式地关闭写入器和输出流。

## 五、缓冲流 ##

BufferedInputStream 和 BufferedOutputStream 是 I/O 包中提供的缓冲输入输出流。它们可以提高 I/O 操作的效率，具有较好的缓存机制，能够减少磁盘操作，缩短文件传输时间。使用 BufferedInputStream 和 BufferedOutputStream 进行读取和写入时，Java 会自动调整缓冲区的大小，使其能够适应不同的数据传输速度。

## 缓冲流代码示例 ##

java复制代码import java.io.BufferedInputStream;   // 引入 BufferedInputStream 类
    import java.io.BufferedOutputStream;  // 引入 BufferedOutputStream 类
    import java.io.FileInputStream;        // 引入 FileInputStream 类
    import java.io.FileOutputStream;       // 引入 FileOutputStream 类
    import java.io.IOException;            // 引入 IOException 类
    
    public class BufferedStreamsExample {
        public static void main(String[] args) {
    
            String sourceFile = "source.txt";
            String targetFile = "target.txt";
    
            try {
                // 创建 BufferedInputStream 和 BufferedOutputStream 对象
                BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(sourceFile));
                BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(targetFile));
    
                // 读取数据，直到读取的内容为-1
                int data;
                while ((data = bufferedInputStream.read()) != -1) {
                    bufferedOutputStream.write(data);
                }
    
                // 关闭 BufferedInputStream 和 BufferedOutputStream 对象
                bufferedInputStream.close();
                bufferedOutputStream.close();
    
                // 打印成功信息
                System.out.println("复制文件成功！");
    
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

## 六、对象流 ##

可以读取或写入 Java 对象的流，比较典型的对象流包括ObjectInputStream 和 ObjectOutputStream。

对象流需要将对象序列化和反序列化为字节序列，使用 ObjectInputStream 和 ObjectOutputStream 可以将 Java 对象转换为字节流进行传输或存储。

在网络传输和文件存储中，ObjectInputStream 和 ObjectOutputStream 通常会被使用到。

## 对象流代码示例 ##

java复制代码import java.io.FileInputStream;          // 引入 FileInputStream 类
    import java.io.FileOutputStream;         // 引入 FileOutputStream 类
    import java.io.ObjectInputStream;        // 引入 ObjectInputStream 类
    import java.io.ObjectOutputStream;       // 引入 ObjectOutputStream 类
    import java.io.Serializable;             // 引入 Serializable 接口
    
    class Person implements Serializable {
        String name;
        int age;
    
        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        public String toString() {
            return "姓名：" + name + "\n年龄：" + age;
        }
    }
    
    public class ObjectStreamsExample {
        public static void main(String[] args) {
    
            String filePath = "person.dat";
    
            // 创建 Person 对象
            Person person = new Person("Alice", 20);
    
            try {
                // 创建 ObjectOutputStream 对象
                ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(filePath));
    
                // 将 Person 对象写入文件
                objectOutputStream.writeObject(person);
    
                // 关闭 ObjectOutputStream 对象
                objectOutputStream.close();
    
                // 创建 ObjectInputStream 对象
                ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(filePath));
    
                // 从文件中读取 Person 对象
                Person personFromFile = (Person) objectInputStream.readObject();
    
                // 关闭 ObjectInputStream 对象
                objectInputStream.close();
    
                // 打印读取的对象
                System.out.println(personFromFile);
    
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }