核心概念

1. 字符集：这是一个字符到数字（码点）的映射表，它定义了“有哪些字符”以及“每个字符对应的编号是多少”。

   
   （图片来源网络，侵删）
   • ASCII：英文字符集，只有 128 个字符。
   • GB2312：中国国家标准简体中文字符集，包含了 6763 个汉字，以及拉丁字母、希腊字母、日文假名等,它是中文信息处理的基础编码之一。
   • Unicode：一个全球统一的、超大的字符集，它包含了世界上几乎所有已知的字符，每个字符都有一个唯一的码点，A 的码点是 U+0041，中 的码点是 U+4E2D。

2. 字符编码：这是将字符的码点转换成计算机可以存储和传输的字节序列的规则。

   • UTF-8 (Unicode Transformation Format - 8-bit)：Unicode 的一种实现方式，它是一种变长编码，英文字符（在 ASCII 范围内）占用 1 个字节，中文通常占用 3 个字节，生僻字可能占用 4 个字节。UTF-8 是目前互联网上最广泛使用的编码。
   • GB2312：它既是字符集，也是一种编码方案，每个汉字和大部分符号都固定占用 2 个字节，第一个字节（高字节）的取值范围是 0xA1-0xF7，第二个字节（低字节）的取值范围是 0xA1-0xFE。

简单比喻：

• 字符集 就像一本字典，告诉你每个汉字（字符）对应的“条目号”（码点）。
• 编码 就像电报码本，告诉你如何用“摩斯密码”（字节序列）来发送这个“条目号”。

Java 中的编码处理

Java 的内部处理是基于 UTF-16 编码的，这意味着，一个 char 类型在 Java 内存中通常占用 2 个字节，用来表示一个 Unicode 字符。

当我们从文件、网络或数据库中读取数据，或者将数据写入这些地方时，就需要进行编码和解码操作，这时，GB2312 和 UTF-8 就派上用场了。

编码：将字符串转换为字节数组

使用 String 类的 getBytes() 方法。

String text = "你好Hello";
// 1. 使用平台默认编码 (不推荐！)
// 在中文 Windows 系统上，默认可能是 GBK，在 Linux 上可能是 UTF-8。
// 这会导致代码在不同环境下行为不一致。
byte[] defaultBytes = text.getBytes();
System.out.println("默认编码: " + new String(defaultBytes)); // 可能正常，也可能乱码
// 2. 使用 GB2312 编码
byte[] gb2312Bytes = text.getBytes("GB2312");
System.out.println("GB2312 编码长度: " + gb2312Bytes.length); // 输出 10 (2*4 + 1*2)
// System.out.println(new String(gb2312Bytes)); // 如果你的控制台是UTF-8，这里会显示乱码
// 3. 使用 UTF-8 编码
byte[] utf8Bytes = text.getBytes("StandardCharsets.UTF_8"); // 推荐使用 StandardCharsets
System.out.println("UTF-8 编码长度: " + utf8Bytes.length); // 输出 11 (3*2 + 1*2 + 1*1)

解码：将字节数组转换为字符串

使用 String 的构造函数,指定字节数组对应的编码。

byte[] gb2312Bytes = "你好".getBytes("GB2312");
// 1. 使用正确的编码解码
String correctString = new String(gb2312Bytes, "GB2312");
System.out.println("正确解码 GB2312: " + correctString); // 输出: 你好
// 2. 使用错误的编码解码 (这是乱码的根源！)
String wrongString = new String(gb2312Bytes, "UTF-8");
System.out.println("错误解码为 UTF-8: " + wrongString); // 输出: ??涓� 或其他乱码

完整示例：文件读写中的编码转换

这是一个非常常见的场景：读取一个 GB2312 编码的文件，将其内容转换为 UTF-8 编码后写入另一个文件。

