java 转gb2312_字符编码转换_进制转换（GB2312,GBK,JNI,HexTOStr） (转)

//

/*

ASCII 英文一个字节

gb2312，gbk 中文两个字节，英文一个字节

在中文系统中ansi一般指gb2312或gbk

GB2312、GBK都属于双字节字符集 (DBCS)

Utf-8 中文三个字节，英文一个字节

Unicode 中文两个字节，英文两个字

*/

//

//

/*

GB2312 中国国家 标准码

ANSI码(American National Standards Institute)

美国国家  标准学会 的 标准码

ASCII码(America Standard Code for Information Interchange)美国信息交换标准码

你可以认为是不同的东西!

ANSI码仅在前126个与ASCII码相同

*/

//

//

/*

/*

*   二进制、八进制、十进制、十六进制转换   16进制和字符相互转换

*/

//

//

/*

java内部是使用16bit的unicode编码(UTF-16)来表示字符串的，无论中文英文都是2字节；

jni内部是使用UTF-8编码来表示字符串的，UTF-8是变长编码的unicode，一般ascii字符是1字节，中文是3字节；

c/c++使用的是原始数据，ascii就是一个字节了，中文一般是GB2312编码，用两个字节来表示一个汉字。

*/

//

//

//   CodeConver.h

//

#ifndef CodeConver_H

#define CodeConver_H

namespaceCodeConvert

