核心概念：字节序

在开始之前，必须理解字节序，计算机内存中多字节数据（如 int）的存储顺序有两种：

1. 大端序

   • 定义：最高有效字节 存储在最低的内存地址。
   • 示例：int 值 0x12345678 在内存中存储为 12 34 56 78。
   • 网络标准：TCP/IP 协议栈中规定使用大端序，因此也常被称为网络字节序。
   • Java 内部表示：Java 的基本数据类型（int, long 等）在内存中就是大端序。

2. 小端序

   • 定义：最低有效字节 存储在最低的内存地址。
   • 示例：int 值 0x12345678 在内存中存储为 78 56 34 12。
   • 常见场景：大多数现代 CPU（如 x86, x64）采用小端序。

将 4 字节的 byte 数组转换为 int

这是最常见的场景，因为一个 int 在 Java 中通常占用 4 个字节。

方法 1：使用 ByteBuffer (推荐)

java.nio.ByteBuffer 是处理字节转换最标准、最灵活的方式,它内部会处理字节序问题。

import java.nio.ByteBuffer;
import java.nio.ByteOrder;
public class ByteArrayToInt {
    public static void main(String[] args) {
        // 示例：将 int 值 0x12345678 转换为大端序的 byte 数组
        byte[] bytesBigEndian = new byte[] {0x12, 0x34, 0x56, 0x78};
        // 示例：将 int 值 0x12345678 转换为小端序的 byte 数组
        byte[] bytesLittleEndian = new byte[] {0x78, 0x56, 0x34, 0x12};
        // --- 使用 ByteBuffer 转换 ---
        // 1. 转换为大端序的 int (默认)
        int intFromBigEndian = ByteBuffer.wrap(bytesBigEndian).getInt();
        System.out.println("大端字节数组 -> int: " + "0x" + Integer.toHexString(intFromBigEndian));
        // 输出: 大端字节数组 -> int: 0x12345678
        // 2. 转换为小端序的 int
        int intFromLittleEndian = ByteBuffer.wrap(bytesLittleEndian).order(ByteOrder.LITTLE_ENDIAN).getInt();
        System.out.println("小端字节数组 -> int: " + "0x" + Integer.toHexString(intFromLittleEndian));
        // 输出: 小端字节数组 -> int: 0x12345678
    }
}

优点：

• 代码清晰,可读性高。
• 可以方便地指定字节序（ByteOrder.BIG_ENDIAN 或 ByteOrder.LITTLE_ENDIAN）。
• 是 Java NIO 的一部分，是处理 I/O 操作的标准方式。

方法 2：使用位移和按位或 (手动实现)

这种方法更底层，不依赖 ByteBuffer,可以让你更好地理解转换过程。

public class ByteArrayToIntManual {
    public static void main(String[] args) {
        // 假设 byte 数组是大端序
        byte[] bytes = new byte[] {0x12, 0x34, 0x56, 0x78};
        // 关键：Java 的 byte 是有符号的（-128 到 127），需要转换为无符号的 int 才能正确位移
        int result = 0;
        for (int i = 0; i < bytes.length; i++) {
            // 将 byte 转换为无符号的 int (0-255)
            // (bytes[i] & 0xFF) 是关键操作
            result |= (bytes[i] & 0xFF) << (8 * (bytes.length - 1 - i));
        }
        System.out.println("手动转换 (大端) -> int: " + "0x" + Integer.toHexString(result));
        // 输出: 手动转换 (大端) -> int: 0x12345678
    }
}

解释：

• bytes[i] & 0xFF：这个操作至关重要。byte 类型在 Java 中是带符号的。0xAB 会被解释为 -85，直接对负数进行位移会得到错误的结果，通过与 0xFF (二进制 11111111) 进行按位与，可以将 byte 提升为 int 并保留其无符号值。
• << (8 * (bytes.length - 1 - i))：这是位移操作，对于大端序，第一个字节是最高有效字节，需要向左位移 24 位（8 * 3），第二个字节位移 16 位,以此类推。

将 1, 2, 或 3 字节的 byte 数组转换为 int

这种情况通常用于解析协议或文件,其中数值的长度是可变的。

方法：位移和按位或 (通用方法)

这种方法同样适用于 4 字节的情况,并且是处理变长数据的标准做法。

public class VariableLengthByteArrayToInt {
    public static void main(String[] args) {
        // --- 1 字节 ---
        byte[] oneByte = {0x7F};
        int intFrom1Byte = (oneByte[0] & 0xFF);
        System.out.println("1 字节 -> int: " + intFrom1Byte); // 输出: 127
        // --- 2 字节 (大端序) ---
        byte[] twoBytes = {0x12, 0x34};
        int intFrom2Bytes = ((twoBytes[0] & 0xFF) << 8) | (twoBytes[1] & 0xFF);
        System.out.println("2 字节 (大端) -> int: " + "0x" + Integer.toHexString(intFrom2Bytes)); // 输出: 0x1234
        // --- 3 字节 (大端序) ---
        byte[] threeBytes = {0x12, 0x34, 0x56};
        int intFrom3Bytes = ((threeBytes[0] & 0xFF) << 16) | ((threeBytes[1] & 0xFF) << 8) | (threeBytes[2] & 0xFF);
        System.out.println("3 字节 (大端) -> int: " + "0x" + Integer.toHexString(intFrom3Bytes)); // 输出: 0x123456
    }
}

注意：对于小端序，只需改变位移的方向即可，2 字节小端序： int intFrom2BytesLE = ((twoBytes[1] & 0xFF) << 8) | (twoBytes[0] & 0xFF);

将超过 4 字节的 byte 数组转换为 int

一个 int 只能存储 4 字节的信息，如果数组更长,你需要决定如何处理多余的字节。

1. 只取前 4 个字节：这是最常见的做法,通常用于校验和或哈希值。
2. 将所有字节合并为一个长整型 long：如果数值可能超过 int 的范围，应该使用 long。

方法 1：只取前 4 个字节

public class LongByteArrayToInt {
    public static void main(String[] args) {
        byte[] longBytes = {0x00, 0x00, 0x00, 0x12, 0x34, 0x56, 0x78, (byte)0xAB};
        // 使用 ByteBuffer 只取前 4 个字节
        int value = ByteBuffer.wrap(longBytes, 0, 4).getInt(); // 从 offset 0 开始，取 4 个字节
        System.out.println("长数组取前4字节 -> int: " + "0x" + Integer.toHexString(value)); // 输出: 0x12345678
    }
}

方法 2：将所有字节合并为 long

public class ByteArrayToLong {
    public static void main(String[] args) {
        byte[] longBytes = {0x00, 0x00, 0x00, 0x12, 0x34, 0x56, 0x78, (byte)0xAB};
        long result = 0;
        for (int i = 0; i < longBytes.length; i++) {
            result |= ((long) (longBytes[i] & 0xFF)) << (8 * (longBytes.length - 1 - i));
        }
        System.out.println("长数组 -> long: " + "0x" + Long.toHexString(result)); // 输出: 0x12345678ab
    }
}

注意：在位移时，需要先将 byte 转换为 long，否则 Java 会将 int 的结果自动提升为 long,高位符号扩展可能会导致错误。

总结与最佳实践

最终建议：

• 首选 ByteBuffer：在绝大多数情况下，ByteBuffer 是最佳选择，它健壮、易读、易维护，并且是 Java 平台处理二进制数据的标准工具。
• 手动方法用于性能关键或特定协议：如果是在对性能要求极高的底层库中，或者需要严格遵循某个协议中不常见的位操作，可以考虑手动位移方法，但对于大多数应用来说，ByteBuffer 的性能已经足够好。