java Integer.reverse反转整数的二进制位顺序

Integer.reverse() 是 Java 中用于反转整数的二进制位顺序的静态方法。它将一个 int 类型数值的 32 位二进制表示从最低位到最高位完全颠倒，生成一个新的整数值。

---

一、方法定义

public static int reverse(int i)

• 所属类：java.lang.Integer
• 访问修饰符：public static
• 参数：int i —— 要反转位序的整数（支持负数）
• 返回值：反转所有 32 位后的 int 值
• 异常：无异常抛出

✅ 该方法操作的是整数的原始位模式，包括符号位，因此结果可能为负数。

---

二、功能说明

将一个 int 值的 32 位二进制表示完全反转，即：

• 第 0 位 ↔ 第 31 位
• 第 1 位 ↔ 第 30 位
• ...
• 第 15 位 ↔ 第 16 位

📌 关键点：

• 操作基于 32 位补码表示
• 包括符号位在内的所有位都被反转
• 返回值仍为 int 类型，可能为负数

---

三、示例代码

示例 1：基本用法（小正数）

int num = 1; // 二进制: 00000000 00000000 00000000 00000001
int reversed = Integer.reverse(num);
// 反转后: 10000000 00000000 00000000 00000000 → 这是 -2147483648
System.out.println(reversed); // 输出：-2147483648

示例 2：数值 8（1000）

int num = 8; // 二进制末尾: ...00001000
int rev = Integer.reverse(num);
// 反转后高位变成: 0001000... → 实际是 268435456
System.out.println(rev); // 输出：268435456

示例 3：全 1 情况（-1）

int num = -1; // 二进制: 11111111 11111111 11111111 11111111
int rev = Integer.reverse(num);
System.out.println(rev); // 输出：-1
// 因为全 1 反转后还是全 1

示例 4：0 的反转

int num = 0;
int rev = Integer.reverse(num);
System.out.println(rev); // 输出：0

示例 5：手动验证（简化版）

// 演示 4 位反转逻辑（非真实 32 位）
int small = 0b0011; // 3
// 若有 reverse4bit，则结果为 0b1100 = 12

// Java 中实际是 32 位反转
int full = 3; // 末尾 00000011
int result = Integer.reverse(full);
System.out.println(result); // 输出：3221225472
// 即 0b11000000 00000000 00000000 00000000

---

四、使用技巧

1. 位反转用于 FFT 或编码算法

在快速傅里叶变换（FFT）中，输入序列常需按位反转排列（Bit-reversed order）。

// 生成位反转索引（示例前 8 个）
for (int i = 0; i < 8; i++) {
    int rev = Integer.reverse(i) >>> 29; // 取高 3 位（因 32-3=29）
    System.out.printf("%d -> %d%n", i, rev);
}
// 输出：
// 0 -> 0 (000 -> 000)
// 1 -> 4 (001 -> 100)
// 2 -> 2 (010 -> 010)
// 3 -> 6 (011 -> 110)
// 4 -> 1 (100 -> 001)
// 5 -> 5 (101 -> 101)
// 6 -> 3 (110 -> 011)
// 7 -> 7 (111 -> 111)

2. 结合 Integer.reverseBytes() 区分

int num = 0x12345678;

System.out.printf("原始: %08X%n", num);                    // 12345678
System.out.printf("位反转: %08X%n", Integer.reverse(num)); // 1E6A2C48
System.out.printf("字节反转: %08X%n", Integer.reverseBytes(num)); // 78563412

• reverse()：逐位反转
• reverseBytes()：逐字节反转（字节序转换）

---

五、常见错误与注意事项

问题	说明	建议
误解结果符号	认为正数反转后仍为正，实际可能为负	理解符号位也被反转
期望局部反转	以为只反转有效位，实际是 32 位全反转	如需局部反转需手动实现
性能误解	认为很慢，实际高度优化	可用于高频场景

示例：为什么 reverse(1) 是负数？

1 的二进制: 00000000 00000000 00000000 00000001
反转后:     10000000 00000000 00000000 00000000 → 最高位为 1 → 负数（-2^31）

---

六、底层实现原理（简化版）

Integer.reverse() 使用 分治法 + 位并行运算，避免逐位操作，性能极高。

简化逻辑如下：

public static int reverse(int i) {
    // 交换每对相邻位
    i = ((i & 0x55555555) << 1) | ((i >>> 1) & 0x55555555);
    // 交换每对 2 位组
    i = ((i & 0x33333333) << 2) | ((i >>> 2) & 0x33333333);
    // 交换每对 4 位组（字节内）
    i = ((i & 0x0f0f0f0f) << 4) | ((i >>> 4) & 0x0f0f0f0f);
    // 交换字节对
    i = (i << 24) | ((i & 0xff00) << 8) | ((i >>> 8) & 0xff00) | (i >>> 24);
    return i;
}

✅ 时间复杂度：O(1)，固定步数完成

---

七、与其他方法对比

方法	功能	示例输入 → 输出
Integer.reverse(i)	32 位逐位反转	1 → -2147483648
Integer.reverseBytes(i)	4 字节顺序反转	0x12345678 → 0x78563412
Integer.rotateLeft(i, n)	循环左移 n 位	1 << 31, 1 → 1
手动循环	逐位构建反转	性能差，不推荐

---

八、最佳实践

✅ 推荐做法

1. 用于算法竞赛或底层编码

   • FFT 输入重排
   • 格雷码生成
   • 哈希函数设计

2. 性能敏感场景

   • JVM 已优化，可放心使用

3. 与 bitCount、numberOfLeadingZeros 配合使用

   int rev = Integer.reverse(n);
   int leadingZeros = Integer.numberOfLeadingZeros(rev);
   

4. 避免对结果做“直观”解读

   • 位反转结果通常不具直观算术意义，用于特定算法逻辑

---

九、性能分析

• 时间复杂度：O(1)，固定 5 步位运算
• JVM 优化：可能映射到 CPU 指令（如 ARM 的 RBIT）
• 性能极高：远快于任何循环实现

✅ 在 JDK 源码中用于某些随机数生成和哈希算法。

---

十、总结

项目	内容
核心功能	将 int 的 32 位二进制完全反转
支持负数	✅ 基于补码位模式操作
返回值	int，可能为负数
典型用途	FFT、编码算法、位操作优化
性能	⭐⭐⭐⭐⭐ 极高，推荐首选
最佳实践	用于特定算法场景，理解其位级语义
常见误区	期望结果保持正数或算术意义

💡 一句话总结：
Integer.reverse() 是 Java 中高效反转整数所有 32 位的工具方法，基于位并行算法实现，适用于需要位级反转的高级算法场景，理解其对符号位的影响是正确使用的关键。