精通 Java IO 流体系：掌握字节流与字符流的区别与应用场景，实现文件、网络等不同数据源的读写操作。

好的，各位看官，欢迎来到《Java IO流大冒险：字节与字符的爱恨情仇》现场！我是你们的导游，江湖人称“代码诗人”，今天就带大家深入Java IO流的腹地，探索字节流和字符流这对欢喜冤家的故事。准备好你们的咖啡☕，让我们开始这场精彩的旅程吧！

第一幕：IO流的世界观——什么是“流”？

首先，我们要搞清楚什么是“流”。别想歪了，不是你想的那种潺潺流水，也不是什么神秘的能量流。在计算机的世界里，“流”是一种抽象概念，它代表着数据传输的通道。想象一下，你正用吸管喝果汁，果汁从杯子里流到你的嘴里，这个吸管就是“流”。在Java IO流中，数据就像果汁，而程序就是你的嘴。IO流就是帮助你的程序从各种数据源（比如文件、网络、内存）读取数据，或者将数据写入到这些数据源的工具。

第二幕：字节流 vs 字符流——谁是你的菜？

现在，主角登场了！字节流和字符流，它们是IO流家族中最耀眼的两颗星，也是最容易让人傻傻分不清的一对冤家。

字节流（Byte Stream）： 字节流就像一位耿直的汉子，简单粗暴，直接操作二进制数据。它以字节（byte）为单位进行读写，一次读一个字节，或者一次写一个字节。就好比你用一把勺子，一勺一勺地舀东西吃，不管你舀的是米饭🍚还是辣椒🌶️，它都照单全收。字节流的代表选手有：InputStream（输入字节流）和 OutputStream（输出字节流）。
字符流（Character Stream）： 字符流则是一位优雅的淑女，温柔细腻，专门处理字符数据。它以字符（char）为单位进行读写，会自动进行字符编码的转换。就好比你用筷子🥢吃饭，它会自动帮你把饭菜夹到嘴里，你不用关心饭菜是什么形状的。字符流的代表选手有：Reader（输入字符流）和 Writer（输出字符流）。

那么问题来了，面对这两位风格迥异的选手，我们该如何选择呢？这就涉及到它们的应用场景了。

特性	字节流	字符流
数据单位	byte（8位）	char（16位，Java中）
处理对象	任何类型的数据（图片、音频、视频、文本等）	文本数据
编码	不涉及编码，直接操作二进制数据	涉及编码，会自动进行字符编码的转换
效率	通常情况下，效率比字符流高	效率相对较低，但对于文本操作更方便
适用场景	读取或写入二进制文件，或者不关心字符编码的文件	读取或写入文本文件，需要处理字符编码的文件
代表类	`InputStream`、`OutputStream`、`FileInputStream`、`FileOutputStream`等	`Reader`、`Writer`、`FileReader`、`FileWriter`等

第三幕：字节流的“十八般武艺”

接下来，我们来深入了解一下字节流的常用类和使用方法。

InputStream（输入字节流）： 它是所有输入字节流的基类，定义了读取字节数据的基本方法。常用的子类有：
- FileInputStream：从文件中读取字节数据。
- ByteArrayInputStream：从字节数组中读取字节数据。
- ObjectInputStream：从输入流中读取对象。
OutputStream（输出字节流）： 它是所有输出字节流的基类，定义了写入字节数据的基本方法。常用的子类有：
- FileOutputStream：向文件中写入字节数据。
- ByteArrayOutputStream：向字节数组中写入字节数据。
- ObjectOutputStream：向输出流中写入对象。

案例1：用FileInputStream和FileOutputStream复制文件

import java.io.*;

public class FileCopy {
    public static void main(String[] args) {
        String sourceFile = "source.txt"; // 源文件
        String destinationFile = "destination.txt"; // 目标文件

        try (FileInputStream fis = new FileInputStream(sourceFile);
             FileOutputStream fos = new FileOutputStream(destinationFile)) {

            byte[] buffer = new byte[1024]; // 缓冲区
            int bytesRead;

            // 循环读取源文件，并写入目标文件
            while ((bytesRead = fis.read(buffer)) != -1) {
                fos.write(buffer, 0, bytesRead);
            }

            System.out.println("文件复制成功！🎉");

        } catch (IOException e) {
            System.err.println("文件复制失败： " + e.getMessage());
        }
    }
}

