检测字节流的编码类型（GBK，UNICODE，GB18030，UTF8..）

最新推荐文章于 2023-06-03 08:20:57 发布
最新推荐文章于 2023-06-03 08:20:57 发布
阅读量969 收藏
点赞数
分类专栏： 辅助知识

想对文本文件做处理，但是有的文本文件没有BOM信息，于是只能对字节流进行检测。

网上找不到综合的，于是干脆自己写了。

比较麻烦的是big5和gbk(在代码里我将ASCII，GB2312，GBK统称为ANSI)的判断，因为gbk的码区包含了big5的部分。

不过测试了不少文件，几十个样本的准确率还是100%。

但估计总有漏网之鱼。

下面为实现代码，供简单参考。

 

=============头文件===================

#defineCODE_ANSI          1
#defineCODE_UNICODE       2
#defineCODE_UTF8          3
#defineCODE_GB18030       4
#defineCODE_UNICODEB      5
#defineCODE_UNICODE4      6
#defineCODE_UNICODE4B     7
#defineCODE_BIG5          8


#defineCODE_ANSIASCII     1
#defineCODE_ANSIGB2312    2
#defineCODE_ANSIGBK       3

 

#defineFILE_TYPE_ANSI     CODE_ANSI
#define FILE_TYPE_UNICODE  CODE_UNICODE
#defineFILE_TYPE_UTF8     CODE_UTF8
#define FILE_TYPE_GB18030  CODE_GB18030
#define FILE_TYPE_UNICODEB  CODE_UNICODEB
#define FILE_TYPE_UNICODE4  CODE_UNICODE4
#define FILE_TYPE_UNICODE4B CODE_UNICODE4B
#defineFILE_TYPE_BIG5     CODE_BIG5

#define CHARBetween(CH_,Low_,Hi_) (((CH_)>=(Low_)) &&((CH_)<=(Hi_)))

#define CHARBetween(CH_,Low_,Hi_) (((CH_)>=(Low_)) &&((CH_)<=(Hi_)))
BOOL   TL_IsATwiceBig5Code(unsigned char* pBuf); //头2字节是否属于big5码区
BOOL   TL_IsATwiceGB2312Code(unsigned char* pBuf);//头2字节是否属于GB码区
BOOL   TL_IsATwiceGBKCode(unsigned char* pBuf);//头2字节是否属于GBK码区
int    TL_IsStreamCodeLikeUTF8(unsigned char* pBuf,size_tLen);//是否utf8，返回0为否，否则返回可能性（75-100）
int    TL_GetFileCodeType(CString FileName,int* HeadLen=NULL,int*ProbalyOut=NULL,int* ANSIDetailCode=NULL);//文件的编码检测
BOOL   TL_DetechStreamCode(unsigned char* pBuf,size_t Len,int*CodeOut,int* ProbalyOut=NULL,int*ANSIDetailCode=NULL);//字节流的编码检测

 

===========代码==============

 


int  TL_IsStreamCodeLikeUTF8(unsigned char*pBuf,size_t Len)
{
  size_t i,AsciiNum=0,ZeroNum=0,LastZero=0,UTFNum=0,UnKnow=0;
 int    UTFRate=0,UnKnowRate=0;

  if (Len<1) return 0;

  for (i=0;i<Len;i++)
  {
    if(pBuf[i]==0)
    {
     ZeroNum++;
     LastZero++;
     continue;
    }
   LastZero=0;
    if(pBuf[i]<=127)
    {
     AsciiNum++;
     continue;
    }

    if(CHARBetween(pBuf[i],0xC0,0xDF) &&((i+1)<Len) &&CHARBetween(pBuf[i+1],0x80,0xBF))
   {//两字节UTF8,110xxx,10xx
     UTFNum +=2;
     i+=1;
     continue;
    }

    if(CHARBetween(pBuf[i],0xE0,0xEF) &&((i+2)<Len) &&CHARBetween(pBuf[i+1],0x80,0xBF)&&CHARBetween(pBuf[i+2],0x80,0xBF))
   {//三字节UTF8
     UTFNum +=3;
     i+=2;
     continue;
    }

   UnKnow++;
  }

  if (UTFNum == 0) return 0;

  UTFRate = (int)(100*((float)UTFNum/(float)(Len-AsciiNum)));
  UnKnowRate = (int)(100*((float)UnKnow/(float)(Len-AsciiNum)));

  if (UTFRate > 98) returnUTFRate; //UTF8字节数的比率超过98

  if ((UTFRate > 95)&& (UTFNum>30)&& (UnKnowRate<5))return UTFRate;  //UTF8字节数的比率超过95 且个数差不多可以接受

  if ((UTFRate > 75)&& (UTFNum>150)&& (UnKnowRate<20))return UTFRate;

  return 0;
}

