JAVA字符编码问题

原創 Javascxl 2020-02-20 18:57

一、基础概念
1、 ANSI编码方式包括GBK、GB2312
2、 UTF-8编码方式ISO-10646-1
3、 IE浏览器正常(默认)情况下只解析以ANSI方式存储的中文，否则出现乱码。同时在解析中文较多的网页时ANSI（GB2312）方式最快。
4、 如果采用FileWriter类输出，使用编码方式（UFT-8）（winxp，win7下）输出。
5、 如果采用OutputStreamWriter((new FileOutputStream(f)),"GB2312")方式强制输出为ANSI编码方式。
以下是在Html中中文乱码问题的解决代码！
-----------------------------------------------------------------------------------------------
二、解释
 字节流与字符流主要的区别是他们的的处理方式
字节流是最基本的，所有的InputStream和OutputStream的子类都是,主要用在处理二进制数据，它是按字节来处理的
但实际中很多的数据是文本，又提出了字符流的概念，它是按虚拟机的encode来处理，也就是要进行字符集的转化
这两个之间通过 InputStreamReader,OutputStreamWriter来关联，实际上是通过byte[]和String来关联
在实际开发中出现的汉字问题实际上都是在字符流和字节流之间转化不统一而造成的

在从字节流转化为字符流时，实际上就是byte[]转化为String时，
public String(byte bytes[], String charsetName)
有一个关键的参数字符集编码，通常我们都省略了，那系统就用操作系统的lang
而在字符流转化为字节流时，实际上是String转化为byte[]时，
byte[]    String.getBytes(String charsetName)
也是一样的道理

至于java.io中还出现了许多其他的流，按主要是为了提高性能和使用方便，
如BufferedInputStream,PipedInputStream等
------------------------------------------------------------------------------------------------

import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;


public class CharsetTest {//强制使用ANSI方式存储文件
    public static void main(String[] args) throws Exception {
        File f=new File("C:\\f1.html");
        String str="<html><head><title>"+"哈子飞！"+"</title></head><body>"+"哈子飞" +".html"+"</body></html>";
        OutputStreamWriter osw=new OutputStreamWriter((new FileOutputStream(f)),"GB2312");
        //OutputStreamWriter 是字符流通向字节流的桥梁
        //FileOutputStream此抽象类是表示输出字节流的所有类的超类。

        //输出流接受输出字节并将这些字节发送到某个接收器。
        osw.write(str);
        osw.flush();
        osw.close();
    }
}

三、正确的做字符串编码转换

1.字符串的内部表示？

字符串在java中统一用unicode表示( 即utf-16 LE) , 

对于 String s = "你好哦!";

如果源码文件是GBK编码, 操作系统（windows）默认的环境编码为GBK，那么编译时,  JVM将 按照GBK编码将字节数组解析成字符，然后将字符转换为unicode格式的字节数组，作为内部存储。

当打印这个字符串时，JVM 根据操作系统本地的语言环境，将unicode转换为GBK，然后操作系统将GBK格式的内容显示出来。

 

当源码文件是UTF-8, 我们需要通知编译器源码的格式，javac -encoding utf-8 ... , 编译时，JVM按照utf-8 解析成字符，然后转换为unicode格式的字节数组， 那么不论源码文件是什么格式，同样的字符串，最后得到的unicode字节数组是完全一致的，显示的时候，也是转成GBK来显示（跟OS环境有关）

 

2.乱码如何产生？ 本质上都是由于 字符串原本的编码格式 与 读取时解析用的编码格式不一致导致的。

例如：

String s = "你好哦!";

System.out.println( new String(s.getBytes(),"UTF-8")); //错误，因为getBytes()默认使用GBK编码， 而解析时使用UTF-8编码，肯定出错。

其中 getBytes() 是将unicode 转换为操作系统默认的格式的字节数组，即"你好哦"的 GBK格式，

new String (bytes, Charset) 中的charset 是指定读取 bytes 的方式，这里指定为UTF-8,即把bytes的内容当做UTF-8 格式对待。

