一、I/O 操作中存在的编码
涉及到编码的地方一般都在字符到字节或者字节到字符的转换上，而需要这种转换的场景主要是在 I/O 的时候，这个 I/O 包括磁盘 I/O 和网络 I/O，关于网络 I/O 部分在后面将主要以 Web 应用为例介绍。
下图是 Java 中处理 I/O 问题的接口：
Reader 类是 Java 的 I/O 中读字符的父类，而 InputStream 类是读字节的父类，InputStreamReader 类就是关联字节到字符的桥梁，它负责在 I/O 过程中处理读取字节到字符的转换，而具体字节到字符的解码实现它由 StreamDecoder 去实现，在 StreamDecoder 解码过程中必须由用户指定 Charset 编码格式。值得注意的是如果你没有指定 Charset，将使用本地环境中的默认字符集，例如在中文环境中将使用 GBK 编码。
写的情况也是类似，字符的父类是 Writer，字节的父类是 OutputStream，通过 OutputStreamWriter 转换字符到字节。如下图所示：
同样 StreamEncoder 类负责将字符编码成字节，编码格式和默认编码规则与解码是一致的。
String file = "c:/stream.txt";
String charset = "UTF-8";
// 写字符换转成字节流
FileOutputStream outputStream = new FileOutputStream(file);
OutputStreamWriter writer = new OutputStreamWriter(
outputStream, charset);
try {
writer.write("这是要保存的中文字符");
} finally {
writer.close();
}
// 读取字节转换成字符
FileInputStream inputStream = new FileInputStream(file);
InputStreamReader reader = new InputStreamReader(
inputStream, charset);
StringBuffer buffer = new StringBuffer();
char[] buf = new char[64];
int count = 0;
try {
while ((count = reader.read(buf)) != -1) {
buffer.append(buffer, 0, count);
}
} finally {
reader.close();
}
在我们的应用程序中涉及到 I/O 操作时只要注意指定统一的编解码 Charset 字符集，一般不会出现乱码问题，有些应用程序如果不注意指定字符编码，中文环境中取操作系统默认编码，如果编解码都在中文环境中，通常也没问题，但是还是强烈的不建议使用操作系统的默认编码，因为这样，你的应用程序的编码格式就和运行环境绑定起来了，在跨环境下很可能出现乱码问题。
二、内存中操作中的编码
在 Java 开发中除了 I/O 涉及到编码外，最常用的应该就是在内存中进行字符到字节的数据类型的转换。
Java 中用 String 表示字符串，所以 String 类就提供转换到字节的方法，也支持将字节转换为字符串的构造函数。如下代码示例：
String s = "这是一段中文字符串";
byte[] b = s.getBytes("UTF-8");
String n = new String(b,"UTF-8");
另外一个是Charset 类，它提供了 encode方法 与 decode方法，分别对应 char[] 到 byte[] 的编码和 byte[] 到 char[] 的解码。如下代码所示：
Charset charset = Charset.forName("UTF-8");
ByteBuffer byteBuffer = charset.encode(string);
CharBuffer charBuffer = charset.decode(byteBuffer);
编码与解码都在一个类中完成，通过 forName 设置编解码字符集，这样更容易统一编码格式。
Java 中还有一个 ByteBuffer 类，它提供一种 char 和 byte 之间的软转换，它们之间转换不需要编码与解码，只是把一个 16bit 的 char 格式，拆分成为 2 个 8bit 的 byte 表示，它们的实际值并没有被修改，仅仅是数据的类型做了转换。如下代码所示：
ByteBuffer heapByteBuffer = ByteBuffer.allocate(1024); ByteBuffer byteBuffer = heapByteBuffer.putChar(c);
以上这些提供字符和字节之间的相互转换只要我们设置编解码格式统一一般都不会出现问题。
三、Java 中如何编解码
前面介绍了几种常见的编码格式，下面将以实际例子介绍 Java 中如何实现编码及解码，下面我们以“I am 君山”这个字符串为例介绍 Java 中如何把它以 ISO-8859-1、GB2312、GBK、UTF-16、UTF-8 编码格式进行编码的。
1 public static void encode() {
2 String name = "I am 君山";
3 toHex(name.toCharArray());
4 try {
5 byte[] iso8859 = name.getBytes("ISO-8859-1");
6 toHex(iso8859);
7 byte[] gb2312 = name.getBytes("GB2312");
8 toHex(gb2312);
9 byte[] gbk = name.getBytes("GBK");
10 toHex(gbk);
11 byte[] utf16 = name.getBytes("UTF-16");
12 toHex(utf16);
13 byte[] utf8 = name.getBytes("UTF-8");
14 toHex(utf8);
15 } catch (UnsupportedEncodingException e) {
16 e.printStackTrace();
17 }
18 }
我们把 name 字符串按照前面说的几种编码格式进行编码转化成 byte 数组，然后以 16 进制输出，我们先看一下 Java 是如何进行编码的。
下面是 Java 中编码需要用到的类图：
首先根据指定的 charsetName 通过 Charset.forName(charsetName) 设置 Charset 类，然后根据 Charset 创建 CharsetEncoder 对象，再调用 CharsetEncoder.encode 对字符串进行编码，不同的编码类型都会对应到一个类中，实际的编码过程是在这些类中完成的。
下面是 String. getBytes(charsetName) 编码过程的时序图：
从上图可以看出根据 charsetName 找到 Charset 类，然后根据这个字符集编码生成 CharsetEncoder，这个类是所有字符编码的父类，针对不同的字符编码集在其子类中定义了如何实现编码，有了 CharsetEncoder 对象后就可以调用 encode 方法去实现编码了。这个是 String.getBytes 编码方法，其它的如 StreamEncoder 中也是类似的方式。下面看看不同的字符集是如何将前面的字符串编码成 byte 数组的？
如字符串“I am 君山”的 char 数组为 49 20 61 6d 20 541b 5c71，下面把它按照不同的编码格式转化成相应的字节。
按照 ISO-8859-1 编码，字符串“I am 君山”用 ISO-8859-1 编码，下面是编码结果：
从上图看出 7 个 char 字符经过 ISO-8859-1 编码转变成 7 个 byte 数组，ISO-8859-1 是单字节编码，中文“君山”被转化成值是 3f 的 byte。3f 也就是“？”字符，所以经常会出现中文变成“？”很可能就是错误的使用了 ISO-8859-1 这个编码导致的。中文字符经过 ISO-8859-1 编码会丢失信息，通常我们称之为“黑洞”，它会把不认识的字符吸收掉。由于现在大部分基础的 Java 框架或系统默认的字符集编码都是 ISO-8859-1，所以很容易出现乱码问题，后面将会分析不同的乱码形式是怎么出现的。
按照 GB2312 编码，字符串“I am 君山”用 GB2312 编码，下面是编码结果：
GB2312 对应的 Charset 是 sun.nio.cs.ext. EUC_CN 而对应的 CharsetDecoder 编码类是 sun.nio.cs.ext. DoubleByte，GB2312 字符集有一个 char 到 byte 的码表，不同的字符编码就是查这个码表找到与每个字符的对应的字节，然后拼装成 byte 数组。
查表的规则如下：
c2b[c2bIndex[char >> 8] + (char & 0xff)]
如果查到的码位值大于 oxff 则是双字节，否则是单字节。双字节高 8 位作为第一个字节，低 8 位作为第二个字节，如下代码所示：
1 if (bb > 0xff) { // DoubleByte
2 if (dl - dp < 2)
3 return CoderResult.OVERFLOW;
4 da[dp++] = (byte) (bb >> 8);
5 da[dp++] = (byte) bb;
6 } else { // SingleByte
7 if (dl - dp < 1)
8 return CoderResult.OVERFLOW;
9 da[dp++] = (byte) bb;
10 }
从上图可以看出前 5 个字符经过编码后仍然是 5 个字节，而汉字被编码成双字节，在第一节中介绍到 GB2312 只支持 6763 个汉字，所以并不是所有汉字都能够用 GB2312 编码。
按照 GBK 编码，字符串“I am 君山”用 GBK 编码，下面是编码结果：
你可能已经发现上图与 GB2312 编码的结果是一样的，没错 GBK 与 GB2312 编码结果是一样的，由此可以得出 GBK 编码是兼容 GB2312 编码的，它们的编码算法也是一样的。不同的是它们的码表长度不一样，GBK 包含的汉字字符更多。所以只要是经过 GB2312 编码的汉字都可以用 GBK 进行解码，反过来则不然。
按照 UTF-16 编码，字符串“I am 君山”用 UTF-16 编码，下面是编码结果：
用 UTF-16 编码将 char 数组放大了一倍，单字节范围内的字符，在高位补 0 变成两个字节，中文字符也变成两个字节。从 UTF-16 编码规则来看，仅仅将字符的高位和地位进行拆分变成两个字节。特点是编码效率非常高，规则很简单，由于不同处理器对 2 字节处理方式不同，Big-endian（高位字节在前，低位字节在后）或 Little-endian（低位字节在前，高位字节在后）编码，所以在对一串字符串进行编码是需要指明到底是 Big-endian 还是 Little-endian，所以前面有两个字节用来保存 BYTE_ORDER_MARK 值，UTF-16 是用定长 16 位（2 字节）来表示的 UCS-2 或 Unicode 转换格式，通过代理对来访问 BMP 之外的字符编码。
按照 UTF-8 编码，字符串“I am 君山”用 UTF-8 编码，下面是编码结果：
UTF-16 虽然编码效率很高，但是对单字节范围内字符也放大了一倍，这无形也浪费了存储空间，另外 UTF-16 采用顺序编码，不能对单个字符的编码值进行校验，如果中间的一个字符码值损坏，后面的所有码值都将受影响。而 UTF-8 这些问题都不存在，UTF-8 对单字节范围内字符仍然用一个字节表示，对汉字采用三个字节表示。
它的编码规则如下：
1 private CoderResult encodeArrayLoop(CharBuffer src,
2 ByteBuffer dst){
3 char[] sa = src.array();
4 int sp = src.arrayOffset() + src.position();
5 int sl = src.arrayOffset() + src.limit();
6 byte[] da = dst.array();
7 int dp = dst.arrayOffset() + dst.position();
8 int dl = dst.arrayOffset() + dst.limit();
9 int dlASCII = dp + Math.min(sl - sp, dl - dp);
10 // ASCII only loop
11 while (dp < dlASCII && sa[sp] < ‘\u0080‘)
12 da[dp++] = (byte) sa[sp++];
13 while (sp < sl) {
14 char c = sa[sp];
15 if (c < 0x80) {
16 // Have at most seven bits
17 if (dp >= dl)
18 return overflow(src, sp, dst, dp);
19 da[dp++] = (byte)c;
20 } else if (c < 0x800) {
21 // 2 bytes, 11 bits
22 if (dl - dp < 2)
23 return overflow(src, sp, dst, dp);
24 da[dp++] = (byte)(0xc0 | (c >> 6));
25 da[dp++] = (byte)(0x80 | (c & 0x3f));
26 } else if (Character.isSurrogate(c)) {
27 // Have a surrogate pair
28 if (sgp == null)
29 sgp = new Surrogate.Parser();
30 int uc = sgp.parse(c, sa, sp, sl);
31 if (uc < 0) {
32 updatePositions(src, sp, dst, dp);
33 return sgp.error();
34 }
35 if (dl - dp < 4)
36 return overflow(src, sp, dst, dp);
37 da[dp++] = (byte)(0xf0 | ((uc >> 18)));
38 da[dp++] = (byte)(0x80 | ((uc >> 12) & 0x3f));
39 da[dp++] = (byte)(0x80 | ((uc >> 6) & 0x3f));
40 da[dp++] = (byte)(0x80 | (uc & 0x3f));
41 sp++; // 2 chars
42 } else {
43 // 3 bytes, 16 bits
44 if (dl - dp < 3)
45 return overflow(src, sp, dst, dp);
46 da[dp++] = (byte)(0xe0 | ((c >> 12)));
47 da[dp++] = (byte)(0x80 | ((c >> 6) & 0x3f));
48 da[dp++] = (byte)(0x80 | (c & 0x3f));
49 }
50 sp++;
51 }
52 updatePositions(src, sp, dst, dp);
53 return CoderResult.UNDERFLOW;
54 }
UTF-8 编码与 GBK 和 GB2312 不同，不用查码表，所以在编码效率上 UTF-8 的效率会更好，所以在存储中文字符时 UTF-8 编码比较理想。
四、几种编码格式的比较
对中文字符后面四种编码格式都能处理，GB2312 与 GBK 编码规则类似，但是 GBK 范围更大，它能处理所有汉字字符，所以 GB2312 与 GBK 比较应该选择 GBK。UTF-16 与 UTF-8 都是处理 Unicode 编码，它们的编码规则不太相同，相对来说 UTF-16 编码效率最高，字符到字节相互转换更简单，进行字符串操作也更好。它适合在本地磁盘和内存之间使用，可以进行字符和字节之间快速切换，如 Java 的内存编码就是采用 UTF-16 编码。但是它不适合在网络之间传输，因为网络传输容易损坏字节流，一旦字节流损坏将很难恢复，想比较而言 UTF-8 更适合网络传输，对 ASCII 字符采用单字节存储，另外单个字符损坏也不会影响后面其它字符，在编码效率上介于 GBK 和 UTF-16 之间，所以 UTF-8 在编码效率上和编码安全性上做了平衡，是理想的中文编码方式。
