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