🌟 Java Integer 类详解
java.lang.Integer是 Java 中对基本类型int的包装类（Wrapper Class），属于Number类的子类。它提供了将int值包装成对象的能力，支持在集合（如List<Integer>）、泛型、反射等场景中使用。
一、核心概念
1. 基本信息
- 包路径：
java.lang.Integer - 继承关系：
public final class Integer extends Number implements Comparable<Integer> - 不可变性：
Integer是不可变对象（Immutable），一旦创建，其值不能更改。 - 自动装箱/拆箱：Java 5 引入的特性，支持
int与Integer自动转换。
2. 主要用途
- 在集合中存储整数（如
List<Integer>）。 - 方法参数需要对象类型时。
- 使用泛型。
- 字符串与整数之间的转换。
- 进制转换（二进制、八进制、十六进制）。
- 位运算支持。
3. 静态常量
Integer.MAX_VALUE // 2^31 - 1 = 2147483647
Integer.MIN_VALUE // -2^31 = -2147483648
Integer.SIZE // 32（位）
Integer.BYTES // 4（字节）
二、操作步骤（详细步骤）
✅ 1. 创建 Integer 对象（装箱）
方法一：使用构造函数（已过时，不推荐）
Integer i1 = new Integer(100); // 已废弃，Java 9 起不推荐
Integer i2 = new Integer("123");
方法二：使用静态工厂方法（推荐）
Integer i1 = Integer.valueOf(100); // 推荐！支持缓存
Integer i2 = Integer.valueOf("123"); // 字符串转 Integer
Integer i3 = Integer.valueOf("1010", 2); // 二进制字符串转 Integer
Integer i4 = Integer.valueOf("ff", 16); // 十六进制字符串
⚠️
valueOf()优于构造函数，因为它使用了缓存池（-128 到 127），性能更好。
✅ 2. 自动装箱与拆箱
// 自动装箱：int → Integer
Integer a = 100; // 编译后：Integer.valueOf(100)
// 自动拆箱：Integer → int
int b = a; // 编译后：a.intValue()
// 混合运算自动拆箱
Integer x = 5;
Integer y = 10;
int sum = x + y; // 自动拆箱后相加
✅ 3. 字符串与 Integer 转换
字符串 → Integer / int
// 方法1：返回 int
int num1 = Integer.parseInt("123");
// 方法2：返回 Integer 对象
Integer num2 = Integer.valueOf("123");
// 指定进制
int bin = Integer.parseInt("1010", 2); // 二进制 → 10
int hex = Integer.parseInt("ff", 16); // 十六进制 → 255
Integer → 字符串
Integer i = 123;
String s1 = i.toString();
String s2 = Integer.toString(456);
String s3 = String.valueOf(i);
✅ 4. 进制转换
int num = 255;
// 转为不同进制字符串
String binary = Integer.toBinaryString(num); // "11111111"
String octal = Integer.toOctalString(num); // "377"
String hex = Integer.toHexString(num); // "ff"
// 从字符串解析指定进制
int fromBin = Integer.parseInt("1111", 2); // 15
int fromHex = Integer.parseInt("a1", 16); // 161
✅ 5. 比较 Integer 对象
使用 compareTo()
Integer a = 100;
Integer b = 200;
int result = a.compareTo(b); // 返回 -1, 0, 1
使用 equals()
Integer a = 100;
Integer b = 100;
System.out.println(a.equals(b)); // true（值比较）
// ❌ 错误方式：使用 == 比较对象
System.out.println(a == b); // 可能 false（超出缓存范围时）
✅ 6. 获取 int 值（拆箱）
Integer i = 100;
int value = i.intValue(); // 显式拆箱
✅ 7. 位运算操作（实用技巧）
int n = 8;
// 判断是否为 2 的幂
boolean isPowerOfTwo = (n & (n - 1)) == 0 && n > 0;
// 获取最低位的 1
int lowBit = n & (-n);
// 计算二进制中 1 的个数
int count = Integer.bitCount(n);
// 反转字节顺序
int reversed = Integer.reverseBytes(n);
// 获取最高/最低 1 的位置
int highestOne = Integer.highestOneBit(n); // 如 8 → 8
int lowestOne = Integer.lowestOneBit(n); // 如 12 → 4
三、常见错误与陷阱
❌ 1. 使用 == 比较 Integer 对象
Integer a = 128;
Integer b = 128;
System.out.println(a == b); // false（超出缓存范围）
System.out.println(a.equals(b)); // true
✅ 正确做法：使用
equals()比较值。
❌ 2. null 导致 NullPointerException
Integer num = null;
int value = num; // 抛出 NPE（自动拆箱）
✅ 解决方案：
int value = (num != null) ? num : 0;
// 或使用
int value = Optional.ofNullable(num).orElse(0);
❌ 3. 字符串解析异常
Integer.parseInt("abc"); // 抛出 NumberFormatException
✅ 解决方案：使用 try-catch
try {
int num = Integer.parseInt("abc");
} catch (NumberFormatException e) {
System.err.println("无效数字格式");
}
四、注意事项
- 缓存范围：
Integer.valueOf()缓存了[-128, 127]的实例，超出此范围会创建新对象。 - 不可变性：修改
Integer值会创建新对象，原对象不变。 - 线程安全：
Integer对象本身是线程安全的（不可变）。 - 泛型限制：集合不能存储基本类型，必须用
Integer。 - 性能敏感场景：避免频繁装箱拆箱，尤其在循环中。
五、使用技巧
🔧 1. 判断奇偶性（位运算）
boolean isEven = (n & 1) == 0;
🔧 2. 快速乘除 2 的幂
n << 1; // n * 2
n >> 1; // n / 2（向下取整）
🔧 3. 交换两个整数（不用临时变量）
a ^= b;
b ^= a;
a ^= b;
🔧 4. 使用 Integer.compare() 避免溢出
// 安全比较，避免 (a - b) 溢出
int result = Integer.compare(a, b);
六、最佳实践
- ✅ 优先使用
Integer.valueOf()而非new Integer()。 - ✅ 比较用
equals()，不要用==。 - ✅ 避免在循环中频繁装箱拆箱：
// ❌ 低效 List<Integer> list = new ArrayList<>(); for (int i = 0; i < 10000; i++) { list.add(i); // 每次装箱 } // ✅ 合理（但大数据量考虑用 int[]） - ✅ 处理
null安全拆箱。 - ✅ 字符串转整数使用
parseInt()，并捕获异常。 - ✅ 大量数值计算优先使用
int，避免对象开销。
七、性能优化建议
| 场景 | 建议 |
|---|---|
| 高频数值操作 | 使用 int 而非 Integer |
| 集合存储 | List<Integer> 是标准做法，但大数据考虑 TIntArrayList（来自 Trove） |
| 缓存利用 | 利用 valueOf() 的缓存机制，小整数复用对象 |
| 循环中装箱 | 避免，可先用 int 计算完再装箱 |
| 位运算替代 | 用 <<, >>, & 替代乘除，提升性能 |
八、扩展：Integer 缓存机制源码简析
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
- 缓存范围默认
[-128, 127]，可通过-XX:AutoBoxCacheMax=N调整。 - 适用于频繁使用的小整数，减少对象创建。
九、总结：快速记忆口诀
✅ 装箱用 valueOf，拆箱要防 null
✅ 比较用 equals，别用 == 犯迷糊
✅ 小数有缓存，大数 new 对象
✅ 字符串转 int，parse 要 try-catch
✅ 循环少装箱，性能才靠谱
十、附录：常用方法速查表
| 方法 | 说明 |
|---|---|
Integer.valueOf(int) |
装箱（推荐） |
Integer.parseInt(String) |
字符串转 int |
toString() |
转字符串 |
compareTo(Integer) |
比较大小 |
equals(Object) |
值比较 |
bitCount(int) |
二进制中 1 的个数 |
toBinaryString() |
转二进制字符串 |
compare(int, int) |
安全比较两个 int |
reverseBytes(int) |
字节反转 |