如下两种方式都会有正确的结果，因为他们的源内容编码和解析用的编码是一致的。

System.out.println( new String(s.getBytes(),"GBK"));

System.out.println( new String(s.getBytes("UTF-8"),"UTF-8"));

 

那么，如何利用getBytes 和 new String() 来进行编码转换呢？  网上流传着一种错误的方法:

GBK--> UTF-8:    new String( s.getBytes("GBK") , "UTF-8);   ,这种方式是完全错误的，因为getBytes 的编码与  UTF-8 不一致，肯定是乱码。

但是为什么在tomcat 下，使用 new String(s.getBytes("iso-8859-1") ,"GBK") 却可以用呢？ 答案是：

tomcat 默认使用iso-8859-1编码， 也就是说，如果原本字符串是GBK的，tomcat传输过程中，将GBK转成iso-8859-1了，

默认情况下，使用iso-8859-1读取中文肯定是有问题的，那么我们需要将iso-8859-1 再转成GBK， 而iso-8859-1 是单字节编码的，

即他认为一个字节是一个字符， 那么这种转换不会对原来的字节数组做任何改变，因为字节数组本来就是由单个字节组成的，

如果之前用GBK编码，那么转成iso-8859-1后编码内容完全没变， 则 s.getBytes("iso-8859-1")  实际上还是原来GBK的编码内容

则 new String(s.getBytes("iso-8859-1") ,"GBK")  就可以正确解码了。 所以说这是一种巧合。

 

3.如何正确的将GBK转UTF-8 ? （实际上是unicode转UTF-8)

String gbkStr = "你好哦!"; //源码文件是GBK格式，或者这个字符串是从GBK文件中读取出来的, 转换为string 变成unicode格式

//利用getBytes将unicode字符串转成UTF-8格式的字节数组

byte[] utf8Bytes = gbkStr.getBytes("UTF-8"); 

//然后用utf-8 对这个字节数组解码成新的字符串

String utf8Str = new String(utf8Bytes, "UTF-8");

简化后就是:

unicodeToUtf8 (String s) {

return new String( s.getBytes("utf-8") , "utf-8");

}

UTF-8 转GBK原理也是一样

return new String( s.getBytes("GBK") , "GBK");

 

 其实核心工作都由  getBytes(charset) 做了。

getBytes 的JDK 描述：Encodes this String into a sequence of bytes using the named charset, storing the result into a new byte array.

 

另外对于读写文件，

OutputStreamWriter w1 = new OutputStreamWriter(new FileOutputStream("D:\\file1.txt"),"UTF-8");

InputStreamReader( stream, charset)

可以帮助我们轻松的按照指定编码读写文件。


四、字符串的各种编码转换

/**
 * 转换字符串的编码
 */
public class ChangeCharset {
 /** 7位ASCII字符，也叫作ISO646-US、Unicode字符集的基本拉丁块 */
 public static final String US_ASCII = "US-ASCII";

 /** ISO 拉丁字母表 No.1，也叫作 ISO-LATIN-1 */
 public static final String ISO_8859_1 = "ISO-8859-1";

 /** 8 位 UCS 转换格式 */
 public static final String UTF_8 = "UTF-8";

 /** 16 位 UCS 转换格式，Big Endian（最低地址存放高位字节）字节顺序 */
 public static final String UTF_16BE = "UTF-16BE";

 /** 16 位 UCS 转换格式，Little-endian（最高地址存放低位字节）字节顺序 */
 public static final String UTF_16LE = "UTF-16LE";

 /** 16 位 UCS 转换格式，字节顺序由可选的字节顺序标记来标识 */
 public static final String UTF_16 = "UTF-16";

 /** 中文超大字符集 */
 public static final String GBK = "GBK";