代码解读：

我们使用了try-with-resources语句，它会自动关闭流，避免资源泄露。
创建FileInputStream和FileOutputStream对象，分别用于读取源文件和写入目标文件。
创建一个缓冲区buffer，用于临时存储读取到的字节数据。
循环读取源文件，每次读取buffer大小的字节数据，并将读取到的数据写入目标文件。
当fis.read(buffer)返回-1时，表示已经读取到文件末尾，循环结束。

第四幕：字符流的“柔情似水”

接下来，我们再来看看字符流的常用类和使用方法。

Reader（输入字符流）： 它是所有输入字符流的基类，定义了读取字符数据的基本方法。常用的子类有：
- FileReader：从文件中读取字符数据。
- BufferedReader：带有缓冲区的字符输入流，可以提高读取效率。
- InputStreamReader：将字节输入流转换为字符输入流，可以指定字符编码。
Writer（输出字符流）： 它是所有输出字符流的基类，定义了写入字符数据的基本方法。常用的子类有：
- FileWriter：向文件中写入字符数据。
- BufferedWriter：带有缓冲区的字符输出流，可以提高写入效率。
- OutputStreamWriter：将字节输出流转换为字符输出流，可以指定字符编码。

案例2：用FileReader和FileWriter读取和写入文本文件

import java.io.*;

public class TextFileReadWrite {
    public static void main(String[] args) {
        String inputFile = "input.txt"; // 输入文件
        String outputFile = "output.txt"; // 输出文件

        try (FileReader fr = new FileReader(inputFile);
             FileWriter fw = new FileWriter(outputFile)) {

            int character;

            // 循环读取输入文件，并写入输出文件
            while ((character = fr.read()) != -1) {
                fw.write(character);
            }

            System.out.println("文件读取和写入完成！✍️");

        } catch (IOException e) {
            System.err.println("文件读取或写入失败： " + e.getMessage());
        }
    }
}

代码解读：

我们使用了try-with-resources语句，它会自动关闭流，避免资源泄露。
创建FileReader和FileWriter对象，分别用于读取输入文件和写入输出文件。
循环读取输入文件，每次读取一个字符，并将读取到的字符写入输出文件。
当fr.read()返回-1时，表示已经读取到文件末尾，循环结束。

第五幕：字节流与字符流的“恩怨情仇”——桥梁模式

有时候，我们需要在字节流和字符流之间进行转换。比如，我们想从一个字节输入流中读取文本数据，或者将文本数据写入到一个字节输出流中。这时，我们就需要用到InputStreamReader和OutputStreamWriter这两个“桥梁”。

InputStreamReader： 将字节输入流转换为字符输入流，可以指定字符编码。
OutputStreamWriter： 将字节输出流转换为字符输出流，可以指定字符编码。

案例3：使用InputStreamReader和OutputStreamWriter进行编码转换

import java.io.*;

public class EncodingConversion {
    public static void main(String[] args) {
        String inputFile = "utf8.txt"; // UTF-8编码的输入文件
        String outputFile = "gbk.txt"; // GBK编码的输出文件
        String inputEncoding = "UTF-8"; // 输入文件编码
        String outputEncoding = "GBK"; // 输出文件编码

        try (FileInputStream fis = new FileInputStream(inputFile);
             FileOutputStream fos = new FileOutputStream(outputFile);
             InputStreamReader isr = new InputStreamReader(fis, inputEncoding);
             OutputStreamWriter osw = new OutputStreamWriter(fos, outputEncoding);
             BufferedReader br = new BufferedReader(isr);
             BufferedWriter bw = new BufferedWriter(osw)) {

            String line;

            // 循环读取输入文件，并写入输出文件
            while ((line = br.readLine()) != null) {
                bw.write(line);
                bw.newLine(); // 写入换行符
            }

            System.out.println("编码转换完成！😎");

        } catch (IOException e) {
            System.err.println("编码转换失败： " + e.getMessage());
        }
    }
}

