Java中字节数组到有符号整数的转换与优化

public int decodeInt(byte[] input, int length) {
    int value = 0;
    int p = 0;
    int paddingPositions = 4 - length; // 计算需要填充的字节数
    for (int i = 0; i < 4; i++) {
        int shift = (4 - 1 - i) * 8; // 计算当前字节需要左移的位数
        if (paddingPositions-- > 0) {
            // 如果需要填充，则使用0填充高位
            value += (0 & 0x000000FF) << shift;
        } else {
            // 否则，取input数组中的字节，并进行位移
            // & 0x000000FF 确保字节被视为无符号数，防止符号扩展
            value += (input[p] & 0x000000FF) << shift;
            p++;
        }
    }
    return value;
}

import java.nio.ByteBuffer;
import java.nio.ByteOrder; // 可选，用于指定字节序

public class ByteArrayToIntConverter {

    /**
     * 将字节数组的前N个字节转换为有符号整数。
     * 如果字节数组长度不足4，会在高位（左侧）填充0。
     *
     * @param input 待转换的字节数组。
     * @param length 需要转换的字节数，最大为4。
     * @return 转换后的有符号整数。
     */
    public static int decodeInt(byte[] input, int length) {
        // 确保要处理的字节数不超过4，因为int是32位（4字节）
        length = Math.min(4, length);

        // 创建一个长度为4的字节数组作为目标缓冲区
        byte[] destination = new byte[4];

        // 将input数组中的相关字节复制到destination数组中。
        // 复制的起始位置是 destination 的 (4 - length) 处，
        // 这样可以确保当 length 小于 4 时，destination 数组的高位自动填充0。
        // 例如，如果 length = 2，数据会复制到 destination[2] 和 destination[3]，
        // destination[0] 和 destination[1] 保持为0。
        System.arraycopy(input, 0, destination, 4 - length, length);

        // 使用ByteBuffer将4字节数组转换为int。
        // 默认情况下，ByteBuffer使用大端序（Big-Endian）。
        // 如果需要小端序，可以使用 ByteBuffer.order(ByteOrder.LITTLE_ENDIAN)。
        int value = ByteBuffer.wrap(destination).getInt();

        return value;
    }

    // 示例：另一种手动位操作的实现，适用于变长字节数组（大端序）
    public static int parseAsBigEndianByteArray(byte[] bytes) {
        int result = 0;
        int factor = bytes.length - 1; // 初始偏移因子
        for (int i = 0; i < bytes.length; i++) {
            // 将当前字节视为无符号数（& 0xFF），然后左移到正确的位置
            result |= (bytes[i] & 0xFF) << (8 * factor--);
        }
        return result;
    }

    public static void main(String[] args) {
        // 示例1: 完整4字节
        byte[] data1 = {0x01, 0x02, 0x03, 0x04};
        int result1 = decodeInt(data1, 4);
        System.out.println("decodeInt({0x01, 0x02, 0x03, 0x04}, 4) -> " + String.format("0x%08X", result1)); // 0x01020304

        // 示例2: 2字节，高位填充0
        byte[] data2 = {0x01, 0x02};
        int result2 = decodeInt(data2, 2);
        System.out.println("decodeInt({0x01, 0x02}, 2) -> " + String.format("0x%08X", result2)); // 0x00000102

        // 示例3: 超过4字节，只取前4字节
        byte[] data3 = {0x10, 0x20, 0x30, 0x40, 0x50};
        int result3 = decodeInt(data3, 5); // length > 4, 实际只处理前4个
        System.out.println("decodeInt({0x10, 0x20, 0x30, 0x40, 0x50}, 5) -> " + String.format("0x%08X", result3)); // 0x10203040

        // 示例4: 使用手动位操作（大端序）
        byte[] data4 = {0x01, 0x02};
        int result4 = parseAsBigEndianByteArray(data4);
        System.out.println("parseAsBigEndianByteArray({0x01, 0x02}) -> " + String.format("0x%08X", result4)); // 0x0102
    }
}