我发现了三种不同的方法: http://www.rgagnon.com/javadetails/java-0596.html

他还提到，我认为最优雅的一个是:

static final String HEXES = "0123456789ABCDEF";
public static String getHex( byte [] raw ) {
    if ( raw == null ) {
        return null;
    }
    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();
}

最近我必须实现一个十六进制转换器，以十六进制格式将字节流转储到日志中。最初我是用海克斯做的。encodeHex已经在这里讨论过了。

但是如果你想以一种非常美观/可读的方式来表示字节数组，io.netty.buffer库可能是一个很好的用途，因为它打印出十六进制以及其中的字符串，消除了不可打印的字符。

要求是这样的，

0010   56 56 09 35 32 f0 b2 00 50 4c 45 41 53 45 20 52   VV.52...PLEASE R
0020   45 2d 45 4e 54 45 52 20 4c 41 53 54 20 54 52 41   E-ENTER LAST TRA
0030   4e 53 41 43 54 49 4f 4e 00 04                     NSACTION..

使用io.netty.buffer以一种更美观的方式做到这一点的最短方法是

import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufUtil;
import io.netty.buffer.Unpooled;

void hexDump(byte[] buf) {
    ByteBuf byteBuf = Unpooled.wrappedBuffer(buf);
    log.trace("Bytes received (Hex)\n" + ByteBufUtil.prettyHexDump(byteBuf.slice()));
}

如果您正在使用maven，请在pom.xml中包含以下依赖项(在netty页面中检查最新版本)

<dependency>
    <groupId>io.netty</groupId>
    <artifactId>netty-buffer</artifactId>
    <version>4.1.68.Final</version>
</dependency>

输出是:

         +-------------------------------------------------+
         |  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f |
+--------+-------------------------------------------------+----------------+
|00000010| 40 40 b3 f3 80 f3 80 f3 80 f1 48 f1 41 f1 4e f1 |@@........H.A.N.|
|00000020| 47 f1 49 f1 4e f1 47 b5 f1 52 f1 4f f1 43 f1 4b |G.I.N.G..R.O.C.K|
|00000030| f3 80 f3 80 41 b4 40 40 f3 80 f3 80 40 f3 80 04 |....A.@@....@...|
+--------+-------------------------------------------------+----------------+

供您参考，使用答案中讨论的方法的长期方法(可能不是最有效的)是:

public static String hexDump(byte[] buf) throws DecoderException
{
    ByteBuffer byteBuf = ByteBuffer.wrap(buf);
    char[] result = Hex.encodeHex(byteBuf);

    String bin = new String(result).toUpperCase();
    String str = new String(Hex.decodeHex(bin), StandardCharsets.UTF_8);

    str = str.replaceAll("[^!-~]", ".");
    StringBuilder out = new StringBuilder();
    int bytes_per_line = 16;

    for (int pos = 0; pos < str.length(); pos += bytes_per_line) {
        out.append(String.format("%04X   ", pos));
        if (2 * (pos + bytes_per_line) >= bin.length()) {
            out.append(String.format("%-" + 2 * bytes_per_line + "s", bin.substring(2 * pos)).replaceAll("..", "$0 "));
        } else {
            out.append(bin.substring(2 * pos, 2 * (pos + bytes_per_line)).replaceAll("..", "$0 "));
        }
        out.append("   ");
        if (pos + bytes_per_line > str.length()) {
            out.append(str.substring(pos));

        } else {
            out.append(str.substring(pos, pos + bytes_per_line));
        }
        out.append("\n");
    }

    return out.toString();
}

我通常使用以下方法进行debuf语句，但我不知道这是否是最好的方法

private static String digits = "0123456789abcdef";

public static String toHex(byte[] data){
    StringBuffer buf = new StringBuffer();
    for (int i = 0; i != data.length; i++)
    {
        int v = data[i] & 0xff;
        buf.append(digits.charAt(v >> 4));
        buf.append(digits.charAt(v & 0xf));
    }
    return buf.toString();
}