BOOL   TL_IsATwiceBig5Code(unsigned char* pBuf)
{
#define BIGZONENum  8
  const unsigned charBig5Tbl[BIGZONENum][12]={
   {0xA1,0xA2,0x40,0x7E,0xA1,0xFE,0},
   {0xA3,0xA3,0x40,0x7E,0xA1,0xBF,0xE1,0xE1,0},
   {0xA4,0xC5,0x40,0x7E,0xA1,0xFE,0},
   {0xC6,0xC6,0x40,0x7E,0xA1,0xfE,0},
   {0xC7,0xC7,0x40,0x7E,0xA1,0xFE,0},
   {0xC8,0xC8,0x40,0x7E,0xA1,0xD3,0},
   {0xC9,0xF8,0x40,0x7E,0xA1,0xFE,0},
   {0xF9,0xF9,0x40,0x7E,0xA1,0xD5,0xD6,0xDC,0xDD,0xFE,0}
  };
  int  Zone,hi,low;

  if ((pBuf[0] <Big5Tbl[0][0])|| (pBuf[0] >Big5Tbl[BIGZONENum-1][1])) return FALSE;

 
  hi = BIGZONENum-1;
  low = 0;
  while (low <= hi)
  {
    Zone =(hi+low+1)/2;
    if(CHARBetween(pBuf[0],Big5Tbl[Zone][0],Big5Tbl[Zone][1]))break;
    if (low ==hi) return FALSE;
    if (pBuf[0]< Big5Tbl[Zone][0]) hi= Zone-1;
    else low =Zone+1;
  }

  for (low=2;;low+=2)
  {
    if(Big5Tbl[Zone][low] == 0) return FALSE;
    if(CHARBetween(pBuf[1],Big5Tbl[Zone][low],Big5Tbl[Zone][low+1]))return TRUE;
  }
  return FALSE;
}


BOOL   TL_IsATwiceGB2312Code(unsigned char* pBuf)
{   
#define GB2312ZONENum  9
  const unsigned charGB2312Tbl[GB2312ZONENum][10]={
   {0xA1,0xA1,0xFE,0},
   {0xA2,0xB1,0xE2,0xE5,0xEE,0xF1,0xFC,0},
   {0xA3,0xA1,0xFE,0},
   {0xA4,0xA1,0xF3,0},
   {0xA5,0xA1,0xF6,0},
   {0xA6,0xA1,0xB8,0xC1,0xD8,0},
   {0xA7,0xA1,0xC1,0xD1,0xF1,0},
   {0xA8,0xA1,0xBA,0xC5,0xE9,0},
   {0xA9,0xA4,0xEF,0}
  };
  int  Zone,hi,low;

  if ((pBuf[0] < 0xA1)||(pBuf[0] > 0xF7)) return FALSE;

 
  hi = GB2312ZONENum-1;
  low = 0;
  while (low <= hi)
  {
    Zone =(hi+low+1)/2;
    if (pBuf[0]== GB2312Tbl[Zone][0])
    {
     for (low=1;;low+=2)
     {
       if (GB2312Tbl[Zone][low] == 0) return FALSE;
       if(CHARBetween(pBuf[1],GB2312Tbl[Zone][low],GB2312Tbl[Zone][low+1]))return TRUE;
     }
    }
    if (low ==hi) break;
    if (pBuf[0]< GB2312Tbl[Zone][0]) hi= Zone-1;
    else low =Zone+1;
  }

  if ((pBuf[0] == 0xD7)&& CHARBetween(pBuf[1],0xFA,0xFE))return FALSE;
  if (CHARBetween(pBuf[0],0xB0,0xF7)&& CHARBetween(pBuf[1],0xA1,0xFE))return TRUE;

  return FALSE;
}

