✅ Java Integer.equals() 方法详解

核心一句话：Integer.equals(Object obj) 用于判断当前 Integer 对象是否与另一个对象“值相等”，是比较两个 Integer 数值是否相同的正确方式。

一、方法定义

public boolean equals(Object obj)
  • 所属类：java.lang.Integer
  • 重写自：Object.equals()
  • 参数：obj — 要比较的对象（任何 Object）
  • 返回值：
    • true：如果 obj 是 Integer 类型且其封装的 int 值与当前对象相同。
    • false：否则（类型不同、值不同、或 obj 为 null）。
  • 重写规则：遵循 Object.equals() 的通用约定（自反、对称、传递、一致性）。

二、功能说明

功能 说明
值比较 比较的是 Integer 包装的 int 值，而不是对象引用
类型安全 先判断是否为 Integer 类型，不是则返回 false
null 安全 如果传入 null，直接返回 false（不会抛异常）
自动拆箱无关 不涉及装箱/拆箱，是对象间的比较

三、源码解析（JDK 8+）

public boolean equals(Object obj) {
    if (obj instanceof Integer) {
        return value == ((Integer)obj).intValue();
    }
    return false;
}
  • 先用 instanceof 判断是否为 Integer 类型。
  • 如果是，再比较内部 int value 是否相等。
  • 使用 intValue() 获取比较对象的值。

💡 关键点：比较的是值，不是引用。

四、示例代码

✅ 示例 1：基本使用（值相等）

Integer a = 100;
Integer b = 100;
System.out.println(a.equals(b)); // true（值相同）

✅ 示例 2：不同对象但值相同

Integer x = new Integer(200);
Integer y = new Integer(200);
System.out.println(x.equals(y)); // true

✅ 示例 3：与 null 比较

Integer num = 100;
System.out.println(num.equals(null)); // false（安全，不会 NPE）

✅ 示例 4：类型不同

Integer i = 123;
Long l = 123L;
System.out.println(i.equals(l)); // false（类型不同，即使值相同）

⚠️ 注意：Integer 和 Long 虽然值相同，但类型不同，equals 返回 false。

✅ 示例 5：与 int 比较（自动装箱）

Integer num = 100;
int primitive = 100;
System.out.println(num.equals(primitive)); 
// true，因为 primitive 会被自动装箱为 new Integer(100)

五、使用技巧

🔧 技巧 1：用于集合中查找 Integer

List<Integer> list = Arrays.asList(1, 2, 3, 100);
boolean contains = list.contains(100); // 内部调用 equals

🔧 技巧 2：在 Map 中作为 key 的比较

Map<Integer, String> map = new HashMap<>();
map.put(100, "hello");
System.out.println(map.containsKey(100)); // true（调用 equals）

🔧 技巧 3：配合 Optional 安全比较

Optional<Integer> opt = getOptionalInteger();
boolean isExpected = opt.filter(val -> val.equals(42)).isPresent();

🔧 技巧 4：避免 == 的陷阱

Integer a = 128;
Integer b = 128;
System.out.println(a == b);     // false（超出缓存，不同对象）
System.out.println(a.equals(b)); // true（值相同）

六、常见错误 ❌

❌ 错误 1：使用 == 比较 Integer 对象

Integer a = 200;
Integer b = 200;
System.out.println(a == b); // ❌ 可能 false（超出 [-128,127] 缓存）

✅ 正确做法：使用 equals()

System.out.println(a.equals(b)); // ✅ true

❌ 错误 2：误以为 Integer.equals(Long) 会返回 true

Integer i = 100;
Long l = 100L;
System.out.println(i.equals(l)); // false！类型不同

✅ 正确做法：手动比较值

System.out.println(i.longValue() == l.longValue()); // true

❌ 错误 3：在 switch 中使用 Integer（不推荐）

Integer num = 1;
// switch(num) { ... } // ❌ 虽然允许，但不推荐，易出错

✅ 推荐使用 if-else 或 equals。

七、注意事项 ⚠️

注意点 说明
✅ 推荐使用 equals 永远用 equals 比较 Integer 值
⚠️ == 只适用于小整数缓存范围 [-128, 127] 内可能为 true，超出则 false
⚠️ 类型必须是 Integer 与其他数字类型（如 Long, Double）比较返回 false
✅ null 安全 equals(null) 返回 false，不会抛 NullPointerException
⚠️ 性能 极快，但高频调用时仍建议避免冗余比较

八、最佳实践 ✅

1. 永远用 equals() 比较 Integer 值

// ✅ 推荐
if (num1 != null && num1.equals(num2)) { ... }

// 或使用 Objects.equals（自动处理 null）
if (Objects.equals(num1, num2)) { ... }

2. 使用 Objects.equals() 更安全

import java.util.Objects;

Integer a = null;
Integer b = 100;
System.out.println(Objects.equals(a, b)); // false（安全）
System.out.println(Objects.equals(a, null)); // true

✅ Objects.equals(a, b) 等价于：

(a == b) || (a != null && a.equals(b))

3. 避免在 switch 中使用 Integer

// ❌ 不推荐
switch (integerValue) { ... }

// ✅ 推荐
if (integerValue.equals(1)) { ... }
else if (integerValue.equals(2)) { ... }

4. 在集合、泛型、反射中放心使用 equals

Set<Integer> set = new HashSet<>();
set.add(100);
set.contains(100); // 内部调用 equals，安全可靠

九、性能优化建议

场景 建议
单次比较 equals() 性能极高，无需担心
高频比较 缓存比较结果或使用原始 int
大量数据 考虑使用 int[] 而非 Integer[]
null 判断 使用 Objects.equals() 避免显式判空

💡 equals() 内部只是 int 值比较，性能几乎等同于 ==。

十、与 compareTo() 的区别

方法 用途 返回值 适用场景
equals() 判断是否相等 true/false 条件判断、集合查找
compareTo() 比较大小 -1, 0, 1 排序、TreeSet、TreeMap 
Integer a = 100, b = 100;
a.equals(b);     // true
a.compareTo(b);  // 0

十一、总结：快速掌握要点 ✅

项目 内容
核心作用 比较两个 Integer 对象的值是否相等
是否重写 是，重写了 Object.equals()
是否 null 安全 是，equals(null) 返回 false
是否类型安全 是，必须是 Integer 类型
与 == 区别 == 比较引用，equals 比较值
推荐用法 Objects.equals(a, b) 最安全
常见陷阱 误用 ==、误以为 Integer.equals(Long) 为 true
性能 极高，可放心使用

🎯 一句话总结：

Integer.equals() 是比较两个 Integer 值是否相等的正确且安全的方式，永远不要用 ==，优先使用 Objects.equals() 处理可能的 null，即可避免几乎所有陷阱。