Java byte数组与十六进制字符串互转
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
|
/**
* href="http://commons.apache.org/codec/">http://commons.apache.org/codec/
*
* @author Aub
*
*/
public
class
Hex {
/**
* 用于建立十六进制字符的输出的小写字符数组
*/
private
static
final
char
[] DIGITS_LOWER = {
'0'
,
'1'
,
'2'
,
'3'
,
'4'
,
'5'
,
'6'
,
'7'
,
'8'
,
'9'
,
'a'
,
'b'
,
'c'
,
'd'
,
'e'
,
'f'
};
/**
* 用于建立十六进制字符的输出的大写字符数组
*/
private
static
final
char
[] DIGITS_UPPER = {
'0'
,
'1'
,
'2'
,
'3'
,
'4'
,
'5'
,
'6'
,
'7'
,
'8'
,
'9'
,
'A'
,
'B'
,
'C'
,
'D'
,
'E'
,
'F'
};
/**
* 将字节数组转换为十六进制字符数组
*
* @param data
* byte[]
* @return 十六进制char[]
*/
public
static
char
[] encodeHex(
byte
[] data) {
return
encodeHex(data,
true
);
}
/**
* 将字节数组转换为十六进制字符数组
*
* @param data
* byte[]
* @param toLowerCase
*
* @return 十六进制char[]
*/
public
static
char
[] encodeHex(
byte
[] data,
boolean
toLowerCase) {
return
encodeHex(data, toLowerCase ? DIGITS_LOWER : DIGITS_UPPER);
}
/**
* 将字节数组转换为十六进制字符数组
*
* @param data
* byte[]
* @param toDigits
* 用于控制输出的char[]
* @return 十六进制char[]
*/
protected
static
char
[] encodeHex(
byte
[] data,
char
[] toDigits) {
int
l = data.length;
char
[] out =
new
char
[l <<
1
];
// two characters form the hex value.
for
(
int
i =
0
, j =
0
; i < l; i++) {
out[j++] = toDigits[(
0xF0
& data[i]) >>>
4
];
out[j++] = toDigits[
0x0F
& data[i]];
}
return
out;
}
/**
* 将字节数组转换为十六进制字符串
*
* @param data
* byte[]
* @return 十六进制String
*/
public
static
String encodeHexStr(
byte
[] data) {
return
encodeHexStr(data,
true
);
}
/**
* 将字节数组转换为十六进制字符串
*
* @param data
* byte[]
* @param toLowerCase
*
* @return 十六进制String
*/
public
static
String encodeHexStr(
byte
[] data,
boolean
toLowerCase) {
return
encodeHexStr(data, toLowerCase ? DIGITS_LOWER : DIGITS_UPPER);
}
/**
* 将字节数组转换为十六进制字符串
*
* @param data
* byte[]
* @param toDigits
* 用于控制输出的char[]
* @return 十六进制String
*/
protected
static
String encodeHexStr(
byte
[] data,
char
[] toDigits) {
return
new
String(encodeHex(data, toDigits));
}
/**
* 将十六进制字符数组转换为字节数组
*
* @param data
* 十六进制char[]
* @return byte[]
* @throws RuntimeException
* 如果源十六进制字符数组是一个奇怪的长度,将抛出运行时异常
*/
public
static
byte
[] decodeHex(
char
[] data) {
int
len = data.length;
if
((len &
0x01
) !=
0
) {
throw
new
RuntimeException(
"Odd number of characters."
);
}
byte
[] out =
new
byte
[len >>
1
];
// two characters form the hex value.
for
(
int
i =
0
, j =
0
; j < len; i++) {
int
f = toDigit(data[j], j) <<
4
;
j++;
f = f | toDigit(data[j], j);
j++;
out[i] = (
byte
) (f &
0xFF
);
}
return
out;
}
/**
* 将十六进制字符转换成一个整数
*
* @param ch
* 十六进制char
* @param index
* 十六进制字符在字符数组中的位置
* @return 一个整数
* @throws RuntimeException
* 当ch不是一个合法的十六进制字符时,抛出运行时异常
*/
protected
static
int
toDigit(
char
ch,
int
index) {
int
digit = Character.digit(ch,
16
);
if
(digit == -
1
) {
throw
new
RuntimeException(
"Illegal hexadecimal character "
+ ch
+
" at index "
+ index);
}
return
digit;
}
public
static
void
main(String[] args) {
String srcStr =
"待转换字符串"
;
String encodeStr = encodeHexStr(srcStr.getBytes());
String decodeStr =
new
String(decodeHex(encodeStr.toCharArray()));
System.out.println(
"转换前:"
+ srcStr);
System.out.println(
"转换后:"
+ encodeStr);
System.out.println(
"还原后:"
+ decodeStr);
}
}
|