Java案例如何对比两个对象？

wen java案例 2026-06-09 7

Java案例如何对比两个对象？深入解析1+种方法与实践

目录导读

引言：为什么对象对比是Java开发中的高频问题？
基础篇：与 equals() 的本质区别
进阶篇：重写 equals() 与 hashCode() 的黄金法则
工具篇：Apache Commons + Guava 的对比利器
案例实战：如何对比自定义复杂对象（含多层嵌套）
常见陷阱问答（Q&A）
总结与最佳实践

引言：为什么对象对比是Java开发中的高频问题？

在Java开发中，对象对比几乎是所有业务系统的基石——从用户登录校验、数据去重，到缓存键设计、集合操作（如 List.contains()、Map.get()），无不需要准确判断“两个对象是否逻辑相等”，许多开发者仅停留在“用比较基本类型，用 equals() 比较对象”的肤浅理解，导致大量bug：例如用比较两个值相同的 String 时偶然正确，却因字符串池机制而不可靠；或在 HashSet 中存放自定义对象时发现“明明属性相同，却无法去重”。

Java案例如何对比两个对象？

本文将结合真实案例，从底层原理到工业级工具箱，全面覆盖Java对象对比的9种关键方法,并附上可直接运行的代码。

基础篇：与 `equals()` 的本质区别

1 运算符：比较引用地址

对于对象类型，判断的是两个引用是否指向同一块堆内存。

String s1 = new String("hello");
String s2 = new String("hello");
System.out.println(s1 == s2); // false，两个不同对象

2 `equals()` 方法：比较逻辑内容

Object 类的默认 equals() 同样使用，但许多核心类（如 String、Integer）已重写为比较内容：

String s1 = new String("hello");
String s2 = new String("hello");
System.out.println(s1.equals(s2)); // true，比较字符序列

3 典型案例：`Integer` 的缓存陷阱

Integer a = 127;  // 自动装箱，使用缓存
Integer b = 127;
Integer c = 128;
Integer d = 128;
System.out.println(a == b); // true（-128~127 缓存）
System.out.println(c == d); // false（超出缓存范围）

关键结论：任何对象对比都应优先使用 equals()，除非业务明确需要“是否同一实例”。

进阶篇：重写 `equals()` 与 `hashCode()` 的黄金法则

1 何时必须重写？

当你需要将自定义对象放入 HashSet、HashMap 等散列集合时，必须同时重写 equals() 和 hashCode()，否则，两个逻辑相等的对象可能被分配不同哈希桶,导致集合无法去重。

2 重写规范（附代码案例）

假设一个 User 类，通过 id 和 email 判断相同：

public class User {
    private int id;
    private String email;
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return id == user.id && 
               (email != null ? email.equals(user.email) : user.email == null);
    }
    @Override
    public int hashCode() {
        // 使用 Objects.hash 生成基于关键字段的哈希值
        return Objects.hash(id, email);
    }
}

3 常见错误：只用 `id` 或 `name` 做哈希

// 错误：hashCode 只用了 id，但 equals 比较了 id + email
public int hashCode() { return id; } 
// 后果：两个 id 相同但 email 不同的对象哈希值一样，违反“相等对象必须相等哈希”原则

工具篇：Apache Commons + Guava 的对比利器

1 Apache Commons Lang3：`EqualsBuilder`

无需手动写冗长的 equals() 代码,链式调用即可：

import org.jk.common.lang3.builder.EqualsBuilder;
public class Product {
    private String sku;
    private double price;
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Product other = (Product) obj;
        return new EqualsBuilder()
                .append(sku, other.sku)
                .append(price, other.price)
                .isEquals();
    }
}

2 Google Guava：`Objects.equal()` 与 `ComparisonChain`

Objects.equal(a, b)：安全处理 null 值，避免 NullPointerException
ComparisonChain：实现多字段排序对比（类似 Comparator）

import com.google.common.base.Objects;
// 对比两个对象
boolean isSame = Objects.equal(user1.getEmail(), user2.getEmail());

3 Lombok 注解：`@EqualsAndHashCode`

生产环境最简洁的方案：

