笔者前几日在开服过程中需要将字符串转化成为16进制的字符串,在网上找到了一些方法尝试之后,均发现存在一个问题-字符串转为16进制后再转回来,英文正常,中文出现乱码
笔者前几日在开服过程中需要将字符串转化成为16进制的字符串,在网上找到了一些方法尝试之后,均发现存在一个问题-字符串转为16进制后再转回来,英文正常,中文出现乱码
经过考虑决定通过以下方式进行解决:
1)在将字符串转为16进制之前先进行一次转化,先将其转化成为统一码编码(相当于把中文用英文字符代替),在转化成为16进制
2)相反的,在十六进制转换为字符串后的得到的是统一码编码,此时再将统一码编码解码即可获取原始字符串
代码如下:
/**
* 字符串转换采用双字节对字符进行编码
*/
公共静态字符串string2Unicode(字符串string) {
string buffer unicode=new string buffer();
for(int I=0;我弦乐。长度();i ) {
//取出每一个字符
char c=字符串。查拉特(一);
//转换为采用双字节对字符进行编码
unicode。追加(' \ \ u '整数。tohexstring(c));
}
返回unicode。tostring();
}
*字符串转为16进制
/**
* 字符串转化成为16进制字符串
* @param s
* @返回
*/
公共静态字符串strTo16(字符串s) {
string str=
for(int I=0;国际标准长度();i ) {
int ch=(int)s . charat(I);
字符串S4=整数。tohexstring(ch);
str=str s4
}
返回字符串;
}
*16进制转为字符串
/**
* 16进制转换成为线类型字符串
* @param s
* @返回
*/
公共静态字符串hextringtostring(String s){
if(s==null | | s . equals(')){
返回空
}
s=s.replace(' ',' ');
byte[]bakey word=new byte[s . length()/2];
for(int I=0;我烤鸡。长度;i ) {
尝试{
bakey word[I]=(字节)(0x ff整数。parse int(s . substring(I * 2,i * 2 2),16));
} catch(异常e) {
e。printstacktrace();
}
}
尝试{
s=新字符串(贝克伍德,“UTF-8”);
new String();
} catch(异常e1) {
E1。printstacktrace();
}
返回s;
}
*Unicode转为字符串
/**
* unicode转字符串
*/
公共静态字符串unicode2String(字符串unicode) {
字符串缓冲区string=新字符串缓冲区();
string[]hex=unicode。split(' \ \ \ \ u ');
for(int I=1;我十六进制长度;i ) {
//转换出每一个代码点
int data=integer。parse int(hex[I],16);
//追加成线
字符串。追加((char)数据);
}
返回字符串。tostring();
}
此方法虽然解决了转化过程中中文乱码的问题,但是过于复杂,笔者后来又发现一种新的转化方式,可直接转化,中文不乱码,
代码如下:
*字符串转16进制
/**
* 字符串转换成为16进制(无需统一码编码)
* @param str
* @返回
*/
公共静态字符串str2HexStr(字符串str) {
char[] chars='0123456789ABCDEF ' .toCharArray();
StringBuilder sb=new StringBuilder(');
byte[]bs=str。getbytes();
(同Internationalorganizations)国际组织位;
for(int I=0;长度;i ) {
bit=(bs[I]0x0f 0)4;
某人(somebody的简写)append(chars[bit]);
bit=bs[I]0x0f;
某人(somebody的简写)append(chars[bit]);
//sb。append(');
}
把某人变成字符串. trim();
}
*16进制转为字符串
/**
* 16进制直接转换成为字符串(无需统一码解码)
* @param hexStr
* @返回
*/
公共静态字符串十六进制字符串2r字符串(字符串十六进制字符串){
String str=' 0123456789ABCDEF
char[]hexs=十六进制字符串。tochararray();
字节[]字节=新字节[十六进制字符串。length()/2];
int n;
for(int I=0;我字节。长度;i ) {
n=str。(hexs[2 * I])的索引* 16;
n=str。(hexs[2 * I 1])的指数;
bytes[I]=(byte)(n0x ff);
}
返回新字符串(字节);
}
下面是补充
Java 语言(一种计算机语言,尤用于创建网站)语言(一种计算机语言,尤用于创建网站)字符串和十六进制字符串互转
公共类HexStringUtils {
private static final char[]DIGITS _ HEX={ ' 0 ',' 1 ',' 2 ',' 3 ',' 4 ',' 5 ',' 6 ',' 7 ',' 8 ',' 9 ',' A ',' B ',' C ',' D ',
e ',' F ' };
受保护的静态char[] encodeHex(byte[] data) {
int l=数据长度
char[]out=new char[l 1];
for (int i=0,j=0;I l;i ) {
out[j]=DIGITS _ HEX[(0xf 0 data[I])4];
out[j]=DIGITS _ HEX[0x0F data[I]];
}
退了出来;
}
受保护的静态字节[]解码(字符[]数据){
int len=data .长度
if ((len0x01)!=0) {
抛出新的RuntimeException('字符个数应该为偶数');
}
字节[]输出=新字节[第1条];
for (int i=0,j=0;j leni ) {
int f=toDigit(data[j],j)4;
j;
f |=toDigit(data[j],j);
j;
out[i]=(字节)(f0x ff);
}
退了出来;
}
受保护的静态int toDigit(char ch,int index) {
int digit=Character.digit(ch,16);
if (digit==-1) {
抛出新运行时异常(索引"索引"处的非法十六进制字符“ch”);
}
返回数字;
}
公共静态字符串toHex(字符串str) {
返回新字符串(编码十六进制(字符串。getbytes());
}
十六进制的公共静态字符串(字符串十六进制){
返回新字符串(解码十六进制(十六进制。tochararray()));
}
公共静态void main(String[] args) {
字符串美国广播公司你好;
字符串十六进制=到十六进制;
字符串解码=fromHex(十六进制);
System.out.println('原字符串:)的;
System.out.println('十六进制字符串:'十六进制);
System.out.println('还原:'解码);
}
}
toHexString
公共静态字符串到十六进制字符串(int I)以十六进制的无符号整数形式返回一个整数参数的字符串表示形式。
如果参数为负,那么无符号整数值为参数加上232;否则等于该参数。将该值转换为十六进制(基数16)的无前导0 的美国信息交换标准代码数字字符串。如果无符号数的大小值为零,则用一个零字符0' ('\u0030 ')表示它;否则,无符号数大小的表示形式中的第一个字符将不是零字符。用以下字符作为十六进制数字:
0123456789abcdef
这些字符的范围是从\u0030 '到\u0039 '和从\u0061 '到u0066 '。如果希望得到大写字母,可以在结果上调用String.toUpperCase()方法:
Integer.toHexString(n).toUpperCase()
参数:
异要转换成字符串的整数。
返回:
用十六进制(基数16)参数表示的无符号整数值的字符串表示形式。
//转化字符串为十六进制编码
公共静态字符串到外部字符串(字符串s)
{
string str=
for(int I=0;是。长度();我)
{
int ch=(int)s . charat(I);
字符串S4=整数。tohexstring(ch);
str=str s4
}
返回字符串;
}
//转化十六进制编码为字符串
公共静态字符串toStringHex(字符串s)
{
byte[]bakey word=new byte[s . length()/2];
for(int I=0;我烤鸡。长度;我)
{
尝试
{
bakey word[I]=(字节)(0x ff整数。parse int(s . substring(I * 2,i*2 2),16));
}
捕捉(例外e)
{
e。printstacktrace();
}
}
尝试
{
s=新字符串(baKeyword,‘utf-8’);//UTF-16le:不是
}
捕捉(例外e1)
{
E1。printstacktrace();
}
返回s;
}
//转化十六进制编码为字符串
公共静态字符串toStringHex(字符串s)
{
byte[]bakey word=new byte[s . length()/2];
for(int I=0;我烤鸡。长度;我)
{
尝试
{
bakey word[I]=(字节)(0x ff整数。parse int(s . substring(I * 2,i*2 2),16));
}
捕捉(例外e)
{
e。printstacktrace();
}
}
尝试
{
s=新字符串(baKeyword,‘utf-8’);//UTF-16le:不是
}
捕捉(例外e1)
{
E1。printstacktrace();
}
返回s;
}
公共静态void main(String[] args) {
System.out.println(encode('中文'));
系统。出去。println(解码(编码('中文')));
}
/*
* 16进制数字字符集
*/
私有静态字符串hexString=' 0123456789ABCDEF
/*
* 将字符串编码成16进制数字,适用于所有字符(包括中文)
*/
公共静态字符串编码(字符串)
{
//根据默认编码获取字节数组
byte[]bytes=str。getbytes();
StringBuilder sb=新的StringBuilder(字节。长度* 2);
//将字节数组中每个字节拆解成2位16进制整数
for(int I=0;ibytes .长度我)
{
某人(somebody的简写)追加(十六进制字符串。charat((bytes[I]0x f 0)4));
某人(somebody的简写)追加(十六进制字符串。charat((bytes[I]0x0f)0));
}
归还某人。tostring();
}
/*
* 将16进制数字解码成字符串,适用于所有字符(包括中文)
*/
公共静态字符串解码(字符串字节)
{
ByteArrayOutputStream baos=new ByteArrayOutputStream(字节。长度()/2);
//将每2位16进制整数组装成一个字节
for(int I=0;ibytes。长度();i=2)
鲍斯。写((十六进制字符串。(字节的索引。charat(I))4 |十六进制字符串。(字节的索引。charat(I 1))));
返回新字符串(baos。tobytearray());
}
第二种方法:
将指定字节数组以16进制的形式打印到控制台
包com。南天。我是客户。自动取款机。深发展;
公共类Util {
public Util() {
}
/**
* 将指定字节数组以16进制的形式打印到控制台
* @param提示字符串
* @param b byte[]
* @返回空的
*/
公共静态void printHexString(字符串提示,字节[] b) {
系统输出打印(提示);
for(int I=0;长度;i ) {
字符串十六进制=整数。tohexstring(b[I]0x ff);
if (hex.length()==1) {
十六进制="0"十六进制;
}
系统。出去。打印(十六进制。toupper case()“”);
}
系统。出去。println(');
}
/**
*
* @param b byte[]
* @返回字符串
*/
公共静态字符串Bytes2HexString(byte[] b) {
string ret=
for(int I=0;长度;i ) {
字符串十六进制=整数。tohexstring(b[I]0x ff);
if (hex.length()==1) {
十六进制="0"十六进制;
}
ret=十六进制。toupper case();
}
返回浸水使柔软
}
/**
* 将两个美国信息交换标准代码字符合成一个字节;
* 如:' EF' -0xEF
* @param src0字节
* @param src1字节
* @返回字节
*/
公共静态字节单位字节(字节src0,字节src1) {
byte _b0=Byte.decode('0x '新字符串(新字节[]{src0}).字节值();
_b0=(字节)(_ B0 ^ 4);
byte _b1=Byte.decode('0x '新字符串(新字节[]{src1}).字节值();
byte ret=(byte)(_ B0 ^ _ B1);
返回浸水使柔软
}
/**
* 将指定字符串src,以每两个字符分割转换为16进制形式
* 如:' 2B44EFD9' - byte[]{0x2B,0x44,0xEF,0xD9}
* @param src字符串
* @返回字节[]
*/
公共静态字节[]十六进制字符串2字节(字符串src){
字节[] ret=新字节[8];
byte[]tmp=src。getbytes();
for(int I=0;i8;i ){
ret[i]=uniteBytes(tmp[i*2],tmp[I * 2 1]);
}
返回浸水使柔软
}
}
以上就是Java 语言(一种计算机语言,尤用于创建网站)语言(一种计算机语言,尤用于创建网站)十六进制与字符串的转换的详细内容,更多关于Java 语言(一种计算机语言,尤用于创建网站)语言(一种计算机语言,尤用于创建网站)十六进制的资料请关注我们其它相关文章!
郑重声明:本文由网友发布,不代表盛行IT的观点,版权归原作者所有,仅为传播更多信息之目的,如有侵权请联系,我们将第一时间修改或删除,多谢。