如何高效移除字节数组各字节前导零并生成新数组？

当然有！用字符串处理确实在大数组场景下效率拉胯——毕竟字符串拼接要反复创建对象、拷贝内存，完全没必要。直接用位运算+缓冲区的方式，全程在二进制层面操作，速度能提升一大截，而且逻辑也清晰。

核心思路 #

我们要做的就是把每个字节的有效位（去掉前导零后的部分）按顺序拼接成新的字节，全程用整数缓冲区暂存未凑够8位的有效位，具体步骤：

1. 预计算总有效位数：提前算出所有字节的有效位总和，直接分配好输出数组的内存，避免动态扩容的开销。
2. 遍历处理每个字节：
   • 把字节转成无符号整数（避免Java中byte的符号位干扰）。
   • 快速计算该字节的前导零数量，得到有效位长度。
   • 提取出该字节的有效位数值。
   • 将有效位合并到缓冲区，当缓冲区的位数≥8时，取出完整的8位作为新字节存入结果数组，剩下的位留在缓冲区继续拼接。
3. 处理剩余位：遍历结束后，如果缓冲区还有不足8位的剩余位，左移补零凑成完整字节存入结果。

代码实现（Java） #

public static byte[] compactBytes(byte[] input) {
    if (input == null || input.length == 0) {
        return new byte[0];
    }

    // 第一步：计算总有效位数，确定输出数组长度
    int totalEffectiveBits = 0;
    for (byte b : input) {
        int unsignedByte = b & 0xFF;
        if (unsignedByte == 0) {
            continue; // 全零字节无有效位，跳过
        }
        // 计算8位中的前导零数量：Integer.numberOfLeadingZeros返回32位中的前导零，减去24得到低8位的前导零
        int leadingZeros = Integer.numberOfLeadingZeros(unsignedByte) - 24;
        totalEffectiveBits += 8 - leadingZeros;
    }

    if (totalEffectiveBits == 0) {
        return new byte[0];
    }

    int outputLength = (totalEffectiveBits + 7) / 8; // 向上取整计算字节数
    byte[] output = new byte[outputLength];
    int buffer = 0; // 用int作为缓冲区，最多存32位，足够暂存多个字节的有效位
    int bufferBitCount = 0;
    int outputIndex = 0;

    // 第二步：遍历处理每个字节
    for (byte b : input) {
        int unsignedByte = b & 0xFF;
        if (unsignedByte == 0) {
            continue;
        }

        int leadingZeros = Integer.numberOfLeadingZeros(unsignedByte) - 24;
        int effectiveBitLength = 8 - leadingZeros;
        int effectiveValue = unsignedByte & ((1 << effectiveBitLength) - 1); // 提取有效位数值

        // 将有效位合并到缓冲区
        buffer = (buffer << effectiveBitLength) | effectiveValue;
        bufferBitCount += effectiveBitLength;

        // 当缓冲区有足够的位时，取出完整字节
        while (bufferBitCount >= 8) {
            bufferBitCount -= 8;
            // 取出缓冲区中最高的8位
            byte newByte = (byte) ((buffer >>> bufferBitCount) & 0xFF);
            output[outputIndex++] = newByte;
            // 保留缓冲区中剩余的低位
            buffer = buffer & ((1 << bufferBitCount) - 1);
        }
    }

    // 第三步：处理剩余的不足8位的有效位
    if (bufferBitCount > 0) {
        // 左移补零凑成8位字节
        byte remainingByte = (byte) (buffer << (8 - bufferBitCount));
        output[outputIndex] = remainingByte;
    }

    return output;
}

为什么这个方法更快？ #

• 无字符串操作：全程没有字符串的创建、拼接、切割，避免了大量的内存分配和拷贝开销——这是大数组场景下性能差异的核心原因。
• 位运算高效：所有操作都是CPU原生支持的位运算（移位、按位或、按位与），执行速度极快，几乎没有额外开销。
• 内存预分配：提前计算输出数组长度，一次性分配内存，避免了动态扩容（比如ArrayList的扩容逻辑）带来的性能损耗。

验证你的示例 #

输入数组{0xF, 0xF, 0x11, 0x4}：

1. 第一个字节0xF（00001111）：有效位4位（1111），存入缓冲区。
2. 第二个字节0xF（00001111）：有效位4位（1111），和缓冲区拼接成8位（11111111），输出0xFF。
3. 第三个字节0x11（00010001）：有效位5位（10001），存入缓冲区。
4. 第四个字节0x4（00000100）：有效位3位（100），和缓冲区拼接成8位（10001100），输出0x8C。
   最终得到的数组就是{0xFF, 0x8C}，完全符合预期。

内容的提问来源于stack exchange，提问作者Dave Henry