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

大家好，我是哪吒。

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