来源：哪吒编程

很多朋友问我，如何才能学好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();

        }

    }

}

2、InputStreamReader 代码示例

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

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

        }

    }

}