只是添加我的两分，因为我看到许多答案使用字符数组和/或使用StringBuilder实例，并声称是快速或更快。

由于我使用ASCII表组织有一个不同的想法，代码点48-57为0-9，代码点65-70为a-f，代码点97-102为a-f，我想测试哪个想法是最快的。

因为我已经好几年没有做过类似的事情了，所以我要做一个广泛的拍摄。我在不同大小的数组中使用了10亿字节(1M, 1K, 10)，因此每个数组有1000倍1M字节，每个数组有1M倍1000字节，每个数组有100M倍10字节。

结果是1-F中的char数组胜出。使用char数组而不是StringBuilder作为输出也很容易(对象更少，不需要测试容量，在增长时不需要新数组或复制)。此外，当使用foreach (for(var b: bytes))循环时，你似乎会得到一个小的惩罚。

使用我的想法的版本大约是。每个数组1M字节时慢15%，每个数组1000字节时慢21%，每个数组10字节时慢18%。StringBuilder版本分别慢了210%、380%和310%。

这很糟糕，但也不是那么出乎意料，因为在第一级缓存中查找小数组胜过if和add... .(一个缓存访问+偏移量计算vs.一个if，一个跳转，一个add ->不确定跳转thou)。

我的版本:

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亿字符的测试，以确保相同的图片... .

我不知道你说的字节字符串到底是什么意思，但这里有一些从字节到字符串的转换，反之亦然，当然官方文档上有更多

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

将字节数组转换为十六进制字符串: 据我所知，没有一个简单的函数可以将某个对象的数组中的所有元素转换为另一个对象的元素，所以你必须自己做。您可以使用以下函数:

从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;
}  

现在已经太迟了，但我希望这能帮助到其他人;)

BigInteger n = new BigInteger(byteArray);
String hexa = n.toString(16);

使用BigInteger将byte[]转换为十六进制字符串的简单方法:

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)将大整数转换为十六进制字符串 要解析十六进制数，请使用new BigInteger("ffa74b"， 16) -不能正确处理前导零

如果你想在十六进制结果中有前导零，检查它的大小，并在必要时添加缺少的零:

if (hex.length() % 2 == 1)
    hex = "0" + hex;

笔记

使用new BigInteger(1, bytes)，而不是new BigInteger(bytes)，因为Java“被设计破坏了”，字节数据类型不包含字节，而是有符号的小整数[-128…127]。如果第一个字节是负的，BigInteger假设您传递了一个负的大整数。只需传递1作为第一个参数(signum=1)。

从十六进制转换回字节[]是棘手的:有时前导零进入产生的输出，它应该像这样被清除:

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;
}

最后一个提示是如果字节[]有几个前导零，它们将丢失。

这是一条非常快的路。不需要外部库。

final protected static char[] HEXARRAY = "0123456789abcdef".toCharArray();

    public static String encodeHexString( byte[] bytes ) {

        char[] hexChars = new char[bytes.length * 2];
        for (int j = 0; j < bytes.length; j++) {
            int v = bytes[j] & 0xFF;
            hexChars[j * 2] = HEXARRAY[v >>> 4];
            hexChars[j * 2 + 1] = HEXARRAY[v & 0x0F];
        }
        return new String(hexChars);
    }

    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语法 %(旗帜)(宽度)转换 标记'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位字节被符号扩展为32位整型。为了有效地撤销这个符号扩展，可以使用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"

这两个因素结合起来应该形成字符串。格式解决方案更佳。

参考文献

整型类型和值 对于字节，从-128到127，包括 JLS 5.1.2扩大原语转换