关于GBK与UTF-8互转乱码问题解读_Python

gbk与utf-8互转乱码问题

我们知道在计算机内存中，存储的是二进制数据，在网络传输中，也是二进制数据，但最终呈现给用户的是字符串，二进制与字符串的转化就需要编码、解码的参与，如果世界上只有一种字符编码方式，就不会有乱码这一说了，但事实是，编码的方式太多了，utf-8、utf-32、utf-16、gbk、gb2312、iso-8859-1、big5、unicode等等。由于每个编码的规则不一样，一般都不能用一种进行编码，用另一种进行解码。

如utf-8中，一个字母用一个字节表示，一个汉字用三个字节表示，特殊的汉字用四个字节表示，而gbk中，一个字母用一个字节表示，一个汉字用两个字节表示。

有一个说法，内存中存储的二进制是unicode码，如果内存中的数据需要存储或传输时，才会进行一次转化，将unicode码转化成其它的编码二进制（有待考证）。个人觉得这种方式很合理，毕竟unicode码中每个字符都有独一无二的二进制与之对应。

排查乱码问题，难度在于是在哪个环节出了问题，但乱码的本质都是一样的，读取二进制的编码和最初将字符串转化成二进制的编码方式不一致。

此处说明一个概念，编码指将字符串转化成二进制，解码指将二进制转化成字符串。

utf-8编码，gbk解码

在这我们讨论一下，gbk和utf-8互转的乱码问题，直接上代码：

package com.hskw.test;

import java.io.unsupportedencodingexception;
 
public class codingtest {
	public static void main(string[] args) throws unsupportedencodingexception {
		string str = "你好，世界";
		system.out.println("字符串长度:"+str.length());
		
		byte[] utfbytes = str.getbytes("utf-8");
		system.out.println("utf-8需要"+utfbytes.length+"字节存储");
		
		byte[] gbkbytes = str.getbytes("gbk");
		system.out.println("gbk需要"+gbkbytes.length+"字节存储");
	}
}

以上代码运行打印出以下内容:

字符串长度:5

utf-8需要15字节存储

gbk需要10字节存储

可以看出，utf-8存储一个汉字，需要3个字节，gbk存储一个汉字，需要2个字节。

现用单个字符测试。

package com.hskw.test;

import java.io.unsupportedencodingexception;
 
public class codingtest {
	public static void main(string[] args) throws unsupportedencodingexception {
		string str = "你";
		
		byte[] utfbytes = str.getbytes("utf-8");
		for(byte utfbyte:utfbytes){
			//字节对应的十进制是负数，因java中的二进制使用补码表示的，此处使用0xff 还原成int表示的数据，再转化成16进制
			system.out.print(integer.tohexstring((utfbyte & 0xff)) +",");
		}
		system.out.println();
		string utf2gbkstr = new string(str.getbytes("utf-8"),"gbk");
		system.out.println("utf-8转化成gbk:"+utf2gbkstr);
		
		byte[] gbkbytes = utf2gbkstr.getbytes("gbk");
		for(byte gbkbyte:gbkbytes){
			system.out.print(integer.tohexstring((gbkbyte & 0xff))+",");
		}
		
		system.out.println();
		string gbk2utfstr = new string(utf2gbkstr.getbytes("gbk"),"utf-8");
		system.out.println("gbk转化成utf-8:"+gbk2utfstr);
	}
}

运行上面代码，得出的结果：

e4,bd,a0,

utf-8转化成gbk:浣�

e4,bd,3f,

gbk转化成utf-8:�?

用两个字符测试，将上述代码string str = “你”改成string str = “你好”。运行代码，得出的结果：

e4,bd,a0,e5,a5,bd,

utf-8转化成gbk:浣犲ソ

e4,bd,a0,e5,a5,bd,

gbk转化成utf-8:你好

上述实验中，utf-8转化成gbk出现乱码，这个很好理解，但是再还原回去，gbk转化成utf-8，单个中文字符依然是乱码，两个字符却能正常显示，这个到底是怎么回事呢？

经过一番研究，想把这个事说明白，还需要从它们的编码规则着手。

iso-8859-1

单字节编码，向下兼容ascii，其编码范围是0x00-0xff，0x00-0x7f之间完全和ascii一致，0x80-0x9f之间是控制字符，0xa0-0xff之间是文字符号。

gbk

采用单双字节变长编码，英文使用单字节编码，完全兼容ascii字符编码，中文部分采用双字节编码。双字节其编码范围从8140至fefe（剔除xx7f）。

单字节：00000000 - 01111111
双字节：10000001 01000000 - 11111110 11111110 (剔除******** 01111111)

单字节、双字节的区分通过高字节高位区分，单字节高位为0，双字节的高字节高位为1。

utf-8

可变长字符编码，是unicode码的具体实现，utf-8用1到6个字节编码unicode字符。