 /**
  * 将字符编码转换成US-ASCII码
  */
 public String toASCII(String str) throws UnsupportedEncodingException{
  return this.changeCharset(str, US_ASCII);
 }
 /**
  * 将字符编码转换成ISO-8859-1码
  */
 public String toISO_8859_1(String str) throws UnsupportedEncodingException{
  return this.changeCharset(str, ISO_8859_1);
 }
 /**
  * 将字符编码转换成UTF-8码
  */
 public String toUTF_8(String str) throws UnsupportedEncodingException{
  return this.changeCharset(str, UTF_8);
 }
 /**
  * 将字符编码转换成UTF-16BE码
  */
 public String toUTF_16BE(String str) throws UnsupportedEncodingException{
  return this.changeCharset(str, UTF_16BE);
 }
 /**
  * 将字符编码转换成UTF-16LE码
  */
 public String toUTF_16LE(String str) throws UnsupportedEncodingException{
  return this.changeCharset(str, UTF_16LE);
 }
 /**
  * 将字符编码转换成UTF-16码
  */
 public String toUTF_16(String str) throws UnsupportedEncodingException{
  return this.changeCharset(str, UTF_16);
 }
 /**
  * 将字符编码转换成GBK码
  */
 public String toGBK(String str) throws UnsupportedEncodingException{
  return this.changeCharset(str, GBK);
 }
 
 /**
  * 字符串编码转换的实现方法
  * @param str  待转换编码的字符串
  * @param newCharset 目标编码
  * @return
  * @throws UnsupportedEncodingException
  */
 public String changeCharset(String str, String newCharset)
   throws UnsupportedEncodingException {
  if (str != null) {
   //用默认字符编码解码字符串。
   byte[] bs = str.getBytes();
   //用新的字符编码生成字符串
   return new String(bs, newCharset);
  }
  return null;
 }
 /**
  * 字符串编码转换的实现方法
  * @param str  待转换编码的字符串
  * @param oldCharset 原编码
  * @param newCharset 目标编码
  * @return
  * @throws UnsupportedEncodingException
  */
 public String changeCharset(String str, String oldCharset, String newCharset)
   throws UnsupportedEncodingException {
  if (str != null) {
   //用旧的字符编码解码字符串。解码可能会出现异常。
   byte[] bs = str.getBytes(oldCharset);
   //用新的字符编码生成字符串
   return new String(bs, newCharset);
  }
  return null;
 }

 public static void main(String[] args) throws UnsupportedEncodingException {
  ChangeCharset test = new ChangeCharset();
  String str = "This is a 中文的 String!";
  System.out.println("str: " + str);
  String gbk = test.toGBK(str);
  System.out.println("转换成GBK码: " + gbk);
  System.out.println();
  String ascii = test.toASCII(str);
  System.out.println("转换成US-ASCII码: " + ascii);
  gbk = test.changeCharset(ascii,ChangeCharset.US_ASCII, ChangeCharset.GBK);
  System.out.println("再把ASCII码的字符串转换成GBK码: " + gbk);
  System.out.println();
  String iso88591 = test.toISO_8859_1(str);
  System.out.println("转换成ISO-8859-1码: " + iso88591);
  gbk = test.changeCharset(iso88591,ChangeCharset.ISO_8859_1, ChangeCharset.GBK);
  System.out.println("再把ISO-8859-1码的字符串转换成GBK码: " + gbk);
  System.out.println();
  String utf8 = test.toUTF_8(str);
  System.out.println("转换成UTF-8码: " + utf8);
  gbk = test.changeCharset(utf8,ChangeCharset.UTF_8, ChangeCharset.GBK);
  System.out.println("再把UTF-8码的字符串转换成GBK码: " + gbk);
  System.out.println();
  String utf16be = test.toUTF_16BE(str);
  System.out.println("转换成UTF-16BE码:" + utf16be);
  gbk = test.changeCharset(utf16be,ChangeCharset.UTF_16BE, ChangeCharset.GBK);
  System.out.println("再把UTF-16BE码的字符串转换成GBK码: " + gbk);
  System.out.println();
  String utf16le = test.toUTF_16LE(str);
  System.out.println("转换成UTF-16LE码:" + utf16le);
  gbk = test.changeCharset(utf16le,ChangeCharset.UTF_16LE, ChangeCharset.GBK);
  System.out.println("再把UTF-16LE码的字符串转换成GBK码: " + gbk);
  System.out.println();
  String utf16 = test.toUTF_16(str);
  System.out.println("转换成UTF-16码:" + utf16);
  gbk = test.changeCharset(utf16,ChangeCharset.UTF_16LE, ChangeCharset.GBK);
  System.out.println("再把UTF-16码的字符串转换成GBK码: " + gbk);
  String s = new String("中文".getBytes("UTF-8"),"UTF-8");
  System.out.println(s);
 }
}

