IO 的分类

tip：作为程序员一定学习编程之道，一定要对代码的编写有追求，不能实现就完事了。我们应该让自己写的代码更加优雅，即使这会费时费力。

推荐：体系化学习Java（Java面试专题）

Java IO 按数据操作方式进行分类

Java IO 按照数据操作方式进行分类，通常分为以下几类：

1. 字节流（Byte Stream）：以字节为单位进行操作，包括 InputStream 和 OutputStream 等类。字节流可以用于读写二进制文件、网络数据等。

2. 字符流（Character Stream）：以字符为单位进行操作，包括 Reader 和 Writer 等类。字符流可以处理文本文件、网络数据等。

3. 缓冲流（Buffered Stream）：通过缓冲区来提高 I/O 效率，包括 BufferedInputStream、BufferedOutputStream、BufferedReader 和 BufferedWriter 等类。

4. 数据流（Data Stream）：提供了读写基本数据类型和字符串的方法，包括 DataInputStream 和 DataOutputStream 等类。

5. 对象流（Object Stream）：用于读写 Java 对象，包括 ObjectInputStream 和 ObjectOutputStream 等类。

6. 文件流（File Stream）：用于读写文件的流，包括 FileInputStream 和 FileOutputStream 等类。

以上是 Java IO 常见的分类方式，不同类型的流在使用时需要根据具体情况进行选择。

一、字节流 InputStream 、OutputStream

 package com.pany.camp.io;

import cn.hutool.core.thread.ThreadUtil;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class ByteStreamExample {

    public static void main(String[] args) throws IOException {

        String content = "Hello, World!";
        FileOutputStream output = new FileOutputStream("data.txt");
        output.write(content.getBytes());
        output.close();
        System.out.println("内容已成功写入文件！");

        ThreadUtil.sleep(5000);

        InputStream input = new FileInputStream("data.txt");
        byte[] buffer = new byte[1024];
        int len = input.read(buffer);
        input.close();
        String content1 = new String(buffer, 0, len);
        System.out.println(content1);
    }
}

我们首先创建了一个字符串变量 content，表示要写入文件的内容。然后，我们创建了一个 FileOutputStream 对象，并指定要写入的文件名为 “data.txt”。接下来，我们使用 write() 方法将字符串转换为字节数组，并将其写入到输出流中。最后，我们关闭输出流。
我们使用 FileInputStream 创建了一个输入流，并指定要读取的文件名为 “data.txt”。然后，我们创建了一个 byte 数组作为缓冲区，并使用 read() 方法从输入流中读取数据，并将其存储在缓冲区中。最后，我们关闭输入流，并使用 String 类的构造函数将缓冲区中的字节转换为字符串，并将其输出到控制台。

二、字符流 InputStream 、OutputStream

package com.pany.camp.io;

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;
public class ReaderWriterExample {

    public static void main(String[] args) throws IOException {
        Reader reader = new FileReader("data.txt");
        Writer writer = new FileWriter("data1.txt");
        char[] buffer = new char[1024];
        int len;
        while ((len = reader.read(buffer)) != -1) {
            writer.write(buffer, 0, len);
        }
        reader.close();
        writer.close();
        System.out.println("内容已成功复制到文件！");
    }
}

我们首先创建了一个 FileReader 对象和一个 FileWriter 对象，分别用于读取和写入文件。然后，我们创建了一个 char 数组作为缓冲区，并使用 while 循环从输入流中读取数据，并将其写入输出流中。最后，我们关闭输入流和输出流。

三、缓冲流 BufferedReader、BufferedWriter

package com.pany.camp.io;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class BufferedReaderWriterExample {

    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new FileReader("data.txt"));
        BufferedWriter writer = new BufferedWriter(new FileWriter("data2.txt"));
        String line;
        while ((line = reader.readLine()) != null) {
            writer.write(line);
            // 分割
            writer.newLine();
        }
        reader.close();
        writer.close();
        System.out.println("内容已成功复制到文件！");
    }
}

我们首先创建了一个 BufferedReader 对象和一个 BufferedWriter 对象，分别用于读取和写入文件。然后，我们使用 while 循环从输入流中读取每一行数据，并将其写入输出流中。注意，我们使用了 BufferedWriter 的 newLine() 方法来写入换行符，以确保复制后的文件与原文件格式相同。最后，我们关闭输入流和输出流。

四、数据流 DataOutputStream、DataInputStream

package com.pany.camp.io;

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class DataInputOutputExample {

    public static void main(String[] args) throws IOException {

        DataOutputStream output = new DataOutputStream(new FileOutputStream("data3.txt"));
        output.writeUTF("Hello, World!");
        output.writeInt(42);
        output.close();
        System.out.println("数据已成功写入文件！");

        DataInputStream input = new DataInputStream(new FileInputStream("data3.txt"));
        String message = input.readUTF();
        int number = input.readInt();
        input.close();
        System.out.println("从文件中读取的字符串为：" + message);
        System.out.println("从文件中读取的整数为：" + number);
    }
}

我们首先创建了一个 DataOutputStream 对象，并使用 writeUTF() 和 writeInt() 方法将一个字符串和一个整数写入到文件中。然后，我们关闭输出流，并输出一条消息表示数据已成功写入文件。

接下来，我们创建了一个 DataInputStream 对象，并使用 readUTF() 和 readInt() 方法从文件中读取之前写入的数据。最后，我们关闭输入流，并输出读取到的字符串和整数。

五、对象流 ObjectOutputStream、ObjectInputStream

package com.pany.camp.io;

import java.io.*;

public class ObjectStreamExample {

    public static void main(String[] args) throws IOException, ClassNotFoundException {

        Person person = new Person("张三", 18);
        ObjectOutputStream output = new ObjectOutputStream(new FileOutputStream("data4.txt"));
        output.writeObject(person);
        output.close();
        System.out.println("对象已成功写入文件！");

        ObjectInputStream input = new ObjectInputStream(new FileInputStream("data4.txt"));
        Person newPerson = (Person) input.readObject();
        input.close();
        System.out.println("从文件中读取的对象为：" + newPerson);
    }
}

package com.pany.camp.io;

import java.io.Serializable;

public class Person implements Serializable {

    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
}

我们首先创建了一个 Person 对象，并将其写入到文件中。注意，Person 类实现了 Serializable 接口，以便可以将其序列化并写入文件中。

然后，我们创建了一个 ObjectInputStream 对象，并使用 readObject() 方法从文件中读取之前写入的对象。注意，在读取对象时，我们需要将其转换为 Person 类型。

最后，我们关闭输入流，并输出读取到的 Person 对象。

六、文件流 FileInputStream、FileOutputStream

package com.pany.camp.io;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileStreamExample {

    public static void main(String[] args) throws IOException {

        FileInputStream input = new FileInputStream("data.txt");
        FileOutputStream output = new FileOutputStream("data4.txt");

        byte[] buffer = new byte[1024];
        int len;
        while ((len = input.read(buffer)) != -1) {
            output.write(buffer, 0, len);
        }

        input.close();
        output.close();
        System.out.println("内容已成功复制到文件！");
    }
}

我们首先创建了一个 FileInputStream 对象和一个 FileOutputStream 对象，分别用于读取和写入文件。然后，我们创建了一个 byte 数组作为缓冲区，并使用 while 循环从输入流中读取数据，并将其写入输出流中。最后，我们关闭输入流和输出流。