Java对象比较全解析：从引用相等到定制排序

在Java开发中，对象比较是高频操作，但也是易错点集中地。用错比较方式可能导致逻辑错误、空指针异常，甚至集合框架行为异常。本文系统梳理Java对象比较的核心机制、适用场景、陷阱规避与现代实践，助你构建健壮可靠的比较逻辑。

一、引用比较：`==` 运算符（身份相等）

本质：比较两个引用是否指向同一内存地址（堆中同一对象实例）。

String s1 = new String("Java");
String s2 = new String("Java");
System.out.println(s1 == s2); // false（不同对象）
System.out.println(s1 == s1); // true

// 枚举比较：安全使用==
DayOfWeek today = DayOfWeek.MONDAY;
System.out.println(today == DayOfWeek.MONDAY); // true（枚举是单例）

✅ 适用场景

判断是否为同一实例（如缓存校验）
枚举类型比较（官方推荐）
基本类型包装类在缓存范围内（如 Integer i = 100; i == 100 为true，但不推荐依赖此行为）

❌ 陷阱

字符串字面量 vs new String："a" == new String("a") 为 false
包装类缓存陷阱：Integer a = 128; Integer b = 128; a == b 为 false（超出-128~127缓存范围）

二、内容相等：`equals()` 方法（逻辑相等）

核心：判断两个对象业务逻辑上是否相等。Object.equals() 默认实现为 ==，需按需重写。

String s1 = new String("Java");
String s2 = new String("Java");
System.out.println(s1.equals(s2)); // true（String重写了equals）

重写规范（Effective Java 准则）

必须满足：自反性、对称性、传递性、一致性、非空性
关键原则：重写 equals() 必须同时重写 hashCode()，否则在 HashMap/HashSet 中行为异常。

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false; // 严格类型检查
    User user = (User) o;
    return age == user.age && Objects.equals(name, user.name);
}

@Override
public int hashCode() {
    return Objects.hash(name, age); // Java 7+ 推荐写法
}

⚠️ getClass() vs instanceof 争议

getClass()：保证对称性，适合final类或禁止继承场景
instanceof：支持多态比较，但需谨慎处理子类字段（易破坏对称性）
→ 建议：除非明确需要多态比较，否则优先用 getClass()（Joshua Bloch 推荐）

三、自然排序：`Comparable<T>` 接口

定位：定义对象的内在、默认排序规则（如数字大小、字典序）。

public class Product implements Comparable<Product> {
    private String name;
    private double price;
    
    @Override
    public int compareTo(Product o) {
        // 避免整数溢出：用Integer.compare而非this.age - o.age
        int nameCmp = this.name.compareTo(o.name);
        return (nameCmp != 0) ? nameCmp : Double.compare(this.price, o.price);
    }
}

// 使用
List<Product> products = ...;
Collections.sort(products); // 或 products.sort(null);

✅ 适用场景：对象有明确且唯一的自然顺序（如时间、金额）
⚠️ 注意：compareTo() 返回0时，强烈建议 equals() 也返回true，否则在 TreeSet 中可能产生逻辑矛盾。

四、定制排序：`Comparator<T>` 接口（外部比较器）

定位：提供灵活、可插拔的排序策略，无需修改类源码。

Java 8+ 链式写法（推荐）

// 单条件：按价格升序
Comparator<Product> byPrice = Comparator.comparingDouble(Product::getPrice);

// 多条件：先按类别升序，再按价格降序，空值排最后
Comparator<Product> complex = Comparator
    .comparing(Product::getCategory, Comparator.nullsLast(Comparator.naturalOrder()))
    .thenComparing(Product::getPrice, Comparator.reverseOrder())
    .thenComparing(Product::getName);

products.sort(complex);

✅ 优势

支持运行时动态选择排序规则
处理null安全：nullsFirst() / nullsLast()
与Stream API无缝集成：list.stream().sorted(comparator)...
适合第三方类或需多种排序场景

五、工具类与现代特性

1. `Objects` 工具类（Java 7+）

Objects.equals(a, b);      // 安全比较：处理null（a/b任一为null返回false，全null返回true）
Objects.deepEquals(a, b);  // 深度比较数组（含多维）

2. 数组比较

Arrays.equals(arr1, arr2);      // 一维数组
Arrays.deepEquals(arr1, arr2);  // 多维数组

3. 记录类（Record，Java 14+）

public record Point(int x, int y) {} // 自动生成equals/hashCode/toString
Point p1 = new Point(1, 2);
Point p2 = new Point(1, 2);
System.out.println(p1.equals(p2)); // true（基于组件值比较）

→ 价值：彻底规避手写equals/hashCode的错误，是值对象的理想选择。

4. 第三方库（可选）

Apache Commons Lang：EqualsBuilder.reflectionEquals()（反射比较，适合测试）
Lombok：@EqualsAndHashCode 注解（编译期生成，需谨慎配置）

六、高频陷阱与最佳实践

场景	错误做法	正确做法
字符串比较	`str == "value"`	`"value".equals(str)` 或 `Objects.equals(str, "value")`
空指针防护	`obj.equals(other)`	`Objects.equals(obj, other)` 或常量在前
浮点字段比较	`this.price == other.price`	`Math.abs(this.price - other.price) < 1e-6`（业务定义阈值）
集合使用	仅重写equals未重写hashCode	必须同时重写，确保HashMap/HashSet行为正确
排序null处理	直接调用compareTo	使用 `Comparator.nullsFirst()` 显式声明null策略

📌 黄金法则总结

相等判断：业务相等 → equals() + hashCode()；同一实例 → ==
排序需求：唯一自然序 → Comparable；多策略/外部控制 → Comparator
空安全：优先使用 Objects.equals()
现代开发：值对象优先考虑 record；排序逻辑用Java 8+ Comparator链式API
验证：重写equals/hashCode后，务必编写单元测试覆盖边界情况（null、子类、不同字段组合）

结语

Java的对象比较体系设计精巧：== 守护引用本质，equals/hashCode 定义逻辑相等，Comparable/Comparator 支撑排序生态，工具类与现代特性持续提升开发体验。理解每种机制的设计意图与约束条件，比记忆语法更重要。在实际编码中，结合业务场景选择合适方案，并通过测试验证行为，方能写出清晰、健壮、可维护的代码。

延伸思考：在微服务序列化场景中，对象经JSON往返后==必然失效，此时equals的稳定性至关重要——这也是为何领域模型中重写equals/hashCode是DDD实践的关键一环。