import lombok.EqualsAndHashCode;
@EqualsAndHashCode(exclude = {"temporaryField"}) // 排除临时字段
public class Employee {
    private int id;
    private String name;
}

案例实战：如何对比自定义复杂对象（含多层嵌套）

场景：对比两个“订单”对象，包含嵌套的“商品列表”和“地址”

此时仅靠 @Data 或手动 equals() 可能不够,因为嵌套集合也要深度对比。

1 方案一：使用 `HashMap` 与递归

// 将复杂对象转为 Map，递归对比所有字段
public static boolean deepCompare(Object a, Object b) {
    if (a == b) return true;
    if (a == null || b == null) return false;
    // 对比基本类型、字符串等
    if (a instanceof Map && b instanceof Map) {
        Map<?,?> mapA = (Map<?,?>) a;
        Map<?,?> mapB = (Map<?,?>) b;
        return mapA.entrySet().stream()
                .allMatch(e -> deepCompare(e.getValue(), mapB.get(e.getKey())));
    }
    // 处理集合
    if (a instanceof Collection && b instanceof Collection) {
        Collection<?> colA = (Collection<?>) a;
        Collection<?> colB = (Collection<?>) b;
        if (colA.size() != colB.size()) return false;
        // 注意：此处需要排序或集合包含判断，否则可能误判
    }
    return a.equals(b);
}

局限：性能较差，且对集合顺序敏感,不适合生产。

2 方案二：使用 JSON 化对比（推荐）

将对象序列化为 JSON 字符串再比较：

import com.fasterxml.jackson.databind.ObjectMapper;
public boolean jsonCompare(Object a, Object b) {
    ObjectMapper mapper = new ObjectMapper();
    // 忽略字段顺序
    JsonNode nodeA = mapper.valueToTree(a);
    JsonNode nodeB = mapper.valueToTree(b);
    return nodeA.equals(nodeB); // Jackson 重写的 equals 会递归对比所有节点
}

优势：天然支持嵌套、集合、null，且可轻松忽略某些字段（通过注解 @JsonIgnore）。

3 方案三：使用 `Comparator` 链与 `Comparator.chain`

Comparator<Order> orderComparator = Comparator
        .comparing(Order::getOrderId)
        .thenComparing(Order::getTotalAmount)
        .thenComparing(o -> o.getItems(), 
                Comparator.comparing(Item::getSku)); // 集合需自定义比较

常见陷阱问答（Q&A）

Q1：为什么用比较两个 Integer 超过 127 会 false？ A：Integer 在 -128~127 范围内使用缓存池，超出范围则创建新对象，比较的是地址，正确做法是用 intValue() 或 equals()。

Q2：equals() 重写后，hashCode() 可以随意返回固定值吗？ A：理论上可以，但会导致所有对象哈希冲突，散列集合性能降到 O(n)，必须按规范：equals() 相等的对象，哈希值必须相等，否则 HashSet 等无法正确去重。

Q3：两个对象属性完全相同，但 equals() 返回 false，可能是什么原因？ A：常见原因：① 未重写 equals()，使用 Object 默认的引用对比；② 某个属性是null，调用equals() 时出现 NPE；③ 使用了不同类加载器加载的相同类（getClass() != o.getClass() 导致）。

Q4：用 @Data 的 equals() 能处理继承吗？ A：不能，Lombok 的 @EqualsAndHashCode 默认只比较当前类的字段，若父类有字段，需加 callSuper=true：@EqualsAndHashCode(callSuper=true)。

Q5：如何对比两个 List 是否元素相同？ A：若元素顺序重要，用 list1.equals(list2)；若顺序不重要，先排序：Collections.sort(listA); listA.equals(listB)，或用 Set 但会消除重复。

总结与最佳实践

场景	推荐方法	注意事项
基本类型包装类	`equals()`	避免使用（缓存陷阱）
自定义简单对象	`@EqualsAndHashCode`	只包含逻辑关键字段
散列集合存储	必须同时重写 `equals()` 和 `hashCode()`	遵守 hashCode 规范
复杂嵌套对象	① Jackson JSON 对比；② `EqualsBuilder` 链	注意集合顺序与 null
性能敏感场景（如循环内）	手动 `equals()` 避免反射	提前做判断以短路