请教各位一个Java里面byte[ ]的一个问题

请教各位一个Java里面byte[ ]的一个问题，就是我现在有一个byte[ ]，比如里面存了一串bytes是EB905B0101E80300，我这里存的是十六进制的一组数字，即EB,90,5B,01,01,E8,03,00共8个十六进制数，然后我将byte[ ]里面的这串数offer给了一个LinkedBlockingQueue，然后我再用take方法从LinkedBlockingQueue中取出这些数，因为我存的是十六进制数字，所以应该是EB,90...这样一个一个的取出来，但是实际情况却是E,B,9,0这样单个单个的给我取出来了，请问一下问题是不是在于我在将这组十六进制数字存进byte[ ]的时候需要让它知道我存的是十六进制，这样后面取出来的时候也就会EB,90...这样的取，不然就会默认为十进制单个单个的取，如果是这样的话请问这个byte[ ]需要怎么转换为十六进制啊？能不能把转换的这几行代码给我说一下，谢谢

纯手写代码，还有疑问可以问我

import java.util.concurrent.LinkedBlockingQueue;

public class A {

    static void printByte(byte b){
        String s = Integer.toHexString(b);
        if(s.length() == 1){
            s = "0" + s;
        }else if(s.length() > 2){
            s = s.substring(s.length() - 2, s.length());
        }
        System.out.print(s);
    }

    static void printBytes(byte[] b){
        for (byte c : b) {
            printByte(c);
            System.out.print(" ");
        }
        System.out.println("");
    }

    public static void main(String[] arg) {

        byte[] bytes = { (byte)0xEB, (byte)0x90, 0x5B, 0x01, 0x01, (byte)0xE8, 0x03, 0x00 };
        printBytes(bytes);

        LinkedBlockingQueue<Byte> queue = new LinkedBlockingQueue<Byte>();
        for( byte b : bytes){
            queue.offer(b);
        }

        while(!queue.isEmpty()){
            Byte b = queue.poll();
            printByte(b);
            System.out.println("");
        }
    } 

}

数组转十六进制字符串
public static String bytesToHex(byte[] bytes) {
    StringBuilder hex = new StringBuilder();
    for (byte b : bytes) {
        hex.append(String.format("%02x", b));
    }
    return hex.toString();
}
使用方法：
byte[] bytes = {0x12, 0x34, 0x56};
String hexString = bytesToHex(bytes);
System.out.println(hexString); // 输出：123456
如果需要将十六进制字符串转换成byte数组，可以使用以下代码实现：
public static byte[] hexToBytes(String hexString) {
    int len = hexString.length();
    byte[] bytes = new byte[len / 2];
    for (int i = 0; i < len; i += 2) {
        bytes[i / 2] = (byte) ((Character.digit(hexString.charAt(i), 16) << 4)
                             + Character.digit(hexString.charAt(i+1), 16));
    }
    return bytes;
}
使用方法：
String hexString = "123456";
byte[] bytes = hexToBytes(hexString);
System.out.println(Arrays.toString(bytes)); // 输出：[18, 52, 86]

是的，您的问题在于在将这16进制数存储到byte数组时没有指定它们是16进制数，所以byte数组中存储的是每个16进制数的ASCII码值。您可以使用Java自带的Hex类将16进制字符串转换为byte数组，例子如下：

import java.nio.charset.StandardCharsets;
import java.util.concurrent.LinkedBlockingQueue;

import javax.xml.bind.DatatypeConverter;

public class Main {
    public static void main(String[] args) throws Exception {
        String hexString = "EB905B0101E80300";
        byte[] bytes = DatatypeConverter.parseHexBinary(hexString);
        LinkedBlockingQueue<Byte> linkedBlockingQueue = new LinkedBlockingQueue<>();
        for (byte b : bytes) {
            linkedBlockingQueue.offer(b);
        }
        Byte result = null;
        while ((result = linkedBlockingQueue.take()) != null) {
            System.out.print(String.format("%02X ", result));
        }
    }
}

通过上面代码，您可以将16进制字符串转换为byte数组，并将其存储到LinkedBlockingQueue中。在从队列中取出元素时，我们可以使用String.format方法将byte类型的数值格式化为十六进制字符串，这样我们就能得到您期望的结果了。

该回答引用ChatGPT
根据描述，问题很可能出现在将byte[]转换为十六进制字符串的过程中。可以使用Java自带的工具类将byte[]转为十六进制字符串，例如：

byte[] bytes = { (byte) 0xEB, (byte) 0x90, (byte) 0x5B, (byte) 0x01, (byte) 0x01, (byte) 0xE8, (byte) 0x03, (byte) 0x00 };
String hexString = DatatypeConverter.printHexBinary(bytes);

这里使用了javax.xml.bind.DatatypeConverter类的printHexBinary方法来将byte[]转换成十六进制字符串，其中（byte）0xEB的写法是将EB这个十六进制数转换成byte类型。

