java unicode 编码转换两种方法

一、问题：
JAVA 字符的编码问题，有很多情况会出现，比如：
1. jsp页面显示不出中文字符

2. servlet不能返回正确的中文名

3. 资源文件乱码，比如就需要中文转unicode

4. 调用js乱码，需要与调用它的jsp页面的编码保持一致

5. 邮件附件名的乱码 或 邮件正文乱码 等等

二、起源：

在Javac编译期间，也会先从OS中取得现在使用的字符集，此处设为A，之后把送入的字符串转化为Unicode编码，在编译之后再从Unicode转化为A型字符集。因此：

1. 当你的操作系统国际设定错误，编译时就会产出错误的字符集编码。
2. 一些比较lj的编译器会按照预先设定的字符集，而非OS所使用的字符集进行编码。
3. 原是文件存盘时使用的字符集与编译器所使用的字符集无法匹配也会产生错误。

对于1和2，很好理解。对于3，例如我们使用的OS时GB2312，但是存盘时使用的编码字符集时UTF-8，这样java编译器编译文件的时候，就把UTF－8字符集当成GB2312字符集来处理，这样当然会出错。

原文见：http://hi.baidu.com/embrace_you/blog/item/20a663b1228c1d5e08230240.html

三、解决办法：

1. 对于一般的问题，我们只要指定编码方式就行了：

比如，javac -encoding gb2312 ... 或在jsp等文件头增加 charset 设定

2. 但有时候不得不面临另外一种不幸的情况，即我们手头只有字节码文件，但是原来类中的常量中肯定存在编码问题。只有先反编译字节码文件，修改文件之后再重新编译。这需要另外一些办法——利用I/O

文字毕竟也是“binary”，为什么要单独给它们编写Reader和Writer类呢？问题在于， InputStream与OutputStream会照本宣科的解读所有输入的数据为binary，而Reader和Writer才真正的把文字当成文字，并且在需要的时候将其转换。

3. 字符的转码：

可以用 byte[] getBytes(String charset)；将String转化为指定字符集的byte数组。

或

String(byte[] bytes, int offset, int length, String charset);
String(byte[] bytes, String charset);

以通过byte数组创建指定字符集的字符串

还可以通过 ByteArrayInputStream 或 ByteArrayOutputStream 串接到 InputStreamReader 或 OutputStreamWriter，来达到转码的目的。

比如 tFileInputMail 组件出现一个问题，解析出的mail附件名乱码，解决方案就是

--> 用 byte[] 构造一个ByteArrayInputStream 对象 A

ByteArrayInputStream bis = new ByteArrayInputStream(str.getBytes());

--> 将此 A 对象传入到特定解码算法里，返回一个 InputStream 子类的对象 B

Object obj = new com.sun.mail.util.BASE64DecoderStream(bis);

--> 读取B到一个byte[]里，根据String(byte[] bytes, int offset, int length, String charset);来构造能返回的正确的附件名

if (obj != null){
int k = bis .available();
byte[] arrByte = new byte[k ];
k = ((java.io.InputStream) (obj )).read(arrByte , 0, k );
attachfileName = new String(arrByte , 0, k , sCharSet );
}

四、unicode 案例

组件是将字符串保存到 microsoft message queue里，据说是16位的unicode的保存的，如果它能自动化转换为unicode保存怎么会出现乱码呢？unicode是统一字符标准编码，每个字符都有它的16位字符集编码，是大而全的编码。

组件的问题是，中文等unicode字符保存后取出来就是乱码了，采取了一个办法，也不知道是不是最好的办法。类似于Properties类里的unicode转换方法，写了一个unicode的转换类

package org.talend.msmq;

