直接使用 ‘==’ 比较对象通常是错误的，因为 == 比较的是两个引用是否指向同一内存地址，而非对象内容是否相等；1. 对于基本类型，== 比较值；2. 对于对象类型，== 比较引用地址；3. 要比较内容相等，应重写 equals() 方法；4. 重写 equals() 时必须同时重写 hashcode() 以满足哈希契约；5. 实现排序时，若需自然顺序则实现 comparable 接口；6. 若需多种排序方式或外部排序，则使用 comparator 接口。
在Java里比较两个对象，这事儿说起来简单，做起来却常常让人挠头。核心就一点：你究竟想比较的是它们在内存里是不是同一个东西（引用相等），还是它们在业务逻辑上是不是代表着相同的值（内容相等）。大多数时候，我们关心的都是后者。所以，通常我们会用到
equals()
方法，并且为了集合类的正确性，还需要和
hashCode()
方法配合。如果涉及到排序，那就是
Comparable
或
Comparator
的地盘了。
解决方案
要实现Java对象的比较，关键在于理解并恰当地使用
==
运算符、
equals()
方法、以及
Comparable
和
Comparator
接口。
对于基本数据类型（int, char, boolean等），
==
直接比较它们的值。但对于对象类型，
==
比较的是两个引用是否指向内存中的同一个对象实例。这意味着，即使两个对象的内容完全一样，如果它们是不同的实例，
==
也会返回
false
。
立即学习“Java免费学习笔记（深入）”；
而
equals()
方法，它的默认行为和
==
是一样的，也是比较引用。但
Object
类提供了这个方法，就是为了让我们可以在自定义类中重写它，从而实现“内容相等”的逻辑。当你重写
equals()
时，几乎总是需要同时重写
hashCode()
，以遵守它们之间的契约，确保基于哈希的集合（如
HashMap
,
HashSet
）能正确工作。
当需要对对象进行排序时，Java提供了两种主要的接口：
-
Comparable<T>
：用于定义对象的“自然顺序”。一个类实现这个接口后，它就能够与同类型的其他对象进行比较，比如数字从小到大，字符串按字典序。
-
Comparator<T>
：如果一个类没有自然顺序，或者你需要多种不同的排序方式，就可以使用
Comparator
。它是一个外部的比较器，可以独立于被比较的类存在。
为什么直接使用 ‘==’ 比较对象通常是错误的？
说实话，这问题我个人觉得挺基础的，但又是个常年有人踩的坑。当我们用
==
来比较两个Java对象时，你得明白，它压根儿就不是在看对象肚子里装了啥，它看的是两个引用是不是指着同一个内存地址。简单点说，就是看它们是不是同一个“身份证号”的家伙。
举个例子，你可能有两个
String
对象，它们的内容都是 “hello”。如果你写
String s1 = new String("hello"); String s2 = new String("hello");
，然后
s1 == s2
，结果多半会让你失望——它是
false
。为啥？因为
new String()
每次都会在内存里创建一个全新的字符串对象，即使它们的值一模一样，它们也是两个独立的个体。只有当你写
String s3 = s1;
这种，
s1 == s3
才会是
true
，因为
s3
现在也指向了
s1
指向的那个对象。
public class ObjectComparisonExample { public static void main(String[] args) { // 示例1：基本类型比较 int a = 10; int b = 10; System.out.println("a == b: " + (a == b)); // true // 示例2：字符串对象比较 (new 出来的不同实例) String s1 = new String("hello"); String s2 = new String("hello"); System.out.println("s1 == s2: " + (s1 == s2)); // false // 示例3：字符串字面量比较 (JVM 字符串常量池优化) String s3 = "world"; String s4 = "world"; System.out.println("s3 == s4: " + (s3 == s4)); // true (因为JVM会优化，指向常量池的同一个对象) // 示例4：自定义对象比较 MyObject obj1 = new MyObject(1, "test"); MyObject obj2 = new MyObject(1, "test"); MyObject obj3 = obj1; // obj3 和 obj1 指向同一个对象 System.out.println("obj1 == obj2: " + (obj1 == obj2)); // false (不同实例) System.out.println("obj1 == obj3: " + (obj1 == obj3)); // true (同一个实例) } } class MyObject { int id; String name; public MyObject(int id, String name) { this.id = id; this.name = name; } // 未重写 equals() 和 hashCode() }
所以，当你真正想判断两个对象在业务上是不是“一样”的时候，比如两个
User
对象，只要它们的
id
相同就认为是同一个用户，那
==
就完全帮不上忙了。它只会告诉你它们是不是同一个内存地址上的数据，而这往往不是我们想要的。这就是为什么我们需要
equals()
方法。
如何正确重写 equals() 和 hashCode() 方法？
这俩方法，我感觉是Java里最容易被误解，也最容易出问题的点之一。你重写
equals()
，几乎就得强制重写
hashCode()
，不然等着踩坑吧，尤其是在用
HashMap
或
HashSet
的时候。它们之间有个非常重要的“契约”：如果两个对象
equals()
返回
true
，那么它们的
hashCode()
也必须返回相同的值。反之则不然，
hashCode()
相同，
equals()
不一定为
true
（这就是哈希冲突）。
重写
equals()
方法时，你需要遵循以下几个基本原则（通常称为
equals
契约）：
- 自反性 (Reflexive)：对于任何非空引用值
x
，
x.equals(x)
必须返回
true
。
- 对称性 (Symmetric)：对于任何非空引用值
x
和
y
，当且仅当
y.equals(x)
返回
true
时，
x.equals(y)
才返回
true
。
- 传递性 (Transitive)：对于任何非空引用值
x
、
y
和
z
，如果
x.equals(y)
返回
true
，并且
y.equals(z)
返回
true
，那么
x.equals(z)
也必须返回
true
。
- 一致性 (Consistent)：对于任何非空引用值
x
和
y
，多次调用
x.equals(y)
始终返回
true
或始终返回
false
，前提是对象中用于比较的信息没有被修改。
- 与
null
的比较
：对于任何非空引用值x
，
x.equals(null)
必须返回
false
。
重写
hashCode()
也很关键。一个好的
hashCode()
方法应该尽量让不同的对象产生不同的哈希值，减少冲突。
来，看个代码例子，我们给
MyObject
重写一下：
import java.util.Objects; // Java 7+ 推荐使用 Objects.hash() class MyObjectWithEqualsHashCode { int id; String name; double value; public MyObjectWithEqualsHashCode(int id, String name, double value) { this.id = id; this.name = name; this.value = value; } @Override public boolean equals(Object o) { // 1. 自反性：如果是同一个对象，直接返回true if (this == o) return true; // 2. 与null比较：如果传入null，返回false // 3. 类型检查：如果类型不一致，返回false。这里用 instanceof 比较宽松， // 也可以用 o.getClass() != this.getClass() 严格检查是否是同一类。 // 对于继承关系，getClass() 更严格，instanceof 更宽松。 // 我个人倾向于 instanceof，因为它允许子类和父类对象进行逻辑上的相等比较。 if (!(o instanceof MyObjectWithEqualsHashCode)) return false; // 4. 类型转换 MyObjectWithEqualsHashCode that = (MyObjectWithEqualsHashCode) o; // 5. 逐个比较关键字段 // 基本类型直接比较 if (id != that.id) return false; // double 类型比较需要注意浮点数精度问题，这里简单直接比较，实际可能需要容忍度 if (Double.compare(that.value, value) != 0) return false; // 对象类型（如String）使用其自身的 equals 方法比较 return Objects.equals(name, that.name); // 推荐使用 Objects.equals() 处理null安全 } @Override public int hashCode() { // 推荐使用 Objects.hash()，它能很好地处理多个字段的哈希计算，并且是null安全的。 // 也可以手动计算，但很容易出错。 return Objects.hash(id, name, value); } // 为了方便打印，重写 toString @Override public String toString() { return "MyObjectWithEqualsHashCode{" + "id=" + id + ", name='" + name + ''' + ", value=" + value + '}'; } } public class EqualsHashCodeDemo { public static void main(String[] args) { MyObjectWithEqualsHashCode objA = new MyObjectWithEqualsHashCode(1, "Alice", 10.5); MyObjectWithEqualsHashCode objB = new MyObjectWithEqualsHashCode(1, "Alice", 10.5); MyObjectWithEqualsHashCode objC = new MyObjectWithEqualsHashCode(2, "Bob", 20.0); System.out.println("objA.equals(objB): " + objA.equals(objB)); // true System.out.println("objA.equals(objC): " + objA.equals(objC)); // false System.out.println("objA.equals(null): " + objA.equals(null)); // false System.out.println("objA.hashCode(): " + objA.hashCode()); System.out.println("objB.hashCode(): " + objB.hashCode()); System.out.println("objC.hashCode(): " + objC.hashCode()); // 演示在集合中的行为 java.util.HashSet<MyObjectWithEqualsHashCode> set = new java.util.HashSet<>(); set.add(objA); System.out.println("Set contains objA: " + set.contains(objA)); // true System.out.println("Set contains objB: " + set.contains(objB)); // true (因为equals和hashCode一致) set.add(objC); System.out.println("Set size: " + set.size()); // 2 } }
这里面有几个小细节值得说：
-
instanceof
vs
getClass()
：
instanceof
允许子类对象与父类对象在业务逻辑上相等（如果子类没有重写
equals
）。而
getClass()
严格要求两个对象的运行时类必须完全相同。这取决于你的业务需求。大多数时候，用
instanceof
配合
super.equals()
会更灵活。
- 浮点数比较：
Double.compare()
是比较安全的浮点数比较方式，因为它处理了
NaN
和
Infinity
的情况。但如果你需要考虑精度误差，可能需要自己定义一个小的容忍度（epsilon）。
-
Objects.equals()
和
Objects.hash()
：这是Java 7引入的工具类，强烈推荐使用。它们能帮你处理
null
值，避免
NullPointerException
，并且
Objects.hash()
能自动生成一个相对不错的哈希值。
什么时候应该使用 Comparable 或 Comparator 接口进行对象排序比较？
当你不仅仅是想判断两个对象是不是“一样”，而是想知道它们谁“更大”或谁“更小”时，比如需要对一个列表进行排序，或者把对象放到
TreeSet
、
TreeMap
这种有序集合里，那
Comparable
和
Comparator
就该登场了。
Comparable
：定义对象的“自然顺序”
如果一个类的对象天生就有一种默认的排序方式，比如数字从小到大，字符串按字典序，那么这个类就应该实现
Comparable<T>
接口。它只有一个方法
compareTo(T other)
：
- 返回负整数：表示当前对象小于
other
。
- 返回零：表示当前对象等于
other
。
- 返回正整数：表示当前对象大于
other
。
这就像给对象贴上了一个“默认排序规则”的标签。
class Product implements Comparable<Product> { private String name; private double price; public Product(String name, double price) { this.name = name; this.price = price; } public String getName() { return name; } public double getPrice() { return price; } @Override public int compareTo(Product other) { // 自然排序：按价格从低到高排序 // 如果价格相同，再按名称字母顺序排序 int priceComparison = Double.compare(this.price, other.price); if (priceComparison != 0) { return priceComparison; } return this.name.compareTo(other.name); } @Override public String toString() { return "Product{name='" + name + "', price=" + price + '}'; } } public class ComparableDemo { public static void main(String[] args) { java.util.List<Product> products = new java.util.ArrayList<>(); products.add(new Product("Laptop", 1200.0)); products.add(new Product("Mouse", 25.0)); products.add(new Product("Keyboard", 75.0)); products.add(new Product("Monitor", 1200.0)); // 价格相同，会按名称排序 System.out.println("Original products: " + products); java.util.Collections.sort(products); // 使用Product的自然顺序 System.out.println("Sorted by price (natural order): " + products); java.util.TreeSet<Product> productSet = new java.util.TreeSet<>(); productSet.add(new Product("Tablet", 500.0)); productSet.add(new Product("Phone", 800.0)); productSet.add(new Product("Tablet", 500.0)); // TreeSet会使用compareTo来判断是否重复 System.out.println("TreeSet of products: " + productSet); } }
Comparator
：提供多种排序方式或外部排序
有时候，一个对象可能没有一个明确的“自然顺序”，或者你需要根据不同的业务场景，对同一类对象进行多种不同的排序。这时候，
Comparator<T>
就派上用场了。它是一个独立的类，实现了
compare(T o1, T o2)
方法。这个方法和
compareTo
类似，也是返回负、零或正整数。
你可以创建多个
Comparator
实现，来满足不同的排序需求，而无需修改被排序的类。这在很多场景下都非常灵活。
import java.util.Comparator; // 价格降序比较器 class PriceDescComparator implements Comparator<Product> { @Override public int compare(Product p1, Product p2) { return Double.compare(p2.getPrice(), p1.getPrice()); // 注意p2在前，实现降序 } } // 名称升序比较器 class NameAscComparator implements Comparator<Product> { @Override public int compare(Product p1, Product p2) { return p1.getName().compareTo(p2.getName()); } } public class ComparatorDemo { public static void main(String[] args) { java.util.List<Product> products = new java.util.ArrayList<>(); products.add(new Product("Laptop", 1200.0)); products.add(new Product("Mouse", 25.0)); products.add(new Product("Keyboard", 75.0)); products.add(new Product("Monitor", 1200.0)); System.out.println("Original products: " + products); // 使用价格降序比较器排序 java.util.Collections.sort(products, new PriceDescComparator()); System.out.println("Sorted by price descending: " + products); // 使用名称升序比较器排序 java.util.Collections.sort(products, new NameAscComparator()); System.out.println("Sorted by name ascending: " + products); // Java 8 以后，Comparator 接口提供了很多方便的静态方法，比如 comparing() // 按价格升序排序 products.sort(Comparator.comparing(Product::getPrice)); System.out.println("Sorted by price ascending (Java 8): " + products); // 按价格升序，价格相同则按名称降序 products.sort(Comparator.comparing(Product::getPrice) .thenComparing(Product::getName, Comparator.reverseOrder())); System.out.println("Sorted by price asc, then name desc (Java 8): " + products); } }
总的来说，如果你需要定义一个类自身的默认排序规则，就用
Comparable
；如果你需要灵活的、多种多样的排序规则，或者你无法修改被排序的类，那么
Comparator
就是你的不二之选。Java 8 以后
Comparator
提供了很多链式调用的方法，用起来简直不要太爽，大大简化了代码。
评论（已关闭）
评论已关闭