------------------------------------------------------------------------------------------------------------------


        java中的String类是按照unicode进行编码的，当使用String(byte[] bytes, String encoding)构造字符串时，encoding所指的是bytes中的数据是按照那种方式编码的，而不是最后产生的String是什么编码方式，换句话说，是让系统把bytes中的数据由encoding编码方式转换成unicode编码。如果不指明，bytes的编码方式将由jdk根据操作系统决定。

        当我们从文件中读数据时，最好使用InputStream方式，然后采用String(byte[] bytes, String encoding)指明文件的编码方式。不要使用Reader方式，因为Reader方式会自动根据jdk指明的编码方式把文件内容转换成unicode编码。

        当我们从数据库中读文本数据时，采用ResultSet.getBytes()方法取得字节数组，同样采用带编码方式的字符串构造方法即可。

ResultSet rs;
bytep[] bytes = rs.getBytes();
String str = new String(bytes, "gb2312");

不要采取下面的步骤。

ResultSet rs;
String str = rs.getString();
str = new String(str.getBytes("iso8859-1"), "gb2312");

        这种编码转换方式效率底。之所以这么做的原因是，ResultSet在getString()方法执行时，默认数据库里的数据编码方式为iso8859-1。系统会把数据依照iso8859-1的编码方式转换成unicode。使用str.getBytes("iso8859-1")把数据还原，然后利用new String(bytes, "gb2312")把数据从gb2312转换成unicode，中间多了好多步骤。

        从HttpRequest中读参数时，利用reqeust.setCharacterEncoding()方法设置编码方式，读出的内容就是正确的了。

五 、汉字为奇数时乱码

问题出现：GBK转UTF-8时，奇数个中文会乱码，偶数个中文不会乱码。
三个中文

Java代码  收藏代码
  1. public static void encodeError() throws UnsupportedEncodingException {  
  2.     String gbk = "我来了";  
  3.     String utf8 = new String(gbk.getBytes("UTF-8"));  
  4.   
  5.     //模拟UTF-8编码的网站显示  
  6.     System.out.println(new String(utf8.getBytes(),"UTF-8"));  
  7. }  
  8. /* 
  9. 我来?? 
  10. */  

 前面三个中文，后面一个中文，都是奇数

Java代码  收藏代码
  1. public static void encodeError2() throws UnsupportedEncodingException {  
  2.     String gbk = "今年是2011年";  
  3.     String utf8 = new String(gbk.getBytes("UTF-8"));  
  4.   
  5.     //模拟UTF-8编码的网站显示  
  6.     System.out.println(new String(utf8.getBytes(),"UTF-8"));  
  7. }  
  8. /* 
  9. 今年??011?? 
  10. */  

 

原因：为什么只有奇数个中文才乱码，偶数个却不乱码？下面来分析原因

Java代码  收藏代码
  1. public static void analyze() throws UnsupportedEncodingException {  
  2.     String gbk = "我来了";  
  3.     String utf8 = new String(gbk.getBytes("UTF-8"));  
  4.     for (byte b : gbk.getBytes("UTF-8")) {  
  5.         System.out.print(b + " ");  
  6.     }  
  7.     System.out.println();  
  8.     for (byte b : utf8.getBytes()) {  
  9.         System.out.print(b + " ");  
  10.     }  
  11. }  
  12. /* 
  13. -26 -120 -111 -26 -99 -91 -28 -70 -122  
  14. -26 -120 -111 -26 -99 -91 -28 -70 63  
  15. */  

 注意最后一个字节不同，上面一行才是正确的UTF-8编码。那么为什么下面一行最后一个字节是63，而不是-122呢？这就是导致乱码的原因所在。