public class CharacterSetToolkit {
public static void main(String[] args)
{
String str = "abc";
str = toUnicode(str, false);
System.out.println(str);
str ="\u4F60\u597D";
str = fromUnicode(str);
System.out.println(str);
}

public CharacterSetToolkit() {
}

private static final char[] hexDigit = {
'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'
};

private static char toHex(int nibble) {
return hexDigit[(nibble & 0xF)];
}

/*
* Converts unicodes to encoded \uxxxx and escapes
* special characters with a preceding slash
*/
public static String toUnicode(String theString, boolean escapeSpace) {
int len = theString.length();
int bufLen = len * 2;
if (bufLen < 0) {
bufLen = Integer.MAX_VALUE;
}
StringBuffer outBuffer = new StringBuffer(bufLen);

for(int x=0; xchar aChar = theString.charAt(x);
// Handle common case first, selecting largest block that
// avoids the specials below
if ((aChar > 61) && (aChar < 127)) {
if (aChar == '\\') {
outBuffer.append('\\'); outBuffer.append('\\');
continue;
}
outBuffer.append(aChar);
continue;
}
switch(aChar) {
case ' ':
if (x == 0 || escapeSpace)
outBuffer.append('\\');
outBuffer.append(' ');
break;
case '\t':outBuffer.append('\\'); outBuffer.append('t');
break;
case '\n':outBuffer.append('\\'); outBuffer.append('n');
break;
case '\r':outBuffer.append('\\'); outBuffer.append('r');
break;
case '\f':outBuffer.append('\\'); outBuffer.append('f');
break;
case '=': // Fall through
case ':': // Fall through
case '#': // Fall through
case '!':
outBuffer.append('\\'); outBuffer.append(aChar);
break;
default:
if ((aChar < 0x0020) || (aChar > 0x007e)) {
outBuffer.append('\\');
outBuffer.append('u');
outBuffer.append(toHex((aChar >> 12) & 0xF));
outBuffer.append(toHex((aChar >> 8) & 0xF));
outBuffer.append(toHex((aChar >> 4) & 0xF));
outBuffer.append(toHex( aChar & 0xF));
} else {
outBuffer.append(aChar);
}
}
}
return outBuffer.toString();
}

public static String fromUnicode(String str) {
return fromUnicode(str.toCharArray(), 0, str.length(), new char[1024]);
}
/*
* Converts encoded \uxxxx to unicode chars
* and changes special saved chars to their original forms
*/
public static String fromUnicode(char[] in, int off, int len, char[] convtBuf) {
if (convtBuf.length < len) {
int newLen = len * 2;
if (newLen < 0) {
newLen = Integer.MAX_VALUE;
}
convtBuf = new char[newLen];
}
char aChar;
char[] out = convtBuf;
int outLen = 0;
int end = off + len;

while (off < end) {
aChar = in[off++];
if (aChar == '\\') {
aChar = in[off++];
if (aChar == 'u') {
// Read the xxxx
int value = 0;
for (int i = 0; i < 4; i++) {
aChar = in[off++];
switch (aChar) {
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
value = (value << 4) + aChar - '0';
break;
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
value = (value << 4) + 10 + aChar - 'a';
break;
case 'A':
case 'B':
case 'C':
case 'D':
case 'E':
case 'F':
value = (value << 4) + 10 + aChar - 'A';
break;
default:
throw new IllegalArgumentException(
"Malformed \\uxxxx encoding.");
}
}
out[outLen++] = (char) value;
} else {
if (aChar == 't') {
aChar = '\t';
} else if (aChar == 'r') {
aChar = '\r';
} else if (aChar == 'n') {
aChar = '\n';
} else if (aChar == 'f') {
aChar = '\f';
}
out[outLen++] = aChar;
}
} else {
out[outLen++] = (char) aChar;
}
}
return new String(out, 0, outLen);
}

}

五、附加

下例是一个说明：无论字符原来用何种本地字符集表示，在Unicode字符集中都被表示成相同的编码。或者说，Unicode字符集和语言的种类无关。

public class ch {

public static void main(String[] args) {
// TODO Auto-generated method stub
try {
String str = "中";
String CHARSET = "GB2312";
// String CHARSET = "SHIFT-JIS";

char nativeChars[] = str.toCharArray();

java.nio.charset.Charset nativeCharset = java.nio.charset.Charset.forName(CHARSET);
java.nio.CharBuffer nativeCharBuffer = java.nio.CharBuffer.wrap(nativeChars);

java.nio.charset.CharsetEncoder encoder = nativeCharset.newEncoder();
java.nio.ByteBuffer nativeBytebuffer = encoder.encode(nativeCharBuffer);

byte[] nativeBytes = nativeBytebuffer.array();
System.out.println("\n#----- " + CHARSET + " encoding output -----#");
for (int i = 0; i < nativeBytes.length; i++) {
System.out.print(Integer.toHexString('\u00FF' & nativeBytes[i]).toUpperCase());
}

java.nio.charset.CharsetDecoder unicodeDecoder = nativeCharset.newDecoder();
java.nio.CharBuffer unicodeCharbuffer = unicodeDecoder.decode(nativeBytebuffer);
char unicodeChars[] = unicodeCharbuffer.array();
System.out.println("\n#----- Unicode encoding output -----#");
for (int i = 0; i < unicodeChars.length; i++) {
System.out.print(Integer.toHexString(unicodeChars[i]).toUpperCase());
}
System.out.println("\n" + String.valueOf(unicodeChars));

} catch (java.nio.charset.CharacterCodingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}