utf-8编码规则：如果只有一个字节则其最高二进制位为0；如果是多字节，其第一个字节从最高位开始，连续的二进制位值为1的个数决定了其编码的字节数，其余各字节均以10开头。

1字节 0xxxxxxx
2字节 110xxxxx 10xxxxxx
3字节 1110xxxx 10xxxxxx 10xxxxxx
4字节 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
5字节 111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
6字节 1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx

明白上述gbk和utf-8的编码规则，我们再分析一下，单个中文字符是乱码，两个字符却能正常显示的问题。

“你”

utf-8编码对应的二进制：11100100 10111101 10100000

将上述二进制通过gbk进行解码，根据gbk规则，第一个字节高位为1，使用双字节编码，

“11100100 10111101”解码成“浣”,“10100000”对于gbk来说是非法的，就解码成了一种特殊字符“�”。

看看能不能将“浣�”还原回“你”呢？

gbk编码对应的二进制：11100100 10111101 00111111

看到上述的二进制，根本不符合utf-8编码规则，故用utf-8进行解码，是解码成了一些特殊字符“�?”。

对于上述情况可以看出，一个二进制，如果不符合当前的编码规则，会被解码成特殊字符，但此特殊字符再进行编码，是回不到最初的二进制的。

用同样的方式，分析“你好”为什么最终可以正常显示。

utf-8编码对应的二进制：11100100 10111101 10100000 11100101 10100101 10111101

将上述二进制通过gbk进行编码，根据gbk规则，使用双字节编码，“1100100 10111101”解码成“浣”，“10100000 11100101”解码成“犲”，“10100101 10111101”解码成“ソ”。

看看能不能将“浣犲ソ”还原成“你好”呢？

gbk 编码对应的二进制：11100100 10111101 10100000 11100101 10100101 10111101

可以看出二进制是可以被还原的，将此二进制通过utf-8解码，肯定能变成“你好”。

一个字符串，通过utf-8进行编码，再通过gbk进行解码，再将得到的字符串进行gbk编码，最后将得到的二进制通过utf-8解码，能否还原到最初的字符串，在于utf-8编码后得到的二进制，是否符合gbk的编码规则，如果符合，最终就可以还原，如果不符合，就不可还原。

gbk编码，utf-8解码

package com.hskw.test;

import java.io.unsupportedencodingexception;
 
public class codingtest {
	public static void main(string[] args) throws unsupportedencodingexception {
		string str = "你好";
		
		byte[] gbkbytes = str.getbytes("gbk");
		for(byte gbkbyte:gbkbytes){
			//字节对应的十进制是负数，因java中的二进制使用补码表示的，此处使用0xff 还原成int表示的数据，再转化成16进制
			system.out.print(integer.tohexstring((gbkbyte & 0xff)) +",");
		}
		system.out.println();
		string gbk2utfstr = new string(str.getbytes("gbk"),"utf-8");
		system.out.println("gbk转化成utf-8:"+gbk2utfstr);
		
		byte[] utfbytes = gbk2utfstr.getbytes("utf-8");
		for(byte utfbyte:utfbytes){
			system.out.print(integer.tohexstring((utfbyte & 0xff))+",");
		}
		
		system.out.println();
		string utf2gbkstr = new string(gbk2utfstr.getbytes("utf-8"),"gbk");
		system.out.println("utf-8转化成gbk:"+utf2gbkstr);
	}
}

运行上述代码，结果为：

c4,e3,ba,c3,

gbk转化成utf-8:��

ef,bf,bd,ef,bf,bd,ef,bf,bd,

utf-8转化成gbk:锟斤拷锟�

上述结果应该都在意料之中，我们通过上述的方法分析一下。

“你好”gbk编码的二进制：11000100 11100011 10111010 11000011

gbk编码的二进制数据，完全匹配不了utf-8的编码规则，最终utf-8只能按如下方式匹配，查看第一个字节，开头“110”，理论上匹配两个字节，但看下一个字节，开头却不是“10”，最终“11000100”解码成“�”,看第二个字节开头是“1110”，理论匹配三个字节，看下个字节符合，以“10”开头，但下下个字节开头是“110”，不符合匹配，最终“11100011 10111010”解码成“�”，同理“11000011”也解码成“�”，这个符号都是为找不到对应规则随意匹配的一个特殊字符。

“��”utf-8编码的二进制为：11101111 10111111 10111101 11101111 10111111 10111101 11101111 10111111 10111101

这个二进制和原先的二进制不相同，根本转化不到最初的字符串，按照gbk的编码规则，“11101111 10111111”编码成“锟”,“10111101 11101111” 编码成“斤”，“10111111 10111101”编码成“拷”，“11101111 10111111”编码成“锟”，“10111101”不符合gbk规则，编码成特殊字符“�”。

理论上说，用gbk编码，utf-8解码的字符串是不能还原到最初的字符串的，因utf-8编码规则的特殊性，gbk编出的二进制，是很难匹配上的。