为了完整起见，一个番石榴解决方案:

import com.google.common.io.BaseEncoding;
...
byte[] bytes = "Hello world".getBytes(StandardCharsets.UTF_8);
final String hex = BaseEncoding.base16().lowerCase().encode(bytes);

现在十六进制是“48656c6c6f20776f726c64”。

下面是一些常见的选项，从简单(一行程序)到复杂(庞大的库)。如果您对性能感兴趣，请参阅下面的微基准测试。

选项1:代码片段-简单(仅使用JDK/Android)

选项1a: BigInteger

一个非常简单的解决方案是使用BigInteger的十六进制表示:

new BigInteger(1, someByteArray).toString(16);

注意，因为它处理的数字不是任意字节字符串，它将省略前导零——这可能是也可能不是你想要的(例如，3字节输入的000AE3 vs 0AE3)。这也非常慢，大约比选项2慢100倍。

选项1b: String.format()

使用%X占位符，String.format()能够将大多数基本类型(short, int, long)编码为十六进制:

String.format("%X", ByteBuffer.wrap(eightByteArray).getLong());

选项1c:整数/长(只有4/8字节数组)

如果你只有4个字节的数组，你可以使用Integer类的toHexString方法:

Integer.toHexString(ByteBuffer.wrap(fourByteArray).getInt());

这同样适用于8字节数组和Long

Long.toHexString(ByteBuffer.wrap(eightByteArray).getLong());

选项1d: JDK17+ HexFormat

最后，JDK 17通过HexFormat提供了直接的十六进制编码的一级支持:

HexFormat hex = HexFormat.of();
hex.formatHex(someByteArray)

选项2:代码片段-高级

这是一个完整的功能，复制和粘贴代码片段，支持大写/小写和小写。它经过优化以最小化内存复杂性和最大化性能，并且应该与所有现代Java版本(5+)兼容。

private static final char[] LOOKUP_TABLE_LOWER = new char[]{0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66};
private static final char[] LOOKUP_TABLE_UPPER = new char[]{0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46};
        
public static String encode(byte[] byteArray, boolean upperCase, ByteOrder byteOrder) {

    // our output size will be exactly 2x byte-array length
    final char[] buffer = new char[byteArray.length * 2];

    // choose lower or uppercase lookup table
    final char[] lookup = upperCase ? LOOKUP_TABLE_UPPER : LOOKUP_TABLE_LOWER;

    int index;
    for (int i = 0; i < byteArray.length; i++) {
        // for little endian we count from last to first
        index = (byteOrder == ByteOrder.BIG_ENDIAN) ? i : byteArray.length - i - 1;
        
        // extract the upper 4 bit and look up char (0-A)
        buffer[i << 1] = lookup[(byteArray[index] >> 4) & 0xF];
        // extract the lower 4 bit and look up char (0-A)
        buffer[(i << 1) + 1] = lookup[(byteArray[index] & 0xF)];
    }
    return new String(buffer);
}

public static String encode(byte[] byteArray) {
    return encode(byteArray, false, ByteOrder.BIG_ENDIAN);
}

完整的源代码与Apache v2许可证和解码器可以在这里找到。

选项3:使用一个小型优化库:bytes-java

在从事上一个项目时，我创建了这个用于在Java中使用字节的小工具包。它没有外部依赖关系，并且与Java 7+兼容。它包括，除其他外，一个非常快速和经过良好测试的HEX en/解码器:

import at.favre.lib.bytes.Bytes;
...
Bytes.wrap(someByteArray).encodeHex()

你可以在Github上查看:bytes-java。

选项4:Apache Commons Codec

当然也有好的通用编解码器。(警告意见)当我在上面概述的项目中工作时，我分析了代码，非常失望;大量重复的无组织代码，过时的和外来的编解码器可能只对极少数有用，而且非常过度设计和缓慢的流行编解码器实现(特别是Base64)。因此，如果你想使用它或其他选择，我会做出明智的决定。无论如何，如果你仍然想使用它，这里有一个代码片段:

import org.apache.commons.codec.binary.Hex;
...
Hex.encodeHexString(someByteArray));

选项5:谷歌番石榴

通常情况下，您已经将番石榴作为依赖项。如果是这样，就用:

import com.google.common.io.BaseEncoding;
...
BaseEncoding.base16().lowerCase().encode(someByteArray);

选项6:Spring Security

如果你使用Spring框架和Spring Security，你可以使用以下方法:

import org.springframework.security.crypto.codec.Hex
...
new String(Hex.encode(someByteArray));

选择7:充气城堡

如果你已经使用了安全框架Bouncy Castle，你可以使用它的Hex util:

import org.bouncycastle.util.encoders.Hex;
...
Hex.toHexString(someByteArray);

不是真的选项8:Java 9+兼容性或“不使用jaxb javax/xml/bind/DatatypeConverter”

在以前的Java(8及以下)版本中，JAXB的Java代码是作为运行时依赖项包含的。由于Java 9和Jigsaw模块化，如果没有显式声明，你的代码不能访问模块之外的其他代码。所以要注意，如果你得到一个异常:

java.lang.NoClassDefFoundError: javax/xml/bind/JAXBException

在Java 9+的JVM上运行时。如果是这样，那么将实现切换到上面的任何替代方案。再看看这个问题。

---

微基准测试

下面是对不同大小的字节数组进行编码的简单JMH微基准测试的结果。这些值是每秒操作数，所以越高越好。 请注意，微观基准测试通常并不代表现实世界的行为，所以对这些结果持保留态度。

| Name (ops/s)         |    16 byte |    32 byte |  128 byte | 0.95 MB |
|----------------------|-----------:|-----------:|----------:|--------:|
| Opt1: BigInteger     |  2,088,514 |  1,008,357 |   133,665 |       4 |
| Opt2/3: Bytes Lib    | 20,423,170 | 16,049,841 | 6,685,522 |     825 |
| Opt4: Apache Commons | 17,503,857 | 12,382,018 | 4,319,898 |     529 |
| Opt5: Guava          | 10,177,925 |  6,937,833 | 2,094,658 |     257 |
| Opt6: Spring         | 18,704,986 | 13,643,374 | 4,904,805 |     601 |
| Opt7: BC             |  7,501,666 |  3,674,422 | 1,077,236 |     152 |
| Opt8: JAX-B          | 13,497,736 |  8,312,834 | 2,590,940 |     346 |

规格:JDK 8u202, i7-7700K, Win10, 24GB Ram。点击这里查看完整的基准测试。

基准更新2022

下面是使用当前的JMH 1.35、Java 17和更高端的计算机的结果

| Name (ops/s)         |    16 byte |    32 byte |  128 byte | 0.95 MB |
|----------------------|-----------:|-----------:|----------:|--------:|
| Opt1: BigInteger     |  2,941,403 |  1,389,448 |   242,096 |       5 |
| Opt2/3: Bytes Lib    | 31,724,981 | 22,786,906 | 6,197,028 |     930 |

规格:JDK temurin 17.0.4, Ryzen 5900X, Win11, 24GB DDR4 Ram

如果您正在为python寻找一模一样的字节数组，我已经将这个Java实现转换为python。

class ByteArray:

@classmethod
def char(cls, args=[]):
    cls.hexArray = "0123456789ABCDEF".encode('utf-16')
    j = 0
    length = (cls.hexArray)

    if j < length:
        v = j & 0xFF
        hexChars = [None, None]
        hexChars[j * 2] = str( cls.hexArray) + str(v)
        hexChars[j * 2 + 1] = str(cls.hexArray) + str(v) + str(0x0F)
        # Use if you want...
        #hexChars.pop()

    return str(hexChars)

array = ByteArray()
print array.char(args=[])