代码解读：

我们使用了try-with-resources语句，它会自动关闭流，避免资源泄露。
创建FileInputStream和FileOutputStream对象，分别用于读取输入文件和写入输出文件。
创建InputStreamReader和OutputStreamWriter对象，指定输入和输出文件的字符编码。
创建BufferedReader和BufferedWriter对象，提高读取和写入的效率。
循环读取输入文件，每次读取一行，并将读取到的数据写入输出文件。

第六幕：缓冲流——提升效率的“秘密武器”

在实际应用中，频繁地进行IO操作会影响程序的性能。为了提高IO效率，我们可以使用缓冲流。缓冲流会在内存中创建一个缓冲区，一次性读取或写入多个字节或字符，减少实际的IO操作次数。

BufferedInputStream： 带有缓冲区的字节输入流。
BufferedOutputStream： 带有缓冲区的字节输出流。
BufferedReader： 带有缓冲区的字符输入流。
BufferedWriter： 带有缓冲区的字符输出流。

案例4：使用BufferedReader和BufferedWriter提高文件读写效率

在前面的案例中，我们已经使用了BufferedReader和BufferedWriter，这里就不再赘述了。

第七幕：网络IO——连接世界的“桥梁”

IO流不仅可以用于文件操作，还可以用于网络通信。通过Socket，我们可以建立客户端和服务器之间的连接，然后使用IO流进行数据传输。

// 客户端
import java.io.*;
import java.net.*;

public class Client {
    public static void main(String[] args) {
        String serverAddress = "127.0.0.1"; // 服务器地址
        int serverPort = 12345; // 服务器端口

        try (Socket socket = new Socket(serverAddress, serverPort);
             PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
             BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()))) {

            // 向服务器发送数据
            out.println("Hello, Server! 👋");

            // 接收服务器返回的数据
            String response = in.readLine();
            System.out.println("Server response: " + response);

        } catch (IOException e) {
            System.err.println("客户端发生异常： " + e.getMessage());
        }
    }
}

// 服务器端
import java.io.*;
import java.net.*;

public class Server {
    public static void main(String[] args) {
        int port = 12345; // 监听端口

        try (ServerSocket serverSocket = new ServerSocket(port)) {
            System.out.println("服务器已启动，监听端口：" + port);

            while (true) {
                try (Socket clientSocket = serverSocket.accept();
                     BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
                     PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true)) {

                    // 接收客户端发送的数据
                    String request = in.readLine();
                    System.out.println("Client request: " + request);

                    // 向客户端返回数据
                    out.println("Hello, Client! 😊");

                } catch (IOException e) {
                    System.err.println("处理客户端连接时发生异常： " + e.getMessage());
                }
            }

        } catch (IOException e) {
            System.err.println("服务器启动失败： " + e.getMessage());
        }
    }
}

代码解读：

客户端和服务器端都使用Socket建立连接。
客户端使用PrintWriter向服务器发送数据，使用BufferedReader接收服务器返回的数据。
服务器端使用BufferedReader接收客户端发送的数据，使用PrintWriter向客户端返回数据。

第八幕：总结与升华——IO流的“修炼之道”

通过今天的学习，相信大家对Java IO流体系有了更深入的了解。记住，字节流和字符流各有千秋，选择哪一个取决于你的具体需求。掌握缓冲流、编码转换等技巧，可以让你在IO操作中游刃有余。

一些小贴士：

始终记得关闭流，避免资源泄露。可以使用try-with-resources语句，让Java自动关闭流。
选择合适的缓冲区大小，可以提高IO效率。
根据实际情况选择合适的字符编码，避免乱码问题。
多练习，多实践，才能真正掌握IO流的精髓。

好了，今天的《Java IO流大冒险：字节与字符的爱恨情仇》就到此结束了。希望大家在IO流的世界里玩得开心，写出更高效、更优雅的代码！感谢大家的观看，我们下期再见！ 👋

发表回复 取消回复

发表回复取消回复