BOOL   TL_IsATwiceGBKCode(unsigned char* pBuf)
{
  if((pBuf[0]<0x81)||(pBuf[0]==0xFF)) returnFALSE;
  if((pBuf[1]<0x40)||(pBuf[1]==0xFF)) returnFALSE;
  if ((pBuf[1]==0x7F)) return FALSE;

  return TRUE;
}


BOOL    TL_DetechStreamCode(unsigned char* pBuf,size_t Len,int*CodeOut,int* ProbalyOut,int* ANSIDetailCode)
{{
  size_t i,AsciiNum=0,ZeroNum=0,UnKnow=0;
  size_t  CharNum[10];
 int    CharRate[10],CharRateExpend[10];
 int    TypeMatchNum=0;
  size_t  LastConsZero=0;
 int    BufCharCode=0,AnsiExType=0,BufCharProbaly=0;

  MEMZERO(CharNum);
  MEMZERO(CharRate);
  MEMZERO(CharRateExpend);
  if (CodeOut!=NULL) *CodeOut = 0;
  if (Len<1) return 0;

  for (i=0;i<Len;i++)
  {
    if(pBuf[i]==0)
    {
     ZeroNum++;
     LastConsZero++;
     if (LastConsZero > 5) break;
     continue;
    }
   LastConsZero=0;
    if(pBuf[i]<=0x7F)
    {
     if (((i+1)<Len) &&(pBuf[i+1] == 0)) // 先看是否unicode
     {
       CharNum[CODE_UNICODE] += 2;
       i++;
       continue;
     }
     AsciiNum++;
     continue;
    }

    if(CHARBetween(pBuf[i],0xC0,0xDF) &&((i+1)<Len) &&CHARBetween(pBuf[i+1],0x80,0xBF))
   {//两字节UTF,110xxx,
     CharNum[CODE_UTF8] += 2;
     i+=1;
     continue;
    }

    if(CHARBetween(pBuf[i],0xE0,0xEF) &&((i+2)<Len) &&CHARBetween(pBuf[i+1],0x80,0xBF) &&CHARBetween(pBuf[i+2],0x80,0xBF))
   {//三字节UTF
     CharNum[CODE_UTF8] += 3;
     i+=2;
     continue;
    }

    if(CHARBetween(pBuf[i],0x81,0xFE) &&((i+3)<Len) &&CHARBetween(pBuf[i+1],0x30,0x39) &&CHARBetween(pBuf[i+2],0x81,0xFE)&&CHARBetween(pBuf[i+3],0x30,0x39))
   {//4字节gb18030
     CharNum[CODE_GB18030] += 4;
     i+=3;
     continue;
    }

   TypeMatchNum =0;
    if(((i+2)<Len) &&TL_IsATwiceBig5Code(pBuf+i))
    {
     CharNum[CODE_BIG5] += 2;
     TypeMatchNum++;
     
    }

    if(CHARBetween(pBuf[i],0x81,0xFE) &&((i+1)<Len) &&CHARBetween(pBuf[i+1],0x40,0xFE) &&(pBuf[i+1] !=0x7F))
    {//字节GBK  字符范围 首字节0x81 - 0xFE,低字节0x40 - 0xFE ,剔除xx7F 一条线  ,包含GB2312
     CharNum[CODE_ANSI] += 2;
     TypeMatchNum+=2;

     
     if((ANSIDetailCode!=NULL)&&TL_IsATwiceGB2312Code(pBuf+i)) CharNum[0] += 2;
     
    }

    if(TypeMatchNum>0)
    {
     i++;
     continue;
    }

   UnKnow++;
  }
 
  for (i=1;i<10;i++)
  {
    if(CharNum[i] == 0) continue;
    CharRate[i]= (int)(100*((float)CharNum[i] /(float)(Len-AsciiNum)));
    if(i!=CODE_UNICODE)  CharRateExpend[i] =(int)(100*((float)(CharNum[i]+AsciiNum) /(float)Len));
    elseCharRateExpend[i] =(int)(100*((float)(CharNum[i]+UnKnow+CharNum[CODE_ANSI])/(float)Len));
  }

  for (i=1;i<10;i++)
  {
    if(CharRate[i] < 76)  continue;
    if(BufCharProbaly>CharRate[i]) continue;
    BufCharCode= i;
   BufCharProbaly = CharRate[i];
  }
  if (BufCharCode == 0)
  {
    for(i=1;i<10;i++)
    {
     if (CharRateExpend[i] < 90) continue;
     if (BufCharProbaly>CharRateExpend[i])continue;
     BufCharCode = i;
     BufCharProbaly = CharRateExpend[i];
    }
  }
 
  if ((BufCharCode == CODE_ANSI)&& (CharNum[CODE_ANSI]<= CharNum[CODE_BIG5]+2)&&(CharNum[CODE_ANSI]>30)) BufCharCode =CODE_BIG5;

  if (AsciiNum == Len)
  {
    BufCharCode= CODE_ANSI;
    AnsiExType =CODE_ANSIASCII;
   BufCharProbaly = 100;
  }
  else if((ANSIDetailCode!=NULL)&&(BufCharCode== CODE_ANSI)&&(AnsiExType ==0))
  {
    if(CharNum[0] == CharNum[CODE_ANSI]) AnsiExType =CODE_ANSIGB2312;
    elseAnsiExType = CODE_ANSIGBK;
  }

  if (CodeOut!=NULL) *CodeOut =BufCharCode;
  if (ProbalyOut!=NULL) *ProbalyOut =BufCharProbaly;
  if((ANSIDetailCode!=NULL)&&(AnsiExType>0)) *ANSIDetailCode = AnsiExType;

  if (BufCharCode>0) returnTRUE;
  return FALSE;
}


int TL_GetFileCodeType(CString FileName,int* HeadLen,int*ProbalyOut,int* ANSIDetailCode)
{
  CFile file;
  unsigned char Head[10248];
  BOOL  bGetTrueType=TRUE;
  UINT i=0,ReadLen=0,PerRead=10240;
  int  iDetechCode=0;

  if (HeadLen!=NULL) *HeadLen = 0;
  if(!file.Open(FileName,CFile::modeReadWrite|CFile::modeNoTruncate))
  {
    returnERR_OPEN_FILE;
  }

  MEMZERO(Head);

  file.Read(Head,20);
  file.Close();

  if((Head[0]==0xEF)&&(Head[1]==0xBB)&&(Head[2]==0xBF))
  {
    if(HeadLen!=NULL) *HeadLen = 3;
    returnFILE_TYPE_UTF8;
  }

  if((Head[0]==0xFF)&&(Head[1]==0xFE))
  {
    if((Head[2]==0x00)&&(Head[3]==0x00))
    {
     if (HeadLen!=NULL) *HeadLen = 4;
     return FILE_TYPE_UNICODE4;
    }
    if(HeadLen!=NULL) *HeadLen = 2;
    returnFILE_TYPE_UNICODE;
  }

  if((Head[0]==0x84)&&(Head[1]==0x31)&&(Head[2]==0x95)&&(Head[3]==0x33))
  {
    if(HeadLen!=NULL) *HeadLen = 4;
    returnFILE_TYPE_GB18030;
  }

  if((Head[0]==0xFE)&&(Head[1]==0xFF))
  {
    if(HeadLen!=NULL) *HeadLen = 2;
    returnFILE_TYPE_UNICODEB;
  }
  if((Head[0]==0x00)&&(Head[1]==0x00)&&(Head[2]==0xFE)&&(Head[3]==0xFF))
  {
    if(HeadLen!=NULL) *HeadLen = 4;
    returnFILE_TYPE_UNICODE4B;
  }
  if (!bGetTrueType) return FILE_TYPE_ANSI;

  if(!file.Open(FileName,CFile::modeReadWrite|CFile::modeNoTruncate))
  {
    returnERR_OPEN_FILE;
  }

  iDetechCode = 0;
  ReadLen=PerRead;
  while (ReadLen==PerRead)
  {
   MEMZERO(Head);
    ReadLen =file.Read(Head,PerRead);
    if(TL_DetechStreamCode(Head,ReadLen,&iDetechCode,ProbalyOut,ANSIDetailCode))break;
  }
  file.Close();

 

if (iDetechCode >0) returniDetechCode;
  return FILE_TYPE_ANSI;
}

kendyhj9999
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
gbk18030 java_编码 ASCII ISO8859-1 GB2312 GBK GB18030 UNICODE UTF
weixin_33362096的博客
03-05 540
常见的编码如下：国外：ASCII(1968年) ISO8859-1(1987年)UNICODE(1994年)+ + + + + + ...
根据字节流判断内容是否使用UTF-8编码
weixin_30532973的博客
10-17 253
问题： 只有一个文本内容，文本没有BOM头，怎样才能判断当前文本是否使用UTF-8编码输出呢？ 思路： 我们都知道使用UTF-8编码输出中文是有多个字节，而且从unicode码转换成UTF-8输出有固定规则，那我们是否可以判断字节流里面是否有满足UTF-8规则的字节串来判断内容是否使用UTF-8编码呢？答案是可以，但不完美。 通过查询https://en.wikipedia.o...
判断是否utf8编码的算法
PI2024的专栏
11-29 4646
参考：http://www.cnblogs.com/powertoolsteam/archive/2010/09/20/1831638.html 问题：由于utf8编码分为有bom头和无bom头，而有bom头的编码很好判断，如果前三个字节是0xE 0xBB 0xBF，那么就是utf8带bom的编码，如果没有bom头，则不能好快的判断到底是utf8还是ansi编码，因为他们都没有头，且全英文的编码
GBK GB2312 utf-8 编码测试
喋血雄鹰
04-27 233
很好的参考：[url]http://sunfish.blog.51cto.com/417500/142577/[/url] 编码解码分析（仅是乱码的一种情况）： 中文的utf-8编码是 每个中文用三个字节来编码，比如下面例子生成6个字节： c1:[code="java"]"亢磊".getBytes("utf-8") (byte[]) [-28, -70, -94, -25, -93...
java判断图片的编码格式
L_GTim的专栏
07-28 2212
有时候图片被更改了后缀名，但是它的编码方式还是不变的。所以不能光通过后缀名来判断这个图片是jpeg还是png或者bmp的。以下这种方法可以帮助你正确判断文件的编码格式。  public static String getFormatName(Object object) throws Exception{   ImageInputStream iis = ImageIO.createI
Java| 编码格式介绍（ANSI、GBK、GB2312、UTF-8、GB18030和 UNICODE）
热门推荐
YvesHe的专栏
10-19 1万+
编码一直是让新手头疼的问题，特别是 GBK、GB2312、UTF-8 这三个比较常见的网页编码的区别，更是让许多新手晕头转向，怎么解释也解释不清楚。但是编码又是那么重要，特别在网页这一块。如果你打出来的不是乱码，而网页中出现了乱码，绝大部分原因就出在了编码上了。此外除了乱码之外，还会出现一些其他问题（例如：IE6 的 CSS 加载问题）等等。我写本文的目的，就是要彻底解释清楚这个编码问题！如果你遇到
gbk_utf8.tar.gz_GBK_GBK转UTF8 C_UTF8转GBK_gbk转utf8
09-24
在实现过程中，需要对字符编码的细节有深入理解，例如GBK编码中每个汉字通常由两个字节表示，而UTF-8则根据字符的Unicode值使用1到4个字节。因此，转换过程中需要准确地识别和处理这些字节序列。 在进行GBK到UTF-8...
unicode转gb18030编码
02-08
在实际应用中，由于历史原因，某些系统或软件可能只支持GB18030编码，因此需要将Unicode（通常以UTF-8形式存在）转换为GB18030。这个转换过程通常包括两个步骤：UTF-8到Unicode，然后Unicode到GB18030。 **1. UTF-8...
unicode转gb18030的c代码
05-08
1. **读取Unicode字符**：从输入流或字符串中读取Unicode字符，通常以UTF-16编码表示，因为Unicode的基本多文种平面（BMP）使用两个字节表示。 2. **查找映射表**：根据读取的Unicode码点，在预先准备好的映射表中...
字符编码：GBK、GB2312、UTF-8
09-29
在处理不同编码的转换时，通常需要通过Unicode作为中间桥梁，比如GBK或GB2312需要先转换成Unicode，然后再转换成UTF-8。这个过程需要注意的是，不正确的转换可能导致乱码问题。 总的来说，选择哪种编码取决于具体的...
自动检测汉字GB18030编码与UTF-8编码
03-13
想到如下特征来识别汉字： 1. 如果第1位是0就不需要判断的，一定是ASCII字符。 2. 如果第1位是1开头的，第2位是0开头的，一定是GB编码。 3. 如果第1位是非1110开头的，则一定是GB编码。 4. 多做几个汉字判断。
检测字节流是否是UTF8编码
Demon的垃圾桶
09-19 857
几天前偶尔看到有人发帖子问“如何自动识别判断url中的中文参数是GB2312还是Utf-8编码”也拜读了wcwtitxu使用巨牛的正则表达式检测UTF8编码的算法。使用无数或条件的正则表达式用起来却是性能不高。刚好曾经在项目中有类似的需求，这里把处理思路和整理后的源代码贴出来供大家参考先聊聊原理：UTF8的编码规则如下表看起来很复杂，总结起来如下：ASCII码（U+0000 - U+007F），不编码其余编码规则为第一个Byte二进制以形式为n个1紧跟个0 (n >= 2), 0后面的位数用来存储真正的字符
判断一个字符串是utf-8还是gb18030编码方法的最佳实践
zhtrue的专栏
10-24 3870
这个问题之所以是一个问题，是因为有一些字符串是能够同时符合两种编码规范的，比如：
字节流、字符流、ascii、gb2312、gbk、gb18030、乱码、什么时候使用字节流，什么时候使用字符流，二者区别。分分钟透彻理解。
请叫我大师兄
11-19 2761
早先在 Java IO包里面出现的都是字节流，因为数据，无论是硬盘上的还是内存中的，都是字节，都是二进制数据10101的方式进行传输或保存的。 那么为什么后来又出现了个字符流的概念呢？ 在我们处理数据的时候，数据的种类有很多，比如dvd，图片，文本，mp3等对于dvd，mp3等都是媒体数据，无论什么数据都是二进制的，0101之类的方式存在的。所以无论什么数据字节流都可以搞定。但是其中有一部
字符集、字符编码格式检测和转码
zhaominyong的专栏
06-01 3079
字符集、字符编码格式检测和转码
Java 判断字节流是否是 UTF8 编码
最新发布
quanzhan_King的博客
06-03 1764
遇到本来设计时使用 GBK 编码处理的地方，在实际使用过程导入了 UTF8 编码，造成了显示文本为乱码的现象，在了解 UTF8，GBK 编码和 Unicode 标准之后，编写了 Java 判断字节流是否是 UTF8 编码的程序，如果是 UTF8 编码，则转换成 GBK 编码。
Java之——检测字符串使用的编码格式
冰河的专栏
03-18 2333
不多说，直接上代码吧。 package com.taiping.vehicle.version11.utils; import java.io.File; import java.io.FileInputStream; import java.io.InputStream; import java.net.URL; /** * Detect encoding * @author F...
gb18030编码格式了解和应用
SpeWong的博客
06-07 7072
编码格式经常用的有UTF-8、GBK，之前用eclipse开发的时候默认格式就是GBK，现在换成AS后默认格式变成了标准的UTF-8。最近做银行业务发现其报文用16进制字符串转成byte数组后，再分别用UTF-8和GBK转码都会有乱码的情况出现。使用UTF-8转码时由于全部是乱码因此判定UTF-8编码肯定是不规范的，使用GBK转码发现有部分字是乱码于是进入正文开始了对编码格式的研究。    乱码
Unicode编码详解：UCS、UTF、BMP与字节序
"这篇文章除了探讨Unicode编码的基础概念，还涉及了UCS、UTF、BMP、BOM等相关的编码术语，并解答了关于Windows记事本识别编码方式的问题，以及UTF-16与UCS2之间的关系。" 文章详细内容： 在计算机科学领域，字符...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值