大家好，我是哪吒。

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

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

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

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

一、InputStream

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

1、FileInputStream的代码示例

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

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 读取字节数组内容的示例代码：

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：管道输入流，用于线程之间的通信。

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代码示例

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

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代码示例：

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

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代码示例：

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

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 代码示例

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

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

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代码示例

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 会自动调整缓冲区的大小，使其能够适应不同的数据传输速度。

缓冲流代码示例

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 通常会被使用到。

对象流代码示例

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