java 十六进制转换成字符,字符串转换为十六进制

java 十六进制转换成字符,字符串转换为十六进制,JAVA 十六进制与字符串的转换

笔者前几日在开服过程中需要将字符串转化成为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的观点,版权归原作者所有,仅为传播更多信息之目的,如有侵权请联系,我们将第一时间修改或删除,多谢。

留言与评论(共有 条评论)
   
验证码: