java Long.reverse反转64位二进制

1. 方法定义

public static long reverse(long i)

2. 功能说明

反转 long 值的 64 位二进制表示
效果：最高位（第63位）与最低位（第0位）交换，次高位（第62位）与次低位（第1位）交换，依此类推
数学本质：二进制位的镜像操作
返回值：反转后的 long 值

3. 示例代码

public class LongReverseExample {
    public static void main(String[] args) {
        // 示例1：反转 1（二进制：63个0 + 1个1）
        long num1 = 1L;
        long reversed1 = Long.reverse(num1);
        System.out.println(Long.toBinaryString(reversed1));
        // 输出：1000000000000000000000000000000000000000000000000000000000000000
        // 说明：1 从最低位移到最高位

        // 示例2：反转 0xFF00（二进制：...1111111100000000）
        long num2 = 0xFF00L;
        long reversed2 = Long.reverse(num2);
        System.out.println(Long.toBinaryString(reversed2));
        // 输出：000000001111111100000000...（共64位）
        // 说明：字节顺序完全反转

        // 示例3：反转特殊值
        System.out.println(Long.reverse(0));      // 0（全0反转后不变）
        System.out.println(Long.reverse(-1));     // -1（全1反转后不变）
    }
}

4. 关键特性

特性	说明
位操作	纯二进制操作，不考虑数值含义
对称值	`0` 和 `-1` 反转后不变
无符号处理	操作基于二进制补码表示
JVM优化	使用高效的底层位操作指令

5. 使用场景

位操作算法

// 计算二进制回文数
boolean isBitPalindrome(long x) {
    return x == Long.reverse(x);
}

数据编码/解码

// 简单编码：位反转加密
long encode(long data) {
    return Long.reverse(data) ^ 0xCAFEBABE;
}

硬件寄存器操作

// 调整字节序（Big-Endian <-> Little-Endian）
long swapEndian(long value) {
    return Long.reverseBytes(value); // 更高效的选择
}

6. 常见错误与解决方案

错误：混淆位反转与字节反转

long value = 0x123456789ABCDEFL;
long wrong = Long.reverse(value); // 位级反转（64位）
long correct = Long.reverseBytes(value); // 字节级反转（8位一组）

解决：

位级反转 → Long.reverse()
字节级反转 → Long.reverseBytes()

错误：忽略符号位影响

long positive = 1L;
long reversed = Long.reverse(positive); 
// 结果：-9223372036854775808（最高位为1的负数）

解决：需要负数结果时使用无符号处理

String binary = Long.toBinaryString(reversed); // 查看二进制表示

错误：误用十进制思维

// 十进制反转 ≠ 二进制反转
Long.reverse(123); // 反转二进制位，不是数字"321"

7. 性能优化

替代算法对比

// 手动反转（低效）
long manualReverse(long i) {
    long result = 0;
    for (int j = 0; j < 64; j++) {
        result <<= 1;
        result |= (i & 1);
        i >>= 1;
    }
    return result;
}

建议：始终使用 Long.reverse()（JVM 内在优化）

热点代码优化

// 预计算反转值（空间换时间）
private static final long[] REVERSE_CACHE = new long[65536];

static {
    for (int i = 0; i < 65536; i++) {
        REVERSE_CACHE[i] = Long.reverse(i) >>> 48;
    }
}

8. 实现原理（伪代码）

public static long reverse(long i) {
    // 分治算法：64位分成32位组->16位组->8位组->4位组->2位组->1位组
    i = (i & 0x5555555555555555L) << 1 | (i >>> 1) & 0x5555555555555555L;
    i = (i & 0x3333333333333333L) << 2 | (i >>> 2) & 0x3333333333333333L;
    i = (i & 0x0F0F0F0F0F0F0F0FL) << 4 | (i >>> 4) & 0x0F0F0F0F0F0F0F0FL;
    i = (i & 0x00FF00FF00FF00FFL) << 8 | (i >>> 8) & 0x00FF00FF00FF00FFL;
    i = (i << 48) | ((i & 0xFFFF0000L) << 16) |
        ((i >>> 16) & 0xFFFF0000L) | (i >>> 48);
    return i;
}

总结

特性	说明
核心功能	反转64位二进制表示
时间复杂度	O(1)（硬件级优化）
使用场景	位操作算法、数据编码、二进制处理
替代方案	字节反转 → `Long.reverseBytes()`
特殊值	`reverse(0)=0`, `reverse(-1)=-1`
注意事项	结果可能与原始数值完全不同

最佳实践：

需要位反转时直接使用 Long.reverse()

检查结果时使用 Long.toBinaryString() 查看二进制

避免手动实现位反转循环（性能差）

区分位反转与字节反转的不同需求