GBK编码是一个中文2个字节，而UTF-8编码是一个中文3个字节，当我们调用getBytes("UTF-8")方法时，会通过计算来增加字节，使得从GBK的2个字节变成UTF-8对应的3个字节。因此，上例3个中文输出了9个字节。

 

这里讲一下怎么通过计算增加字节，不深究的读者可以跳过此段。为了醒目，直接用代码讲解

Java代码  收藏代码
  1. public static void gbk2Utf() throws UnsupportedEncodingException {  
  2.     String gbk = "我来了";  
  3.     char[] c = gbk.toCharArray();  
  4.     byte[] fullByte = new byte[3*c.length];  
  5.     for (int i=0; i<c.length; i++) {  
  6.         String binary = Integer.toBinaryString(c[i]);  
  7.         StringBuffer sb = new StringBuffer();  
  8.         int len = 16 - binary.length();  
  9.         //前面补零  
  10.         for(int j=0; j<len; j++){  
  11.                 sb.append("0");  
  12.             }  
  13.         sb.append(binary);  
  14.         //增加位，达到到24位3个字节  
  15.         sb.insert(0, "1110");  
  16.             sb.insert(8, "10");  
  17.             sb.insert(16, "10");  
  18.             fullByte[i*3] = Integer.valueOf(sb.substring(0, 8), 2).byteValue();//二进制字符串创建整型  
  19.             fullByte[i*3+1] = Integer.valueOf(sb.substring(8, 16), 2).byteValue();  
  20.             fullByte[i*3+2] = Integer.valueOf(sb.substring(16, 24), 2).byteValue();  
  21.     }  
  22.     //模拟UTF-8编码的网站显示  
  23.     System.out.println(new String(fullByte,"UTF-8"));  
  24. }  

 

现在我们来找出最后一个字节是63，而不是-122的原因。

Java代码  收藏代码
  1. public static void analyze2() throws UnsupportedEncodingException {  
  2.     String gbk = "我来了";  
  3.     byte[] utfBytes = gbk.getBytes("UTF-8");//得到9个字节  
  4.     String utf8 = new String(utfBytes);//问题就出在这  
  5.     System.out.print(utf8);  
  6. }  
  7. /* 
  8. 鎴戞潵浜? 
  9. */  

 因为文件是GBK编码，new String(utfBytes)默认就是new String(utfBytes,"GBK")。它会2个字节2个字节地转换成字符，当字节是奇数时最后1个字节转字符就会计算错误，然后直接赋予最后这个字符为?，对应ASCII代码就是63。

 

解决问题
保证字节正确才是硬道理。当调用getBytes("UTF-8")转换成字节数组后，创建ISO-8859-1编码的字符串，ISO-8859-1编码是一个字节对应一个字符，因此不会使最后一个字节错误。

Java代码  收藏代码
  1. public static void correctEncode() throws UnsupportedEncodingException {  
  2.     String gbk = "我来了";  
  3.     String iso = new String(gbk.getBytes("UTF-8"),"ISO-8859-1");  
  4.     for (byte b : iso.getBytes("ISO-8859-1")) {  
  5.         System.out.print(b + " ");  
  6.     }  
  7.     System.out.println();  
  8.   
  9.     //模拟UTF-8编码的网站显示  
  10.     System.out.println(new String(iso.getBytes("ISO-8859-1"),"UTF-8"));  
  11. }  
  12. /* 
  13. -26 -120 -111 -26 -99 -91 -28 -70 -122  
  14. 我来了 
  15. */  

Javascxl
发布了35 篇原创文章 · 获赞 9 · 访问量 14万+
私信 关注
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章