如果需要将十六进制字符串转换为byte[]，可以使用如下代码：

String hexString = "EB905B0101E80300";
byte[] bytes = DatatypeConverter.parseHexBinary(hexString);

这里同样使用了javax.xml.bind.DatatypeConverter类的parseHexBinary方法，将十六进制字符串转换成byte[]。

在Java中，byte数组本身只是一组字节数据，并没有存储数据的进制信息。所以问题不在于byte数组的存储方式，而是在处理byte数组时，需要将其按照十六进制的形式进行解析和显示。

您可以使用以下方法将byte数组转换为十六进制字符串：

public static String bytesToHex(byte[] bytes) {
    StringBuilder sb = new StringBuilder();
    for (byte b : bytes) {
        sb.append(String.format("%02X", b)); // 将每个字节转换为两位十六进制表示
    }
    return sb.toString();
}

然后，在将十六进制字符串存入LinkedBlockingQueue之前，将其转换为byte数组：

```c
String hexString = "EB905B0101E80300"; // 十六进制字符串
byte[] byteArray = new BigInteger(hexString, 16).toByteArray(); // 将十六进制字符串转换为byte数组

这样，您就可以将byte数组存入LinkedBlockingQueue，然后使用take()方法取出时，每次都会得到一个字节的十六进制字符串。

注意，使用BigInteger的构造函数将十六进制字符串转换为byte数组时，前面的0字节可能会被移除。如果您需要保留前导0字节，可以自定义一个方法来进行转换。

以下答案由GPT-3.5大模型与博主波罗歌共同编写：
是的，您的假设是正确的，Java中的byte数组默认被解释为十进制数字，而不是十六进制。

您可以通过使用Java提供的Integer类中的方法将byte数组转换为十六进制字符串。下面是一种将byte数组转换为十六进制字符串的方法：

public static String bytesToHex(byte[] bytes) {
    StringBuilder hexString = new StringBuilder();
    for (int i = 0; i < bytes.length; i++) {
        String hex = Integer.toHexString(0xFF & bytes[i]);
        if (hex.length() == 1) {
            hexString.append('0');
        }
        hexString.append(hex);
    }
    return hexString.toString();
}

使用这个方法：

byte[] bytes = {(byte) 0xEB, (byte) 0x90, (byte) 0x5B, (byte) 0x01, (byte) 0x01, (byte) 0xE8, (byte) 0x03, (byte) 0x00};
String hexString = bytesToHex(bytes);
System.out.println(hexString); // 输出 "eb905b0101e80300"

现在，您可以将生成的十六进制字符串存储在LinkedBlockingQueue中，然后在需要使用它时将其转换回原始字节：

String hexString = queue.take();
byte[] bytes = hexStringToBytes(hexString);

下面是将十六进制字符串转换回原始字节的方法：

public static byte[] hexStringToBytes(String hexString) {
    int len = hexString.length();
    byte[] data = new byte[len / 2];
    for (int i = 0; i < len; i += 2) {
        data[i / 2] = (byte) ((Character.digit(hexString.charAt(i), 16) << 4)
                + Character.digit(hexString.charAt(i+1), 16));
    }
    return data;
}

如果我的回答解决了您的问题，请采纳！

在 Java 中，byte 数组存储的是二进制数据，而不是表示十六进制的字符串。如果你希望将一个十六进制字符串转换为 byte 数组，可以使用 javax.xml.bind.DatatypeConverter 类的 parseHexBinary 方法。以下是一个示例代码：

import javax.xml.bind.DatatypeConverter;

public class Main {
    public static void main(String[] args) {
        String hexString = "EB905B0101E80300";
        byte[] byteArray = DatatypeConverter.parseHexBinary(hexString);

        // 将 byte 数组存入 LinkedBlockingQueue
        LinkedBlockingQueue<byte[]> queue = new LinkedBlockingQueue<>();
        queue.offer(byteArray);

        // 从 LinkedBlockingQueue 中取出 byte 数组
        byte[] retrievedArray = queue.take();

        // 将 byte 数组转换为十六进制字符串
        String retrievedHexString = DatatypeConverter.printHexBinary(retrievedArray);

        System.out.println("Retrieved Hex String: " + retrievedHexString);
    }
}

在上面的代码中，我们首先使用 DatatypeConverter.parseHexBinary 方法将十六进制字符串转换为 byte 数组，并将其存入 LinkedBlockingQueue 中。然后，我们使用 LinkedBlockingQueue.take 方法从队列中取出 byte 数组。

如果你希望将取出的 byte 数组转换回十六进制字符串，可以使用 DatatypeConverter.printHexBinary 方法。

运行上面的代码，你将得到输出结果为 EB905B0101E80300，表示成功将十六进制字符串转换为 byte 数组，并从队列中取出。