Java 内部使用 UTF-16 编码

首先要明确一个最关键的概念：

Java 中的 String 对象本身并不存储字符编码信息。

所有的 String 在内存中都使用 UTF-16 编码来存储其字符，这意味着无论你用哪种编码（如 GBK, ISO-8859-1, UTF-8）将字节流读入程序，一旦通过 new String(byte[], charset) 构造成功，它就变成了一个与编码无关的、统一的 UTF-16 内部表示。

你无法直接从一个已经存在的 String 对象中“获取”它当初是用什么编码创建的，因为那信息已经丢失了。

我们通常说的“获取编码”是什么意思？

我们通常遇到的需求场景是：

1. 从字节流（如文件、网络请求）中读取数据，并想知道它是什么编码，以便正确地将其解码成 String。
2. 将一个 String 转换成字节流，并指定一种编码（如 UTF-8）来保存或传输。

问题的核心不是从 String 获取编码，而是如何判断一个字节数组（byte[]）的编码，或者如何选择正确的编码来创建 String。

如何判断字节数组的编码（并转换为 String）

这是最常见的需求,判断文件或网络流的编码没有 100% 准确的方法，但有一些非常有效的策略和工具。

方法 1：使用库（推荐 - 如 ICU4J 或 juniversalchardet）

手动实现编码检测非常复杂,强烈建议使用成熟的第三方库。

示例：使用 juniversalchardet (Mozilla 的编码检测算法的 Java 实现)

这是一个轻量级且非常流行的选择。

添加依赖 (Maven):

<dependency>
    <groupId>com.github.albfernandez</groupId>
    <artifactId>juniversalchardet</artifactId>
    <version>2.4.0</version>
</dependency>

Java 代码示例:

import org.mozilla.universalchardet.UniversalDetector;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
public class EncodingDetector {
    public static String detectEncoding(byte[] bytes) throws IOException {
        UniversalDetector detector = new UniversalDetector(null);
        detector.handleData(bytes, 0, bytes.length);
        detector.dataEnd();
        String encoding = detector.getDetectedCharset();
        detector.reset();
        return encoding;
    }
    public static void main(String[] args) throws IOException {
        // --- 示例 1: UTF-8 编码的字节 ---
        String textUtf8 = "你好，世界！Hello, World!";
        byte[] bytesUtf8 = textUtf8.getBytes(StandardCharsets.UTF_8);
        System.out.println("字节数组 (UTF-8): " + bytesToHex(bytesUtf8));
        String detectedEncoding1 = detectEncoding(bytesUtf8);
        System.out.println("检测到的编码: " + detectedEncoding1);
        System.out.println("解码后的字符串: " + new String(bytesUtf8, detectedEncoding1));
        System.out.println("-------------------------------------");
        // --- 示例 2: GBK 编码的字节 ---
        String textGbk = "你好，世界！";
        byte[] bytesGbk = textGbk.getBytes("GBK"); // 注意：这里使用系统的 GBK 编码
        System.out.println("字节数组 (GBK): " + bytesToHex(bytesGbk));
        String detectedEncoding2 = detectEncoding(bytesGbk);
        System.out.println("检测到的编码: " + detectedEncoding2);
        System.out.println("解码后的字符串: " + new String(bytesGbk, detectedEncoding2));
        System.out.println("-------------------------------------");
        // --- 示例 3: 无法确定的情况 ---
        byte[] unknownBytes = { 0x61, 0x62, 0x63 }; // "abc" 在很多编码中都是一样的
        String detectedEncoding3 = detectEncoding(unknownBytes);
        System.out.println("字节数组 (unknown): " + bytesToHex(unknownBytes));
        System.out.println("检测到的编码: " + (detectedEncoding3 != null ? detectedEncoding3 : "无法确定"));
    }
    // 一个辅助方法，用于打印字节数组的十六进制表示，方便观察
    private static String bytesToHex(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (byte b : bytes) {
            sb.append(String.format("%02X ", b));
        }
        return sb.toString();
    }
}

方法 2：通过文件头或 BOM (Byte Order Mark) 判断

某些编码（如 UTF-8, UTF-16）会在文件开头放置一个特殊的字节序列，称为 BOM，用来标识编码。

• UTF-8 BOM: EF BB BF
• UTF-16 BE BOM: FE FF
• UTF-16 LE BOM: FF FE

你可以检查字节流的开头是否包含这些特征。

public class BomDetector {
    public static String detectByBom(byte[] bom) {
        if (bom.length >= 3 && bom[0] == 0xEF && bom[1] == 0xBB && bom[2] == 0xBF) {
            return "UTF-8";
        }
        if (bom.length >= 2) {
            if (bom[0] == 0xFE && bom[1] == 0xFF) {
                return "UTF-16BE";
            }
            if (bom[0] == 0xFF && bom[1] == 0xFE) {
                // 可能是 UTF-16LE 或 UTF-8 with BOM，需要进一步检查
                if (bom.length >= 4 && bom[2] == 0x00 && bom[3] == 0x3C) { // 检查 "<?"
                    return "UTF-16LE";
                }
                return "UTF-8"; // 或者其他编码，这里简化处理
            }
        }
        return null; // 未检测到 BOM
    }
}

注意：BOM 方法不是万能的，很多文件（特别是 Linux 下的文本文件）没有 BOM，有些工具（如 Python 的 open()）在写入 UTF-8 文件时默认不添加 BOM，认为 BOM 是不必要的。

将 String 转换为指定编码的字节数组

这个场景很直接,因为你需要明确地告诉 Java 使用哪种编码。

public class StringToBytes {
    public static void main(String[] args) {
        String text = "你好，世界！Hello, World!";
        // 1. 转换为 UTF-8 编码的字节数组
        byte[] utf8Bytes = text.getBytes(StandardCharsets.UTF_8);
        System.out.println("UTF-8 字节数组: " + bytesToHex(utf8Bytes));
        // 2. 转换为 GBK 编码的字节数组
        // 注意：如果系统不支持 GBK，这行代码会抛出 UnsupportedCharsetException
        byte[] gbkBytes = text.getBytes(Charset.forName("GBK"));
        System.out.println("GBK 字节数组: " + bytesToHex(gbkBytes));
        // 3. 转换为 ISO-8859-1 编码的字节数组
        // ISO-8859-1 (Latin-1) 不能表示中文字符，非 ASCII 字符会被替换为 '?'
        byte[] isoBytes = text.getBytes(StandardCharsets.ISO_8859_1);
        System.out.println("ISO-8859-1 字节数组: " + bytesToHex(isoBytes));
        System.out.println("ISO-8859-1 解码后: " + new String(isoBytes, StandardCharsets.ISO_8859_1));
    }
    private static String bytesToHex(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (byte b : bytes) {
            sb.append(String.format("%02X ", b));
        }
        return sb.toString();
    }
}

最佳实践： 在 Java 中，始终显式地指定字符集，而不要依赖平台默认的字符集。

• 错误做法: text.getBytes() 或 new String(byteArray)
• 正确做法: text.getBytes(StandardCharsets.UTF_8) 或 new String(byteArray, StandardCharsets.UTF_8)

StandardCharsets 枚举类（Java 7+）提供了预定义的、不可变的字符集常量（UTF-8, UTF-16, ISO-8859-1），使用它们可以避免 UnsupportedCharsetException，并且代码更清晰、性能更好。

希望这个详细的解释能帮助你彻底理解 Java 中的字符串和编码问题！