{

#include 

#include 

#include 

#include 

#include 

#include 

//   ANSI To Unicode

//   测试通过

wchar_t* ANSIToUnicode(constchar* str )

{

inttextlen ;

wchar_t* result;

textlen = MultiByteToWideChar( CP_ACP, 0, str,-1, NULL,0 );

if(textlen ==0)

{

returnNULL;

}

result = (wchar_t*)malloc((textlen+1)*sizeof(wchar_t));

memset(result,0,(textlen+1)*sizeof(wchar_t));

MultiByteToWideChar(CP_ACP, 0,str,-1,(LPWSTR)result,textlen );

returnresult;

}

/************************************************************************/

//  Unicode  To ANSI(美国国家标准码)

//  测试通过

//  [2/8/2012 liu]

/************************************************************************/

char* UnicodeToANSI(constwchar_t* str )

{

char* result;

inttextlen;

textlen = WideCharToMultiByte( CP_ACP, 0, str, -1, NULL, 0, NULL, NULL );

if(textlen ==0)

{

returnNULL;

}

result =(char*)malloc((textlen+1)*sizeof(char));

memset( result, 0, sizeof(char) * ( textlen + 1 ) );

WideCharToMultiByte( CP_ACP, 0, str, -1, result, textlen, NULL, NULL );

returnresult;

}

/************************************************************************/

//  UTF8 To Unicode

//  [2/8/2012 liu]

//  测试通过

/************************************************************************/

intUTF8ToUnicode(wchar_t* &result,constchar* utf8 )

{

inttextlen ;

textlen = MultiByteToWideChar( CP_UTF8, 0, (LPCSTR)utf8,-1, NULL,0 );

if(textlen == 0)

{

returnNULL;

}

result = (wchar_t*)malloc((textlen+1)*sizeof(wchar_t));

memset(result,0,textlen * 2 + 2);

intwidelen = MultiByteToWideChar(CP_UTF8, 0,(LPCSTR)utf8,-1,(LPWSTR)result,textlen );

returnwidelen-1;

}

/************************************************************************/

//  UnicodeToUTF8

//  ????????

//  [2/8/2012 liu]

/************************************************************************/

char* UnicodeToUTF8(constwchar_t* str )

{

char* result;

inttextlen;

textlen = WideCharToMultiByte( CP_UTF8, 0, str, -1, NULL, 0, NULL, NULL );

if(textlen == 0)

{

returnNULL;

}

result =(char*)malloc((textlen+1)*sizeof(char));

memset(result, 0, sizeof(char) * ( textlen + 1 ) );

WideCharToMultiByte( CP_UTF8, 0, str, -1, result, textlen, NULL, NULL );

returnresult;

}

/************************************************************************/

//  宽字符 转换为 多字符  Unicode - ANSI

//  ????????

//  [2/8/2012 liu]

/************************************************************************/

char* w2m(constwchar_t* wcs)

{

intlen;

char* buf;

if(wcs =NULL)

{

returnNULL;

}

len =wcstombs(NULL,wcs,0);

if(len == 0)

returnNULL;

buf = (char*)malloc(sizeof(char)*(len+1));

memset(buf, 0, sizeof(char) *(len+1));

len =wcstombs(buf,wcs,len+1);

returnbuf;

}

/************************************************************************/

//  多字符 转换为 宽字符  ANSI - Unicode

//

//  [2/8/2012 liu]

/************************************************************************/

wchar_t* multiByte_to_wideChar(constchar* mbs)

{

intlen;

wchar_t* buf;

if(mbs == NULL)

{

returnNULL;

}

len =mbstowcs(NULL,mbs,0);

if(len == 0)

returnNULL;

buf = (wchar_t*)malloc(sizeof(wchar_t)*(len+1));

memset(buf, 0, sizeof(wchar_t) *(len+1));

len =mbstowcs(buf,mbs,len+1);

returnbuf;

}

/************************************************************************/

//  ANSI To UTF8

//  ？？？？？？

//  [2/8/2012 liu]

/************************************************************************/

char* ANSIToUTF8(constchar* str)

{

returnUnicodeToUTF8(ANSIToUnicode(str));

}

/************************************************************************/

//  UTF8 To ANSI

//  测试通过

//  [2/8/2012 liu]

/************************************************************************/

char* UTF8ToANSI(constchar* str)

{

wchar_t* temp;

if(str == NULL)

{

returnNULL;

}

UTF8ToUnicode(temp,str);

returnUnicodeToANSI(temp);

}

//  测试OK

//  UTF8  convert to GB2312

voidUTF8ToGB2312(constchar*  utf8,char* &gb2312 )

{

intnLen = MultiByteToWideChar( CP_UTF8, 0, utf8, -1, NULL, 0 );

if(nLen == 0)

{

gb2312 = NULL;

return;

}

USHORT* pwszGB2312 =newUSHORT[ nLen + 1 ];

RtlZeroMemory( pwszGB2312, nLen * 2 + 2 );

MultiByteToWideChar( CP_UTF8, 0, utf8, -1, pwszGB2312, nLen );

nLen = WideCharToMultiByte( CP_ACP, 0, pwszGB2312, -1, NULL, 0, NULL, NULL );

CHAR* pszGB2312 =newCHAR[ nLen + 1 ];

RtlZeroMemory( pszGB2312, nLen + 1 );

WideCharToMultiByte( CP_ACP, 0, pwszGB2312, -1, pszGB2312, nLen, NULL, NULL );

gb2312 = pszGB2312;

//      delete [] pszGB2312;

//      delete [] pwszGB2312;

}

// GB2312 convert to UTF8

//  测试通过

intGB2312ToUTF8(constchar* gb2312,char* &utf8 )

{

intnLen1 = MultiByteToWideChar( CP_ACP, 0, gb2312, -1, NULL, 0 );

if(nLen1 == 0)

{

return0;

}

USHORT* pwszUTF8 =newUSHORT[ nLen1 + 1 ];

RtlZeroMemory( pwszUTF8, nLen1 * 2 + 2 );

MultiByteToWideChar( CP_ACP, 0, gb2312, -1, pwszUTF8, nLen1 );

intnLen = WideCharToMultiByte( CP_UTF8, 0, pwszUTF8, -1, NULL, 0, NULL, NULL );

CHAR* pszUTF8 =newCHAR[ nLen + 1 ];

RtlZeroMemory( pszUTF8, nLen + 1 );

WideCharToMultiByte( CP_UTF8, 0, pwszUTF8, -1, pszUTF8, nLen, NULL, NULL );

utf8 = pszUTF8;

returnnLen1-1;

//  delete [] pszUTF8;

//  delete [] pwszUTF8;

}

//  Gb2312 To Unicode

//  测试通过

intGb2312ToUnicode(wchar_t* &OutUnicode,constchar*gb2312)

{

char* utf8 = NULL;

if(gb2312==NULL)

{

OutUnicode = NULL;

return0;

}

GB2312ToUTF8(gb2312,utf8);

intlen = UTF8ToUnicode(OutUnicode,utf8);

returnlen;

}

//

//

/**************************************************************************

*

*  函数名:  HexToString

*

*  描  述:  16进制 转为 字符串

*

*  参  数:  IN：const char *pHex，IN：unsigned long hexLen,

*           OUT：char *pByteString

*

*  返  回:  成功：0 ，   失败：1、2

*

*  作  者： liuguanglin

*

**************************************************************************/

DWORDHexToString(/*IN*/constchar* pHex,

/*IN*/DWORDhexLen,

/*OUT*/char* pByteString)

{

unsigned longi;

if(pHex==NULL)

return1;

if(hexLen <= 0)

return2;

for(i=0;i

{

if(((pHex[i]&0xf0)>>4)>=0 && ((pHex[i]&0xf0)>>4)<=9)

pByteString[2*i]=((pHex[i]&0xf0)>>4)+0x30;

elseif(((pHex[i]&0xf0)>>4)>=10 && ((pHex[i]&0xf0)>>4)<=16)

pByteString[2*i]=((pHex[i]&0xf0)>>4)+0x37;   //  小写：0x37 改为 0x57

if((pHex[i]&0x0f)>=0 && (pHex[i]&0x0f)<=9)

pByteString[2*i+1]=(pHex[i]&0x0f)+0x30;

elseif((pHex[i]&0x0f)>=10 && (pHex[i]&0x0f)<=16)

pByteString[2*i+1]=(pHex[i]&0x0f)+0x37;      //  小写：0x37 改为 0x57

}

return0;

}

/**************************************************************************

*

*  函数名:  StringToHex

*

*  描  述:  字符串 转为 16进制

*

*  参  数:  IN：const char *pHexBYTE，IN：DWORD dwStrLen,OUT：BYTE *pbHex

*

*  返  回:  成功：0 ，   失败：1、2

*

*  作  者： liuguanglin

*

**************************************************************************/

DWORDStringToHex(/*IN*/constBYTE* pByteString,

/*IN */DWORDdwStrLen,

/*OUT*/BYTE* pbHex)

{

DWORDi;

DWORDdwRet;

unsigned char* pTempBuf=NULL;

if(pByteString==NULL || pbHex==NULL)

return1;

if(dwStrLen <= 0)

return2;

if((dwStrLen%2)!=0)

{

pTempBuf=(BYTE*)malloc(dwStrLen+2);

pTempBuf[0]=0x30;

memcpy(&pTempBuf[1],pByteString,sizeof(BYTE)*dwStrLen);

dwRet=StringToHex(pTempBuf,dwStrLen+1,pbHex);

free(pTempBuf);

returndwRet;

}

else

{

for(i=0;i

{

if(i%2==0)

{

if(pByteString[i]>='0'&& pByteString[i]<='9')

pbHex[i/2]=(pByteString[i]-0x30)<<4;

elseif(pByteString[i]>='a'&& pByteString[i]<='f')

pbHex[i/2]=(pByteString[i]-0x57)<<4;

elseif(pByteString[i]>='A'&& pByteString[i]<='F')

pbHex[i/2]=(pByteString[i]-0x37)<<4;

else

return3;

}

else

{

if(pByteString[i]>='0'&& pByteString[i]<='9')

pbHex[i/2]|=pByteString[i]-0x30;

elseif(pByteString[i]>='a'&& pByteString[i]<='f')

pbHex[i/2]|=pByteString[i]-0x57;

elseif(pByteString[i]>='A'&& pByteString[i]<='F')

pbHex[i/2]|=pByteString[i]-0x37;

else

return4;

}

}

}

return0;

}

/*****************************************

HEX 到 ASCII 的转换函数

入口参数： data: 转换数据的入口指针

buffer: 转换后数据入口指针

len : 需要转换的长度

返回参数：转换后数据长度

*******************************************/

inthex_2_ascii(char*data,char*buffer,intlen)

{

constcharascTable[17] = {"0123456789ABCDEF"};

char*tmp_p = buffer;

inti, pos;

pos = 0;

for(i = 0; i 

{

tmp_p[pos++] = ascTable[data[i]>>4&0x0f];

tmp_p[pos++] = ascTable[data[i] & 0x0f];

}

tmp_p[pos] = '\0';

returnpos;

}

/*****************************************

ASCII 到 HEX 的转换函数

入口参数： O_data: 转换数据的入口指针，

N_data: 转换后新数据的入口指针

len : 需要转换的长度

返回参数：-1: 转换失败

其它：转换后数据长度

注意：O_data[]数组中的数据在转换过程中会被修改。

****************************************/

intascii_2_hex(char*O_data,char*N_data,intlen)

{

inti,j,tmp_len;

chartmpData;

for(i = 0; i 

{

if((O_data[i] >='0') && (O_data[i] <='9'))

{

tmpData = O_data[i] - '0';

}

elseif((O_data[i] >='A') && (O_data[i] <='F'))//A....F

{

tmpData = O_data[i] - 0x37;

}

elseif((O_data[i] >='a') && (O_data[i] <='f'))//a....f

{

tmpData = O_data[i] - 0x57;

}

else{

return-1;

}

O_data[i] = tmpData;

}

for(tmp_len = 0,j = 0; j 

{

N_data[tmp_len++] = (O_data[j]<<4) | O_data[j+1];

}

returntmp_len;

}

/**************************************************************************

*

*  函数名:  Soft_swap

*

*  描  述:  RSA密钥 倒序

*

*  参  数:  IN: void *dst, IN: const void *src, IN: size_t count

*

*  返  回:  无

*

*  作  者： liuguanglin

**************************************************************************/

voidSoft_swap(void*dst,constvoid*src,size_tcount)

{

inti;

unsigned char*t;

unsigned char*q = (unsignedchar*)dst;

unsigned char*p = (unsignedchar*) src;

t = q;

if(t == p)

{

q = (unsigned char*)malloc(count);

assert(q);

}

for( i=0; (size_t) i

if(t == p) {

memcpy(p, q, count);

free(q);

}

}

//  编码转换  

 UTF8 convert to GB2312

VOIDUTF82GB2312(/*IN*/constchar* utf8,/* OUT */constchar* gb2312 )

{

intnLen = MultiByteToWideChar( CP_UTF8, 0, utf8 , -1, NULL, 0 );

USHORT* pwszGB2312 =newUSHORT[ nLen + 1 ];

RtlZeroMemory( pwszGB2312, nLen * 2 + 2 );

MultiByteToWideChar( CP_UTF8, 0, utf8 , -1, pwszGB2312, nLen );

nLen = WideCharToMultiByte( CP_ACP, 0, pwszGB2312, -1, NULL, 0, NULL, NULL );

CHAR* pszGB2312 =newCHAR[ nLen + 1 ];

RtlZeroMemory( pszGB2312, nLen + 1 );

WideCharToMultiByte( CP_ACP, 0, pwszGB2312, -1, pszGB2312, nLen, NULL, NULL );

gb2312 = pszGB2312;

delete[] pszGB2312;

delete[] pwszGB2312;

}

 GB2312 convert to UTF8

VOIDGB23122UTF8(/*IN*/constchar* gb2312,/* OUT */constchar* utf8 )

{

intnLen = MultiByteToWideChar( CP_ACP, 0, gb2312 , -1, NULL, 0 );

USHORT* pwszUTF8 =newUSHORT[ nLen + 1 ];

RtlZeroMemory( pwszUTF8, nLen * 2 + 2 );

MultiByteToWideChar( CP_ACP, 0, gb2312 , -1, pwszUTF8, nLen );

nLen = WideCharToMultiByte( CP_UTF8, 0, pwszUTF8, -1, NULL, 0, NULL, NULL );

CHAR* pszUTF8 =newCHAR[ nLen + 1 ];

RtlZeroMemory( pszUTF8, nLen + 1 );

WideCharToMultiByte( CP_UTF8, 0, pwszUTF8, -1, pszUTF8, nLen, NULL, NULL );

utf8 = pszUTF8;

delete[] pszUTF8;

delete[] pwszUTF8;

}

//-----------------------------------------------  JNI 部分  ---------------------------------------

/*

java内部是使用16bit的unicode编码(UTF-16)来表示字符串的，无论中文英文都是2字节；

jni内部是使用UTF-8编码来表示字符串的，UTF-8是变长编码的unicode，一般ascii字符是1字节，中文是3字节；

c/c++使用的是原始数据，ascii就是一个字节了，中文一般是GB2312编码，用两个字节来表示一个汉字。

*/

//  测试Ok

// 只适用于 window平台

char* jstringToWindows( JNIEnv *env, jstring jstr )

{ // unicode(UTF-16) 转换成 GB2312

intlength = (env)->GetStringLength(jstr );

constjchar* jcstr = (env)->GetStringChars(jstr, 0 );

char* rtn = (char*)malloc( length*2+1 );

intsize = 0;

size = WideCharToMultiByte( CP_ACP, 0, (LPCWSTR)jcstr, length, rtn,(length*2+1), NULL, NULL );

if( size <= 0 )

returnNULL;

(env)->ReleaseStringChars(jstr, jcstr );

rtn[size] = 0;

returnrtn;

}

//  测试Ok

//  只适用于 window平台

jstring WindowsTojstring( JNIEnv* env,constchar* str )

{   //GB2312转换成 unicode(UTF-16)

jstring rtn = 0;

intslen = strlen(str);

unsigned short* buffer = 0;

if( slen == 0 )

rtn = (env)->NewStringUTF(str );

else

{

intlength = MultiByteToWideChar( CP_ACP, 0, (LPCSTR)str, slen, NULL, 0 );

buffer = (unsigned short*)malloc( length*2 + 1 );

if( MultiByteToWideChar( CP_ACP, 0, (LPCSTR)str, slen, (LPWSTR)buffer, length ) >0 )

{

rtn = (env)->NewString(  (jchar*)buffer, length );

}

//   rtn = (env)->NewString(  (jchar*)buffer, length );

}

if( buffer )

free( buffer );

returnrtn;

}

/************************************************************************/

//java jni中跨平台(win32或linux,unix)  String转为jstring 。

/************************************************************************/

jstring nativeTojstring( JNIEnv* env,constchar* str )

{

jclass strClass = env->FindClass( "Ljava/lang/String;");

jmethodID ctorID = env->GetMethodID( strClass, "",

"([BLjava/lang/String;)V");

if(env->ExceptionCheck() == JNI_TRUE || str == NULL)

{

env->ExceptionDescribe();

env->ExceptionClear();

printf("nativeTojstring函数转换时,str为空/n");

returnNULL;

}

jbyteArray bytes = env->NewByteArray( strlen(str));

//如果str为空则抛出异常给jvm

env->SetByteArrayRegion( bytes, 0,  strlen(str), (jbyte*)str);

jstring encoding = env->NewStringUTF( "GBK");

jstring strRtn = (jstring)env->NewObject( strClass, ctorID, bytes,

encoding);

//释放str内存

// free(str);

returnstrRtn;

}

/************************************************************************/

//java jni中跨平台(win32或linux,unix)  jstring转为String 。

/************************************************************************/

char* jstringToNative(JNIEnv *env, jstring jstr)

{

if(env->ExceptionCheck() == JNI_TRUE || jstr == NULL)

{

env->ExceptionDescribe();

env->ExceptionClear();

printf("jstringToNative函数转换时,传入的参数str为空");

returnNULL;

}

jbyteArray bytes = 0;

jthrowable exc;

char*result = 0;

if(env->EnsureLocalCapacity(2) 

return0;/* out of memory error */

}

jclass jcls_str = env->FindClass("java/lang/String");

jmethodID MID_String_getBytes = env->GetMethodID(jcls_str, "getBytes","()[B");

bytes = (jbyteArray)env->CallObjectMethod(jstr, MID_String_getBytes);

exc = env->ExceptionOccurred();

if(!exc) {

jint len = env->GetArrayLength( bytes);

result = (char*)malloc(len + 1);

if(result == 0) {

//  这个好像是要在Linux 平台下才有的函数，

//  window 报错：error C2065: 'JNU_ThrowByName' : undeclared identifier

//      JNU_ThrowByName(env, "java/lang/OutOfMemoryError", 0);

env->DeleteLocalRef(bytes);

return0;

}

env->GetByteArrayRegion(bytes, 0, len, (jbyte *)result);

result[len] = 0; /* NULL-terminate */

} else{

env->DeleteLocalRef(exc);

}

env->DeleteLocalRef(bytes);

return(char*)result;

}

}

#endif