Java开发中，常常会遇到乱码的问题，一旦遇到这种问题，常常就很扯蛋，每个人都不愿意承认是自己的代码有问题。其实编码问题并没有那么神秘，那么不可捉摸，搞清Java的编码本质过程就真相大白了。
先看个图：
其实，编码问题存在两个方面：JVM之内和JVM之外。
1、Java文件编译后形成class
这里Java文件的编码可能有多种多样，但Java编译器会自动将这些编码按照Java文件的编码格式正确读取后产生class文件，这里的class文件编码是Unicode编码（具体说是UTF-16编码）。
因此，在Java代码中定义一个字符串：
String s="汉字";
不管在编译前java文件使用何种编码，在编译后成class后，他们都是一样的----Unicode编码表示。
2、JVM中的编码
JVM加载class文件读取时候使用Unicode编码方式正确读取class文件，那么原来定义的String s="汉字";在内存中的表现形式是Unicode编码。
当调用String.getBytes()的时候，其实已经为乱码买下了祸根。因为此方法使用平台默认的字符集来获取字符串对应的字节数组。在WindowsXP中文版中，使用的默认编码是GBK，不信运行下：
public class Test {
public
static
void main(String[] args) {
System.out.println( "当前JRE：" + System.getProperty(
"java.version"));
System.out.println( "当前JVM的默认字符集：" + Charset.defaultCharset());
} }
当前JRE：1.6.0_16 当前JVM的默认字符集：GBK
当 不同的系统、数据库经过多次编码后，如果对其中的原理不理解，就容易导致乱码。因此，在一个系统中，有必要对字符串的编码做一个统一，这个统一模糊点说， 就是对外统一。比如方法字符串参数，IO流，在中文系统中，可以统一使用GBK、GB13080、UTF-8、UTF-16等等都可以，只是要选择有些更 大字符集，以保证任何可能用到的字符都可以正常显示，避免乱码的问题。（假设对所有的文件都用ASCII码）那么就无法实现双向转换了。
要 特别注意的是，UTF-8并非能容纳了所有的中文字符集编码，因此，在特殊情况下，UTF-8转GB18030可能会出现乱码，然而一群傻B常常在做中文 系统喜欢用UTF-8编码而不说不出个所以然出来！最傻B的是，一个系统多个人做，源代码文件有的人用GBK编码，有人用UTF-8，还有人用 GB18030。FK，都是中国人，也不是外包项目，用什么UTF-8啊，神经！源代码统统都用GBK18030就OK了，免得ANT脚本编译时候提示不 可认的字符编码。
因此，对于中文系统来说，最好选择GBK或GB18030编码（其实GBK是GB18030的子集），以便最大限度的避免乱码现象。
3、内存中字符串的编码
内存中的字符串不仅仅局限于从class代码中直接加载而来的字符串，还有一些字符串是从文本文件中读取的，还有的是通过数据库读取的，还有可能是从字节数组构建的，然而他们基本上都不是Unicode编码的，原因很简单，存储优化。
因 此就需要处理各种各样的编码问题，在处理之前，必须明确“源”的编码，然后用指定的编码方式正确读取到内存中。如果是一个方法的参数，实际上必须明确该字 符串参数的编码，因为这个参数可能是另外一个日文系统传递过来的。当明确了字符串编码时候，就可以按照要求正确处理字符串，以避免乱码。
在对字符串进行解码编码的时候，应该调用下面的方法：
getBytes(String charsetName) String( byte[] bytes, String charsetName)
而不要使用那些不带字符集名称的方法签名，通过上面两个方法，可以对内存中的字符进行重新编码。
Java代码
1. package com.elmer.c;
2.
3. import java.io.UnsupportedEncodingException;
4.
5. public class GbktoUtf8 {
6.
7. public String convertString(String gbk){
8. "";
9. try {
10. new String(gbk2utf8(gbk),"UTF-8");
11. catch (UnsupportedEncodingException e) {
12. e.printStackTrace();
13. }
14. return utf8;
15. }
16.
17. public byte[] gbk2utf8(String chenese) {
18. char c[] = chenese.toCharArray();
19. byte[] fullByte = new byte[3 * c.length];
20. for (int i = 0; i < c.length; i++) {
21. int m = (int) c[i];
22. String word = Integer.toBinaryString(m);
23.
24. new StringBuffer();
25. int len = 16 - word.length();
26. for (int j = 0; j < len; j++) {
27. "0");
28. }
29. sb.append(word);
30. 0, "1110");
31. 8, "10");
32. 16, "10");
33.
34. 0, 8);
35. 8, 16);
36. 16);
37.
38. byte b0 = Integer.valueOf(s1, 2).byteValue();
39. byte b1 = Integer.valueOf(s2, 2).byteValue();
40. byte b2 = Integer.valueOf(s3, 2).byteValue();
41. byte[] bf = new byte[3];
42. 0] = b0;
43. 3] = bf[0];
44. 1] = b1;
45. 3 + 1] = bf[1];
46. 2] = b2;
47. 3 + 2] = bf[2];
48.
49. }
50. return fullByte;
51. }
52.
53. public static void main(String[] args) {
54. new GbktoUtf8();
55. "我是q !"));
56. }
57.
58. }
核心是找的资料,还没放到web里试过
二.
Java代码
1. public class TranCharset {
2.
3. private static final String PRE_FIX_UTF = "&#x";
4.
5. private static final String POS_FIX_UTF = ";";
6.
7. public TranCharset() {
8. }
9.
10. /**
11. * Translate charset encoding to unicode
12. *
13. * @param sTemp
14. * charset encoding is gb2312
15. * @return charset encoding is unicode
16. */
17. public static String XmlFormalize(String sTemp) {
18. new StringBuffer();
19.
20. if (sTemp == null || sTemp.equals("")) {
21. return "";
22. }
23. String s = TranCharset.TranEncodeTOGB(sTemp);
24. for (int i = 0; i < s.length(); i++) {
25. char cChar = s.charAt(i);
26. if (TranCharset.isGB2312(cChar)) {
27. sb.append(PRE_FIX_UTF);
28. sb.append(Integer.toHexString(cChar));
29. sb.append(POS_FIX_UTF);
30. else {
31. switch ((int) cChar) {
32. case 32:
33. " ");
34. break;
35. case 34:
36. """);
37. break;
38. case 38:
39. "&");
40. break;
41. case 60:
42. "<");
43. break;
44. case 62:
45. ">");
46. break;
47. default:
48. sb.append(cChar);
49. }
50. }
51. }
52. return sb.toString();
53. }
54.
55. /**
56. * 将字符串编码格式转成GB2312
57. *
58. * @param str
59. * @return
60. */
61. public static String TranEncodeTOGB(String str) {
62. try {
63. String strEncode = TranCharset.getEncoding(str);
64. new String(str.getBytes(strEncode), "GB2312");
65. return temp;
66. catch (java.io.IOException ex) {
67.
68. return null;
69. }
70. }
71.
72. /**
73. * 判断输入字符是否为gb2312的编码格式
74. *
75. * @param c
76. * 输入字符
77. * @return 如果是gb2312返回真，否则返回假
78. */
79. public static boolean isGB2312(char c) {
80. new Character(c);
81. String sCh = ch.toString();
82. try {
83. byte[] bb = sCh.getBytes("gb2312");
84. if (bb.length > 1) {
85. return true;
86. }
87. catch (java.io.UnsupportedEncodingException ex) {
88. return false;
89. }
90. return false;
91. }
92.
93. /**
94. * 判断字符串的编码
95. *
96. * @param str
97. * @return
98. */
99. public static String getEncoding(String str) {
100. "GB2312";
101. try {
102. if (str.equals(new String(str.getBytes(encode), encode))) {
103. String s = encode;
104. return s;
105. }
106. catch (Exception exception) {
107. }
108. "ISO-8859-1";
109. try {
110. if (str.equals(new String(str.getBytes(encode), encode))) {
111. String s1 = encode;
112. return s1;
113. }
114. catch (Exception exception1) {
115. }
116. "UTF-8";
117. try {
118. if (str.equals(new String(str.getBytes(encode), encode))) {
119. String s2 = encode;
120. return s2;
121. }
122. catch (Exception exception2) {
123. }
124. "GBK";
125. try {
126. if (str.equals(new String(str.getBytes(encode), encode))) {
127. String s3 = encode;
128. return s3;
129. }
130. catch (Exception exception3) {
131. }
132. "BIG5";
133. try {
134. if (str.equals(new String(str.getBytes(encode), encode))) {
135. String s4 = encode;
136. return s4;
137. }
138. catch (Exception exception3) {
139. }
140. return "";
141. }
142.
143. public static void main(String args[]) {
144. "下载"));
145. }
146. }
Java代码
1. package com.lang.string;
2.
3.
4. public class ConverFromGBKToUTF8 {
5. public static void main(String[] args){
6.
7. try {
8.
9. new ConverFromGBKToUTF8();
10. "我是我我们";
11. byte [] fullByte = convert.gbk2utf8(chenese);
12. new String(fullByte, "UTF-8");
13. "string from GBK to UTF-8 byte: " + fullStr);
14.
15.
16. catch (Exception e) {
17. e.printStackTrace();
18. }
19. }
20.
21. public byte[] gbk2utf8(String chenese){
22. char c[] = chenese.toCharArray();
23. byte [] fullByte =new byte[3*c.length];
24. for(int i=0; i<c.length; i++){
25. int m = (int)c[i];
26. String word = Integer.toBinaryString(m);
27. // System.out.println(word);
28.
29. new StringBuffer();
30. int len = 16 - word.length();
31. //补零
32. for(int j=0; j<len; j++){
33. "0");
34. }
35. sb.append(word);
36. 0, "1110");
37. 8, "10");
38. 16, "10");
39.
40. // System.out.println(sb.toString());
41.
42. 0, 8);
43. 8, 16);
44. 16);
45.
46. byte b0 = Integer.valueOf(s1, 2).byteValue();
47. byte b1 = Integer.valueOf(s2, 2).byteValue();
48. byte b2 = Integer.valueOf(s3, 2).byteValue();
49. byte[] bf = new byte[3];
50. 0] = b0;
51. 3] = bf[0];
52. 1] = b1;
53. 3+1] = bf[1];
54. 2] = b2;
55. 3+2] = bf[2];
56.
57. }
58. return fullByte;
59. }
60. }
JAVA字符编码系列二：Unicode,ISO-8859-1,GBK,UTF-8编码及相互转换
１、函数介绍
在Java中，字符串用统一的Unicode编码，每个字符占用两个字节，与编码有关的两个主要函数为：
１）将字符串用指定的编码集合解析成字节数组，完成Unicode－〉charsetName转换
public byte[] getBytes(String charsetName) throws UnsupportedEncodingException２）将字节数组以指定的编码集合构造成字符串，完成charsetName－〉Unicode转换
public String(byte[] bytes, String charsetName) throws UnsupportedEncodingException２、Unicode与各编码之间的直接转换
下面以对中文字符串＂ａ中文＂的编码转换为例，来了解各种编码之间的转换
１）Unicode和GBK
测试结果如下，每个汉字转换为两个字节，且是可逆的，即通过字节可以转换回字符串
String－GBK〉ByteArray：\u0061\u4E2D\u6587（a中文）－〉0x61 0xD6 0xD0 0xCE 0xC4
ByteArray－GBK〉String：0x61 0xD6 0xD0 0xCE 0xC4－〉\u0061\u4E2D\u6587（a中文）２）Unicode和UTF-8
测试结果如下，每个汉字转换为三个字节，且是可逆的，即通过字节可以转换回字符串
String－UTF-8〉ByteArray：\u0061\u4E2D\u6587（a中文）－〉0x61 0xE4 0xB8 0xAD 0xE6%0x96 0x87
ByteArray－UTF-8〉String：0x61 0xE4 0xB8 0xAD 0xE6%0x96 0x87－〉\u0061\u4E2D\u6587（a中文）
３）Unicode和ISO-8859-1
测试结果如下，当存在汉字时转换失败，非可逆，即通过字节不能再转换回字符串
String－ISO-8859-1〉ByteArray：\u0061\u4E2D\u6587（a中文）－〉0x61 0x3F 0x3F
ByteArray－ISO-8859-1〉String：0x61 0x3F 0x3F－〉\u0061\u003F\u003F（a??）
３、Unicode与各编码之间的交叉转换
在上面直接转换中，由字符串（Unicode）生成的字节数组，在构造回字符串时，使用的是正确的编码集合，如果使用的不是正确的编码集合会怎样呢？会正确构造吗？如果不能正确构造能有办法恢复吗？会信息丢失吗？
下面我们就来看看这种情况，这部分可以说明在某些情况下虽然我们最终正确显示了结果，但其间仍然进行了不正确的转换。
１）能够正确显示的中间不正确转换
我们知道String－GBK〉ByteArray－GBK〉String是正确的，但如果我们采用String－GBK〉ByteArray－ISO-8859-1〉String呢？通过测试结果如下：
String－GBK〉ByteArray－ISO-8859-1〉String：\u0061\u4E2D\u6587（a中文）－〉0x61 0xD6 0xD0 0xCE 0xC4－〉\u0061\u00D6\u00D0\u00CE\u00C4（a????）
这时我们得到的字符串为？乱码“a????”，但是通过继续转换我们仍然可以复原回正确的字符串“a中文”，过程如下：
String－GBK〉ByteArray－ISO-8859-1〉String－ISO-8859-1〉ByteArray－GBK〉String
对 应：\u0061\u4E2D\u6587（a中文）－〉0x61 0xD6 0xD0 0xCE 0xC4－〉\u0061\u00D6\u00D0\u00CE\u00C4（a????）－〉0x61 0xD6 0xD0 0xCE 0xC4－〉\u0061\u4E2D\u6587（a中文）
也 就是我们在首次构造字符串时，我们用了错误的编码集合得到了错误的乱码，但是我们通过错上加错，再用错误的编码集合获取字节数组，然后再用正确的编码集合 构造，就又恢复了正确的字符串。这时就属于是“能够正确显示的中间不正确转换”。在Jsp页面提交数据处理时常常发生这种情况。
此外能够正确显示的中间不正确转换还有：
String－UTF-8〉ByteArray－ISO-8859-1〉String－ISO-8859-1〉ByteArray－UTF-8〉String
和
String－UTF-8〉ByteArray－GBK〉String－GBK〉ByteArray－UTF-8〉String
对 应：\u0061\u4E2D\u6587（a中文）－〉0x61 0xE4 0xB8 0xAD 0xE6%0x96 0x87－〉\u0061\u6D93\uE15F\u6783（a涓枃）－〉0x61 0xE4 0xB8 0xAD 0xE6%0x96 0x87－〉\u0061\u4E2D\u6587（a中文）
４、编码过程中错误诊断参考
１）一个汉字对应一个问号
在通过ISO-8859-1从字符串获取字节数组时，由于一个Unicode转换成一个byte，当遇到不认识的Unicode时，转换为0x3F，这样无论用哪种编码构造时都会产生一个？乱码。
２）一个汉字对应两个问号
在通过GBK从字符串获取字节数组时，由于一个Unicode转换成两个byte，如果此时用ISO-8859-1或用UTF-8构造字符串就会出现两个问号。
若是通过ISO-8859-1构造可以再通过上面所说的错上加错恢复（即再通过从ISO-8859-1解析，用GBK构造）；
若是通过UTF-8构造则会产生Unicode字符＂\uFFFD＂，不能恢复，若再通过String－UTF-8〉ByteArray－GBK〉String，则会出现杂码，如a锟斤拷锟斤拷
３）一个汉字对应三个问号
在通过UTF-8从字符串获取字节数组时，由于一个Unicode转换成三个byte，如果此时用ISO-8859-1构造字符串就会出现三个问号；用GBK构造字符串就会出现杂码，如a涓枃。