import java.io.*;
public class EncodingConverter {
    public static void main(String[] args) {
        // 原始文件路径 (假设是 GB2312 编码)
        String sourceFile = "gb2312.txt";
        // 目标文件路径 (将转换为 UTF-8 编码)
        String targetFile = "utf8.txt";
        // 要写入 GB2312 文件的内容
        String contentToWrite = "这是一个测试文件 Test File 123";
        try {
            // --- 第一步：创建一个 GB2312 编码的源文件 ---
            // 使用 OutputStreamWriter 并指定编码，确保文件以 GB2312 方式写入
            try (OutputStreamWriter osw = new OutputStreamWriter(
                    new FileOutputStream(sourceFile), "GB2312")) {
                osw.write(contentToWrite);
                System.out.println("成功创建 GB2312 编码文件: " + sourceFile);
            }
            // --- 第二步：读取 GB2312 文件并转换为 UTF-8 文件 ---
            // 使用 InputStreamReader 并指定编码来读取
            try (InputStreamReader isr = new InputStreamReader(
                    new FileInputStream(sourceFile), "GB2312");
                 // 使用 OutputStreamWriter 并指定编码来写入
                 OutputStreamWriter osw = new OutputStreamWriter(
                    new FileOutputStream(targetFile), "UTF-8")) {
                char[] buffer = new char[1024];
                int length;
                // 循环读取源文件内容
                while ((length = isr.read(buffer)) != -1) {
                    // 将读取到的字符写入目标文件，自动进行编码转换
                    osw.write(buffer, 0, length);
                }
                System.out.println("成功将 GB2312 文件转换为 UTF-8 文件: " + targetFile);
            }
        } catch (UnsupportedEncodingException e) {
            System.err.println("不支持的编码: " + e.getMessage());
        } catch (IOException e) {
            System.err.println("发生 IO 错误: " + e.getMessage());
        }
    }
}

运行上述代码后：

1. 你会得到一个 gb2312.txt 文件，它的字节内容是 GB2312 编码的。
2. 你会得到一个 utf8.txt 文件，它的字节内容是 UTF-8 编码的,但文件里面的文字内容和源文件完全一样。

最佳实践和常见问题

永远不要依赖默认编码

String.getBytes() 或 new String(byte[]) 不带编码参数的方法，依赖于 JVM 运行环境的默认编码，这会导致你的代码在 A 开发者的机器上运行正常，在 B 开发者的机器上就出现乱码。

解决方案： 始终显式地指定编码。

// 好的做法
byte[] bytes = myString.getBytes("UTF-8");
String str = new String(byteArray, "UTF-8");
// 更好的做法 (Java 7+)
import java.nio.charset.StandardCharsets;
byte[] bytes = myString.getBytes(StandardCharsets.UTF_8);
String str = new String(byteArray, StandardCharsets.UTF_8);

如何处理“乱码”？

乱码的根本原因是 解码时使用的编码与编码时使用的编码不一致。

场景： 你收到了一段 GB2312 编码的字节数组，但你用 UTF-8 去解码它。

解决方案：

1. 确定原始编码：你需要知道这段字节数率最初是用什么编码（如 GB2312, GBK, ISO-8859-1）生成的，这通常来自数据源的定义（如 HTTP 头、数据库元数据、文件格式规范）。

2. 使用正确的编码重新解码：

   // 假设 bytes 是 GB2312 编码的字节数组，但你错误地用 ISO-8859-1 (Latin-1) 解码了
   String wrongString = new String(bytes, "ISO-8859-1"); // 产生了乱码
   // 现在你知道了原始编码是 GB2312，可以这样“纠正”
   // 注意：这种方法不是万能的，但对于单字节到多字节的编码通常有效
   byte[] originalBytes = wrongString.getBytes("ISO-8859-1"); // 这一步只是把乱码字符当成单字节取回来
   String correctString = new String(originalBytes, "GB2312"); // 用正确的编码重新解析
   System.out.println(correctString); // 输出正确的字符串

总结对比

在新的 Java 项目中，强烈建议全程使用 UTF-8 作为编码标准，从源代码文件（确保 IDE 设置为 UTF-8）、数据库、服务器配置到文件 I/O，都统一使用 UTF-8，可以避免 99% 的编码问题，只有在需要与遗留的 GB2312 系统交互时，才需要进行 GB2312 和 UTF-8 之间的转换。