我有一个字节数组。 我希望将该数组的每个字节字符串转换为其对应的十六进制值。
Java中是否有将字节数组转换为十六进制的函数？
答案 0 :(得分：280)
byte[] bytes = {-1, 0, 1, 2, 3 };
StringBuilder sb = new StringBuilder();
for (byte b : bytes) {
sb.append(String.format("%02X ", b));
}
System.out.println(sb.toString());
// prints "FF 00 01 02 03 "
java.util.Formatter syntax
%[flags][width]conversion
'0' - 结果将为零填充2 'X' - 结果格式为十六进制整数，大写查看问题的文本，这也可能是所要求的：
String[] arr = {"-1", "0", "10", "20" };
for (int i = 0; i < arr.length; i++) {
arr[i] = String.format("%02x", Byte.parseByte(arr[i]));
}
System.out.println(java.util.Arrays.toString(arr));
// prints "[ff, 00, 0a, 14]"
这里有几个答案使用Integer.toHexString(int);这是可行的，但有一些警告。由于参数是int，因此对byte参数执行扩展的基元转换，这涉及符号扩展。
byte b = -1;
System.out.println(Integer.toHexString(b));
// prints "ffffffff"
用Java签名的8位byte符号扩展为32位int。要有效撤消此符号扩展名，可以使用byte屏蔽0xFF。
byte b = -1;
System.out.println(Integer.toHexString(b & 0xFF));
// prints "ff"
使用toHexString的另一个问题是它没有填充零：
byte b = 10;
System.out.println(Integer.toHexString(b & 0xFF));
// prints "a"
这两个因素的结合应该使String.format解决方案更具优先性。
byte，从-128到127，包括答案 1 :(得分：58)
我发帖是因为现有的答案都没有解释为什么他们的方法有效，我认为这对这个问题非常重要。在某些情况下，这会导致所提出的解决方案显得不必要地复杂和微妙。为了说明我将提供一个相当简单的方法，但我会提供更多细节来帮助说明为什么它的工作原理。
首先，我们要做什么？我们希望将字节值（或字节数组）转换为表示ASCII中十六进制值的字符串。所以第一步是找出Java中的字节到底是什么：
字节数据类型是 8位有符号二进制补码整数。它的最小值为-128，最大值为127（含）。字节数据类型可用于在大型阵列中保存内存，其中节省的内存实际上很重要。它们也可用于代替int，其限制有助于澄清您的代码;变量范围有限的事实可以作为一种文档形式。
这是什么意思？一些事情：首先，最重要的是，这意味着我们正在使用 8位。因此，例如我们可以将数字2写为0000 0010.但是，由于它是二进制补码，我们写一个负2，如下所示：1111 1110.还意味着转换为十六进制非常简单。也就是说，您只需将每个4位段直接转换为十六进制。请注意，要理解此方案中的负数，首先需要了解两个补码。如果您还不了解两个补码，可以在这里阅读一个很好的解释：http://www.cs.cornell.edu/~tomf/notes/cps104/twoscomp.html
一旦数字是二进制补码，将它转换为十六进制就很简单了。通常，从二进制转换为十六进制是非常简单的，正如您将在接下来的两个示例中看到的那样，您可以直接从二进制补码转换为十六进制。
示例1：将2转换为十六进制。
1）首先将2转换为2的二进制补码：
2 (base 10) = 0000 0010 (base 2)
2）现在将二进制转换为十六进制：
0000 = 0x0 in hex
0010 = 0x2 in hex
therefore 2 = 0000 0010 = 0x02.
示例2：将-2（以二进制补码）转换为十六进制。
1）首先将-2转换为二进制的二进制补码：
-2 (base 10) = 0000 0010 (direct conversion to binary)
1111 1101 (invert bits)
1111 1110 (add 1)
therefore: -2 = 1111 1110 (in two's complement)
2）现在转换为十六进制：
1111 = 0xF in hex
1110 = 0xE in hex
therefore: -2 = 1111 1110 = 0xFE.
<小时/>
现在我们已经涵盖了这个概念，你会发现我们可以通过一些简单的屏蔽和移动实现我们想要的。要理解的关键是您尝试转换的字节已经是两个补码。您自己不进行此转换。我认为这是对这个问题的一个主要困惑点。以下面的字节数组为例：
byte[] bytes = new byte[]{-2,2};
我们只是手动将它们转换为十六进制，但是我们怎样才能用Java做到这一点？方法如下：
第1步：创建一个StringBuffer来保存我们的计算。
StringBuffer buffer = new StringBuffer();
第2步：隔离高阶位，将它们转换为十六进制，然后将它们附加到缓冲区
给定二进制数1111 1110，我们可以通过先将它们移位4来隔离高阶位，然后将其余的数字归零。从逻辑上讲，这很简单，但是，由于符号扩展，Java（和许多语言）中的实现细节引入了皱纹。实质上，当您移动字节值时，Java首先将您的值转换为整数，然后执行符号扩展。所以，虽然你会期望1111 1110＆gt;＆gt; 4为0000 1111，实际上，在Java中它表示为二进制补码0xFFFFFFFF！
回到我们的例子：
1111 1110 >> 4 (shift right 4) = 1111 1111 1111 1111 1111 1111 1111 1111 (32 bit sign-extended number in two's complement)
然后我们可以用掩码隔离这些位：
1111 1111 1111 1111 1111 1111 1111 1111 & 0xF = 0000 0000 0000 0000 0000 0000 0000 1111
therefore: 1111 = 0xF in hex.
在Java中，我们可以一次完成所有这些：
Character.forDigit((bytes[0] >> 4) & 0xF, 16);
forDigit函数只是将传递给它的数字映射到十六进制数字0-F的集合上。
第3步：接下来我们需要隔离低阶位。由于我们想要的位已经在正确的位置，我们可以掩盖它们：
1111 1110 & 0xF = 0000 0000 0000 0000 0000 0000 0000 1110 (recall sign extension from before)
therefore: 1110 = 0xE in hex.
和以前一样，在Java中我们可以一次性完成这一切：
Character.forDigit((bytes[0] & 0xF), 16);
将所有这些放在一起我们可以将其作为for循环并转换整个数组：
for(int i=0; i < bytes.length; i++){
buffer.append(Character.forDigit((bytes[i] >> 4) & 0xF, 16));
buffer.append(Character.forDigit((bytes[i] & 0xF), 16));
}
希望这个解释能让你清楚地知道你在互联网上找到的许多例子中究竟发生了什么。希望我没有发生任何令人震惊的错误，但建议和更正非常受欢迎！
答案 2 :(得分：21)
我发现这样做的最快方式如下：
private static final String HEXES = "0123456789ABCDEF";
static String getHex(byte[] raw) {
final StringBuilder hex = new StringBuilder(2 * raw.length);
for (final byte b : raw) {
hex.append(HEXES.charAt((b & 0xF0) >> 4)).append(HEXES.charAt((b & 0x0F)));
}
return hex.toString();
}
比String.format快〜50倍。如果你想测试它：
public class MyTest{
private static final String HEXES = "0123456789ABCDEF";
@Test
public void test_get_hex() {
byte[] raw = {
(byte) 0xd0, (byte) 0x0b, (byte) 0x01, (byte) 0x2a, (byte) 0x63,
(byte) 0x78, (byte) 0x01, (byte) 0x2e, (byte) 0xe3, (byte) 0x6c,
(byte) 0xd2, (byte) 0xb0, (byte) 0x78, (byte) 0x51, (byte) 0x73,
(byte) 0x34, (byte) 0xaf, (byte) 0xbb, (byte) 0xa0, (byte) 0x9f,
(byte) 0xc3, (byte) 0xa9, (byte) 0x00, (byte) 0x1e, (byte) 0xd5,
(byte) 0x4b, (byte) 0x89, (byte) 0xa3, (byte) 0x45, (byte) 0x35,
(byte) 0xd6, (byte) 0x10,
};
int N = 77777;
long t;
{
t = System.currentTimeMillis();
for (int i = 0; i < N; i++) {
final StringBuilder hex = new StringBuilder(2 * raw.length);
for (final byte b : raw) {
hex.append(HEXES.charAt((b & 0xF0) >> 4)).append(HEXES.charAt((b & 0x0F)));
}
hex.toString();
}
System.out.println(System.currentTimeMillis() - t); // 50
}
{
t = System.currentTimeMillis();
for (int i = 0; i < N; i++) {
StringBuilder hex = new StringBuilder(2 * raw.length);
for (byte b : raw) {
hex.append(String.format("%02X", b));
}
hex.toString();
}
System.out.println(System.currentTimeMillis() - t); // 2535
}
}
}
编辑：刚刚发现某些内容只有一个小的速度而且只有一行，但不兼容与JRE 9. 使用风险自负
import javax.xml.bind.DatatypeConverter;
DatatypeConverter.printHexBinary(raw);
答案 3 :(得分：15)
尝试这种方式：
byte bv = 10;
String hexString = Integer.toHexString(bv);
处理数组（如果我理解正确的话）：
byte[] bytes = {9, 10, 11, 15, 16};
StringBuffer result = new StringBuffer();
for (byte b : bytes) {
result.append(String.format("%02X ", b));
result.append(" "); // delimiter
}
return result.toString();
正如提到的多基因润滑剂，String.format()是与Integer.toHexString()相比的正确答案（因为它以正确的方式处理负数）。
答案 4 :(得分：13)
答案 5 :(得分：8)
如果您想要一个恒定宽度的十六进制表示，即0A而不是A，以便您可以明确地恢复字节，请尝试format()：
StringBuilder result = new StringBuilder();
for (byte bb : byteArray) {
result.append(String.format("%02X", bb));
}
return result.toString();
答案 6 :(得分：7)
如果您愿意使用外部库，则org.apache.commons.codec.binary.Hex类会使用encodeHex方法，该方法需要byte[]并返回char[]。此方法比format选项快很多，并且封装了转换的详细信息。另外还有decodeHex方法用于相反的转换。
答案 7 :(得分：6)
使用byte[]将BigInteger转换为十六进制字符串的简短方法：
import java.math.BigInteger;
byte[] bytes = new byte[] {(byte)255, 10, 20, 30};
String hex = new BigInteger(1, bytes).toString(16);
System.out.println(hex); // ff0a141e
内置系统类java.math.BigInteger类（java.math.BigInteger）与二进制和十六进制数据兼容：
BigInteger(signum=1, byte[])，可以通过byte[]创建一个大整数（设置其第一个参数signum = 1以正确处理负字节）BigInteger.toString(16)将大整数转换为 hex 字符串new BigInteger("ffa74b", 16)解析十六进制数-无法正确处理前导零如果您可能希望十六进制结果中包含前导零，请检查其大小并在必要时添加缺少的零：
if (hex.length() % 2 == 1)
hex = "0" + hex;
使用new BigInteger(1, bytes)而不是new BigInteger(bytes)，因为Java是“ 被设计破坏”的，并且byte数据类型不包含字节，而是带符号的小整数[-128 ... 127]。如果第一个字节为负，则BigInteger假设您传递了一个负大整数。只需将1作为第一个参数（signum=1）。
将从十六进制转换为byte[] 的过程很棘手：有时在生成的输出中输入前导零，应按以下方式清除它：
byte[] bytes = new BigInteger("ffa74b", 16).toByteArray();
if (bytes[0] == 0) {
byte[] newBytes = new byte[bytes.length - 1];
System.arraycopy(bytes, 1, newBytes, 0, newBytes.length);
bytes = newBytes;
}
最后一个注意事项是，如果byte[]有多个前导零，它们将丢失。
答案 8 :(得分：5)
这是我发现目前运行速度最快的代码。我在2390毫秒的长度为32的109015字节数组上运行它。我在VM上运行它，因此它可能在裸机上运行得更快。
public static final char[] HEX_DIGITS = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
public static char[] encodeHex( final byte[] data ){
final int l = data.length;
final char[] out = new char[l<<1];
for( int i=0,j=0; i<l; i++ ){
out[j++] = HEX_DIGITS[(0xF0 & data[i]) >>> 4];
out[j++] = HEX_DIGITS[0x0F & data[i]];
}
return out;
}
然后你可以做
String s = new String( encodeHex(myByteArray) );
答案 9 :(得分：5)
您可以使用Bouncy Castle Provider库中的方法：
org.bouncycastle.util.encoders.Hex.toHexString(byteArray);
Bouncy Castle Crypto包是Java的一个实现 加密算法。这个jar包含JCE提供者和 用于JDK 1.5到1.5的Bouncy Castle Cryptography API的轻量级API JDK 1.8。
Maven依赖：
<dependency>
<groupId>org.bouncycastle</groupId>
<artifactId>bcprov-jdk15on</artifactId>
<version>1.60</version>
</dependency>
org.apache.commons.codec.binary.Hex.encodeHexString(byteArray);
Apache Commons Codec包中包含简单的编码器和解码器 适用于各种格式，如Base64和Hexadecimal。此外 这些广泛使用的编码器和解码器，编解码器包也 维护一组语音编码实用程序。
Maven依赖：
<dependency>
<groupId>commons-codec</groupId>
<artifactId>commons-codec</artifactId>
<version>1.11</version>
</dependency>
答案 10 :(得分：3)
BigInteger n = new BigInteger(byteArray);
String hexa = n.toString(16));
答案 11 :(得分：2)
这是一个将字节转换为十六进制
的简单函数 private static String convertToHex(byte[] data) {
StringBuffer buf = new StringBuffer();
for (int i = 0; i < data.length; i++) {
int halfbyte = (data[i] >>> 4) & 0x0F;
int two_halfs = 0;
do {
if ((0 <= halfbyte) && (halfbyte <= 9))
buf.append((char) ('0' + halfbyte));
else
buf.append((char) ('a' + (halfbyte - 10)));
halfbyte = data[i] & 0x0F;
} while(two_halfs++ < 1);
}
return buf.toString();
}
答案 12 :(得分：2)
其他人已经涵盖了一般情况。但是如果你有一个已知形式的字节数组，例如MAC地址，那么你可以：
byte[] mac = { (byte)0x00, (byte)0x00, (byte)0x00, (byte)0x00, (byte)0x00 };
String str = String.format("%02X:%02X:%02X:%02X:%02X:%02X",
mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
答案 13 :(得分：1)
如果性能问题，创建（并销毁）一堆String实例并不是一个好方法。
请忽略那些详细（重复）参数检查语句（if s）。这是（另一个）教育目的。
完整的maven项目：http://jinahya.googlecode.com/svn/trunk/com.googlecode.jinahya/hex-codec/
...编码
/**
* Encodes a single nibble.
*
* @param decoded the nibble to encode.
*
* @return the encoded half octet.
*/
protected static int encodeHalf(final int decoded) {
switch (decoded) {
case 0x00:
case 0x01:
case 0x02:
case 0x03:
case 0x04:
case 0x05:
case 0x06:
case 0x07:
case 0x08:
case 0x09:
return decoded + 0x30; // 0x30('0') - 0x39('9')
case 0x0A:
case 0x0B:
case 0x0C:
case 0x0D:
case 0x0E:
case 0x0F:
return decoded + 0x57; // 0x41('a') - 0x46('f')
default:
throw new IllegalArgumentException("illegal half: " + decoded);
}
}
/**
* Encodes a single octet into two nibbles.
*
* @param decoded the octet to encode.
* @param encoded the array to which each encoded nibbles are written.
* @param offset the offset in the array.
*/
protected static void encodeSingle(final int decoded, final byte[] encoded,
final int offset) {
if (encoded == null) {
throw new IllegalArgumentException("null encoded");
}
if (encoded.length < 2) {
// not required
throw new IllegalArgumentException(
"encoded.length(" + encoded.length + ") < 2");
}
if (offset < 0) {
throw new IllegalArgumentException("offset(" + offset + ") < 0");
}
if (offset >= encoded.length - 1) {
throw new IllegalArgumentException(
"offset(" + offset + ") >= encoded.length(" + encoded.length
+ ") - 1");
}
encoded[offset] = (byte) encodeHalf((decoded >> 4) & 0x0F);
encoded[offset + 1] = (byte) encodeHalf(decoded & 0x0F);
}
/**
* Decodes given sequence of octets into a sequence of nibbles.
*
* @param decoded the octets to encode
*
* @return the encoded nibbles.
*/
protected static byte[] encodeMultiple(final byte[] decoded) {
if (decoded == null) {
throw new IllegalArgumentException("null decoded");
}
final byte[] encoded = new byte[decoded.length << 1];
int offset = 0;
for (int i = 0; i < decoded.length; i++) {
encodeSingle(decoded[i], encoded, offset);
offset += 2;
}
return encoded;
}
/**
* Encodes given sequence of octets into a sequence of nibbles.
*
* @param decoded the octets to encode.
*
* @return the encoded nibbles.
*/
public byte[] encode(final byte[] decoded) {
return encodeMultiple(decoded);
}
...解码
/**
* Decodes a single nibble.
*
* @param encoded the nibble to decode.
*
* @return the decoded half octet.
*/
protected static int decodeHalf(final int encoded) {
switch (encoded) {
case 0x30: // '0'
case 0x31: // '1'
case 0x32: // '2'
case 0x33: // '3'
case 0x34: // '4'
case 0x35: // '5'
case 0x36: // '6'
case 0x37: // '7'
case 0x38: // '8'
case 0x39: // '9'
return encoded - 0x30;
case 0x41: // 'A'
case 0x42: // 'B'
case 0x43: // 'C'
case 0x44: // 'D'
case 0x45: // 'E'
case 0x46: // 'F'
return encoded - 0x37;
case 0x61: // 'a'
case 0x62: // 'b'
case 0x63: // 'c'
case 0x64: // 'd'
case 0x65: // 'e'
case 0x66: // 'f'
return encoded - 0x57;
default:
throw new IllegalArgumentException("illegal half: " + encoded);
}
}
/**
* Decodes two nibbles into a single octet.
*
* @param encoded the nibble array.
* @param offset the offset in the array.
*
* @return decoded octet.
*/
protected static int decodeSingle(final byte[] encoded, final int offset) {
if (encoded == null) {
throw new IllegalArgumentException("null encoded");
}
if (encoded.length < 2) {
// not required
throw new IllegalArgumentException(
"encoded.length(" + encoded.length + ") < 2");
}
if (offset < 0) {
throw new IllegalArgumentException("offset(" + offset + ") < 0");
}
if (offset >= encoded.length - 1) {
throw new IllegalArgumentException(
"offset(" + offset + ") >= encoded.length(" + encoded.length
+ ") - 1");
}
return (decodeHalf(encoded[offset]) << 4)
| decodeHalf(encoded[offset + 1]);
}
/**
* Encodes given sequence of nibbles into a sequence of octets.
*
* @param encoded the nibbles to decode.
*
* @return the encoded octets.
*/
protected static byte[] decodeMultiple(final byte[] encoded) {
if (encoded == null) {
throw new IllegalArgumentException("null encoded");
}
if ((encoded.length & 0x01) == 0x01) {
throw new IllegalArgumentException(
"encoded.length(" + encoded.length + ") is not even");
}
final byte[] decoded = new byte[encoded.length >> 1];
int offset = 0;
for (int i = 0; i < decoded.length; i++) {
decoded[i] = (byte) decodeSingle(encoded, offset);
offset += 2;
}
return decoded;
}
/**
* Decodes given sequence of nibbles into a sequence of octets.
*
* @param encoded the nibbles to decode.
*
* @return the decoded octets.
*/
public byte[] decode(final byte[] encoded) {
return decodeMultiple(encoded);
}
答案 14 :(得分：1)
Java 17 附带了一个实用程序，可将字节数组和数字转换为其十六进制对应项。假设我们有一个字节数组形式的“Hello World”的 MD5 摘要：
var md5 = MessageDigest.getInstance("md5");
md5.update("Hello world".getBytes(UTF_8));
var digest = md5.digest();
现在我们可以使用 HexFormat.of().formatHex(byte[]) 方法将给定的 byte[] 转换为其十六进制形式：
jshell> HexFormat.of().formatHex(digest)
$7 ==> "3e25960a79dbc69b674cd4ec67a72c62"
withUpperCase() 方法返回前一个输出的大写版本：
jshell> HexFormat.of().withUpperCase().formatHex(digest)
$8 ==> "3E25960A79DBC69B674CD4EC67A72C62"
答案 15 :(得分：1)
我无法弄清楚字符串究竟是什么意思，但是这里有一些从字节到字符串的转换，反之亦然，当然官方文档还有更多内容
Integer intValue = 149;
相应的字节值为：
Byte byteValue = intValue.byteValue(); // this will convert the rightmost byte of the intValue to byte, because Byte is an 8 bit object and Integer is at least 16 bit, and it will give you a signed number in this case -107
从Byte变量返回整数值：
Integer anInt = byteValue.intValue(); // This will convert the byteValue variable to a signed Integer
从字节和整数到十六进制字符串：
这就是我这样做的方式：
Integer anInt = 149
Byte aByte = anInt.byteValue();
String hexFromInt = "".format("0x%x", anInt); // This will output 0x95
String hexFromByte = "".format("0x%x", aByte); // This will output 0x95
将字节数组转换为十六进制字符串：
据我所知，没有简单的函数将一些Object数组中的所有元素转换为另一个Object的元素，所以你必须自己做。您可以使用以下功能：
从byte []到String：
public static String byteArrayToHexString(byte[] byteArray){
String hexString = "";
for(int i = 0; i < byteArray.length; i++){
String thisByte = "".format("%x", byteArray[i]);
hexString += thisByte;
}
return hexString;
}
从十六进制字符串到字节[]：
public static byte[] hexStringToByteArray(String hexString){
byte[] bytes = new byte[hexString.length() / 2];
for(int i = 0; i < hexString.length(); i += 2){
String sub = hexString.substring(i, i + 2);
Integer intVal = Integer.parseInt(sub, 16);
bytes[i / 2] = intVal.byteValue();
String hex = "".format("0x%x", bytes[i / 2]);
}
return bytes;
}
现在为时已晚，但我希望这可以帮助其他人;）
答案 16 :(得分：1)
如果您喜欢流，这里是格式和连接方法的单表达式版本：
String hex = IntStream.range(0, bytes.length)
.map(i -> bytes[i] & 0xff)
.mapToObj(b -> String.format("%02x", b))
.collect(Collectors.joining());
很遗憾没有像 Arrays::streamUnsignedBytes 这样的方法。
答案 17 :(得分：0)
我看到很多使用 char 数组和/或使用 StringBuilder 实例的答案并声称速度更快。
因为我有一个不同的想法，使用 ASCII 表组织，代码点 48-57 为 0-9，AF 为 65-70，af 为 97-102，所以我想测试哪个想法最快。
由于我已经有很多年没有做过类似的事情了，所以我对此进行了广泛的讨论。我在不同大小的数组（1M、1K、10）中使用了 10 亿个字节，所以每个数组有 1000 次 1M 字节，每个数组有 1M 次 1000 字节和 100M 次每个数组 10 个字节。
结果是 1-F 的字符数组获胜。使用 char 数组作为输出而不是 StringBuilder 也可以胜任（更少的对象，没有容量测试，没有新数组，也没有增长时的复制）。此外，在使用 foreach (for(var b : bytes)) 循环时，您似乎会受到一点惩罚。
使用我的想法的版本大约是。每个阵列 1M 字节慢 15%，每个阵列 1000 字节慢 21%，每个阵列 10 字节慢 18%。 StringBuilder 版本慢了 210%、380% 和 310%。
糟糕但并不意外，因为在一级缓存中查找小数组胜过 if 和 add... 。 （一次缓存访问 + 偏移量计算 vs. 一次如果，一次跳转，一次添加 -> 你不确定跳转）。
我的版本：
public static String bytesToHex(byte [] bytes) {
char [] result = new char [bytes.length * 2];
for(int index = 0; index < bytes.length; index++) {
int v = bytes[index];
int upper = (v >>> 4) & 0xF;
result[index * 2] = (char)(upper + (upper < 10 ? 48 : 65 - 10));
int lower = v & 0xF;
result[index * 2 + 1] = (char)(lower + (lower < 10 ? 48 : 65 - 10));
}
return new String(result);
}
PS：是的，我跑了多次，每次都跑得最好，做了热身，还跑了 100 亿个字符，以确保相同的画面.......
答案 18 :(得分：0)
如果您使用Tink，则有：
OR (JSON_EXTRACT(s.contacts, "$**.email") LIKE :q))';
所以这样的事情应该起作用：
package com.google.crypto.tink.subtle;
public final class Hex {
public static String encode(final byte[] bytes) { ... }
public static byte[] decode(String hex) { ... }
}
答案 19 :(得分：0)
就像其他答案一样，我建议使用String.format()和BigInteger。但是，要将字节数组解释为big-endian binary representation而不是two's-complement binary representation（具有可能存在的十六进制值范围的符号和不完整使用），请使用BigInteger(int signum, byte[] magnitude)，而不是BigInteger(byte[] val)。
例如，对于长度为8的字节数组，请使用：
String.format("%016X", new BigInteger(1,bytes))
优势：
缺点：
示例：
byte[] bytes = new byte[8];
Random r = new Random();
System.out.println("big-endian | two's-complement");
System.out.println("-----------------|-----------------");
for (int i = 0; i < 10; i++) {
r.nextBytes(bytes);
System.out.print(String.format("%016X", new BigInteger(1,bytes)));
System.out.print(" | ");
System.out.print(String.format("%016X", new BigInteger(bytes)));
System.out.println();
}
示例输出：
big-endian | two's-complement
-----------------|-----------------
3971B56BC7C80590 | 3971B56BC7C80590
64D3C133C86CCBDC | 64D3C133C86CCBDC
B232EFD5BC40FA61 | -4DCD102A43BF059F
CD350CC7DF7C9731 | -32CAF338208368CF
82CDC9ECC1BC8EED | -7D3236133E437113
F438C8C34911A7F5 | -BC7373CB6EE580B
5E99738BE6ACE798 | 5E99738BE6ACE798
A565FE5CE43AA8DD | -5A9A01A31BC55723
032EBA783D2E9A9F | 032EBA783D2E9A9F
8FDAA07263217ABA | -70255F8D9CDE8546
答案 20 :(得分：0)
你的快速方法：
private static final String[] hexes = new String[]{
"00","01","02","03","04","05","06","07","08","09","0A","0B","0C","0D","0E","0F",
"10","11","12","13","14","15","16","17","18","19","1A","1B","1C","1D","1E","1F",
"20","21","22","23","24","25","26","27","28","29","2A","2B","2C","2D","2E","2F",
"30","31","32","33","34","35","36","37","38","39","3A","3B","3C","3D","3E","3F",
"40","41","42","43","44","45","46","47","48","49","4A","4B","4C","4D","4E","4F",
"50","51","52","53","54","55","56","57","58","59","5A","5B","5C","5D","5E","5F",
"60","61","62","63","64","65","66","67","68","69","6A","6B","6C","6D","6E","6F",
"70","71","72","73","74","75","76","77","78","79","7A","7B","7C","7D","7E","7F",
"80","81","82","83","84","85","86","87","88","89","8A","8B","8C","8D","8E","8F",
"90","91","92","93","94","95","96","97","98","99","9A","9B","9C","9D","9E","9F",
"A0","A1","A2","A3","A4","A5","A6","A7","A8","A9","AA","AB","AC","AD","AE","AF",
"B0","B1","B2","B3","B4","B5","B6","B7","B8","B9","BA","BB","BC","BD","BE","BF",
"C0","C1","C2","C3","C4","C5","C6","C7","C8","C9","CA","CB","CC","CD","CE","CF",
"D0","D1","D2","D3","D4","D5","D6","D7","D8","D9","DA","DB","DC","DD","DE","DF",
"E0","E1","E2","E3","E4","E5","E6","E7","E8","E9","EA","EB","EC","ED","EE","EF",
"F0","F1","F2","F3","F4","F5","F6","F7","F8","F9","FA","FB","FC","FD","FE","FF"
};
public static String byteToHex(byte b) {
return hexes[b&0xFF];
}
答案 21 :(得分：0)
这是一种非常快捷的方式。无需外部库。
答案 22 :(得分：-2)
使用
Integer.toHexString((int)b);