理解equals()方法与集合操作的深层关联
在java编程中，object类提供的equals()方法用于判断两个对象是否“相等”。然而，当我们在自定义类中重写此方法时，如果不遵循其约定，可能会导致意想不到的行为，尤其是在与java集合框架（如linkedlist、hashset、hashmap等）交互时。
考虑一个纸牌游戏的场景。我们有一个Card类，包含牌面值（rank）和花色（suit）属性。为了实现特定的游戏逻辑，开发者可能尝试重写equals()方法，使其仅基于牌面值来判断两张牌是否相等。例如：
public class Card {
private int cardNum; // 代表牌面值，例如1-13
private String suit; // 代表花色
// 构造函数和其他方法省略...
@Override
public boolean equals(Object obj) {
if (!(obj instanceof Card)){
return false;
} else {
Card card = (Card) obj;
// 仅根据牌面值判断相等
return card.cardNum == this.cardNum;
}
}
@Override
public String toString() {
// 示例：返回 "7 of Clubs"
return cardNum + " of " + suit;
}
}表面上看，这个equals()方法似乎能满足“判断两张牌是否同点数”的需求。然而，当它与LinkedList的remove()方法结合使用时，问题便浮出水面。
假设Dealer类有一个deal()方法，用于从牌堆m_cards中随机抽取并移除一张牌：
public class Dealer {
private LinkedList<Card> m_cards; // 牌堆
// 构造函数用于初始化牌堆...
public Card deal() {
// 每次调用都创建新的Random实例是不推荐的，后续会讨论
Random rand = new Random();
Card randomCard;
// 随机选择一张牌
randomCard = m_cards.get(rand.nextInt(m_cards.size()));
// 从牌堆中移除这张牌
m_cards.remove(randomCard);
return randomCard;
}
}LinkedList.remove(Object o)方法的内部实现会遍历列表，并对列表中的每个元素调用其equals()方法来与传入的参数o进行比较。一旦找到第一个equals()返回true的元素，就会将其移除。
立即学习“Java免费学习笔记（深入）”；
现在，让我们分析当Card类的equals()方法仅比较cardNum时，m_cards.remove(randomCard)会发生什么：
- deal()方法随机选出了一张牌，例如“7 of Clubs”。
- m_cards.remove("7 of Clubs")被调用。
- remove()方法开始遍历m_cards列表。
- 如果列表中先遇到“7 of Hearts”，由于“7 of Hearts”的cardNum与“7 of Clubs”的cardNum相同，equals()方法会返回true。
- 结果，remove()方法会错误地移除“7 of Hearts”，而不是实际被选中的“7 of Clubs”。
- 这导致牌堆中剩余的牌出现混乱，玩家可能抽到重复的牌（因为被选中的“7 of Clubs”没有被移除），或者牌堆中缺少了不该缺少的牌（因为“7 of Hearts”被错误移除）。
这就是为什么即使没有直接使用.equals()进行比较，仅仅是equals()方法的“存在”和其不正确的实现，就可能“搞砸”其他依赖于对象相等性判断的代码。
深入解析：equals()方法的正确实现
为了避免上述问题，我们必须严格遵循equals()方法的设计约定。对于Card类，两张牌真正“相等”的定义应该是它们具有相同的牌面值（rank）和相同的花色（suit）。
以下是Card类equals()方法的正确实现范例：
import java.util.Objects; // 引入Objects工具类，简化null检查和比较
public class Card {
private int cardNum; // 代表牌面值
private String suit; // 代表花色
public Card(int cardNum, String suit) {
this.cardNum = cardNum;
this.suit = suit;
}
// Getter方法省略...
@Override
public boolean equals(Object obj) {
// 1. 自反性：对象必须等于其自身
if (this == obj) {
return true;
}
// 2. 非空性：null不等于任何非null对象
if (obj == null) {
return false;
}
// 3. 类型一致性：比较对象必须是相同类型或兼容类型
// 如果期望子类和父类对象可以相等，可以使用 instanceof
// 如果只允许相同具体类的对象相等，使用 getClass() != obj.getClass()
if (getClass() != obj.getClass()) { // 推荐使用 getClass() 进行严格类型检查
return false;
}
// 4. 转换类型并比较所有关键字段
Card other = (Card) obj;
// 使用Objects.equals()处理可能为null的字段（如String）
return this.cardNum == other.cardNum &&
Objects.equals(this.suit, other.suit);
}
@Override
public String toString() {
return cardNum + " of " + suit;
}
}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，只要equals比较中所用的信息没有被修改，多次调用x.equals(y)始终返回相同的结果。
- 非空性 (Non-null): 对于任何非空引用值x，x.equals(null)必须返回false。
上述示例遵循了这些约定，确保了Card对象的相等性判断是逻辑上完整且一致的。
配套实现：hashCode()的重要性
当重写equals()方法时，必须同时重写hashCode()方法。这是Java中Object类的一个核心契约：
如果两个对象根据equals(Object)方法是相等的，那么调用这两个对象中任意一个的hashCode方法都必须产生相同的整数结果。
违反这一契约会导致使用基于散列的集合（如HashSet、HashMap）时出现严重问题，例如，相等的对象无法被正确地存储或检索。
对于Card类，其hashCode()方法应根据cardNum和suit这两个字段生成散列码：
import java.util.Objects;
public class Card {
// ... 其他代码 ...
@Override
public boolean equals(Object obj) {
// ... 正确的equals实现 ...
}
@Override
public int hashCode() {
// 使用Objects.hash()可以方便地组合多个字段的哈希码
return Objects.hash(cardNum, suit);
}
}Objects.hash()方法是一个非常实用的工具，它能够为多个字段生成一个高质量的哈希码，同时处理可能为null的字段。
优化实践：Random实例的管理
除了equals()和hashCode()的问题，原始代码中deal()方法的一个小但重要的优化点是Random实例的创建。
public Card deal() {
Random rand = new Random(); // 每次调用都创建新的Random实例
// ...
}在短时间内频繁创建Random的新实例（尤其是在默认构造函数下，它使用当前时间作为种子），可能导致生成的随机数序列不够随机，甚至在极短的时间内生成相同的序列。
最佳实践是重用Random实例，将其声明为类的成员变量，并在构造函数中初始化一次：
import java.util.LinkedList;
import java.util.Random;
import java.util.Objects; // 用于Card类的equals/hashCode
public class Dealer {
private LinkedList<Card> m_cards;
// 声明一个静态的或实例级的Random对象，只创建一次
private static final Random RAND = new Random();
public Dealer() {
m_cards = new LinkedList<>();
// 初始化牌堆，例如：
String[] suits = {"Hearts", "Diamonds", "Clubs", "Spades"};
for (String suit : suits) {
for (int i = 2; i <= 14; i++) { // 2-10, Jack(11), Queen(12), King(13), Ace(14)
m_cards.add(new Card(i, suit));
}
}
// 洗牌操作...
}
public Card deal() {
if (m_cards.isEmpty()) {
throw new IllegalStateException("Deck is empty!");
}
int randomIndex = RAND.nextInt(m_cards.size()); // 使用重用的RAND实例
Card randomCard = m_cards.get(randomIndex);
m_cards.remove(randomIndex); // 直接通过索引移除更高效，且避免equals问题
return randomCard;
}
// deals方法可以保持不变，因为它调用了deal()
public LinkedList<Card> deals(int n) {
LinkedList<Card> cardsDealt = new LinkedList<>();
for (int i = 0; i < n; i++) {
cardsDealt.add(deal());
}
return cardsDealt;
}
@Override
public String toString() {
return "\nYour dealer has a deck of " + m_cards.size() + " cards: \n\nCards currently in deck: " + m_cards;
}
}注意： 在deal()方法中，如果已经通过m_cards.get(randomIndex)获取了要移除的Card对象，并且我们知道它的索引，那么直接使用m_cards.remove(randomIndex)来移除元素会更高效，并且能完全避免equals()方法带来的潜在问题（尽管在equals()实现正确后，remove(Object)也能正常工作）。
总结与建议
本教程通过一个具体的纸牌游戏案例，深入探讨了Java中equals()方法重写的重要性及其对集合操作的影响。核心要点包括：
- equals()方法契约： 严格遵循equals()方法的五个约定（自反性、对称性、传递性、一致性、非空性）是编写健壮代码的基础。对于自定义类，其相等性应基于所有能够唯一标识该对象的关键属性。
- hashCode()的配套重写： 任何时候重写equals()方法，都必须同时重写hashCode()方法，以维护Java对象契约，确保基于散列的集合能正常工作。
- 集合操作的依赖： LinkedList.remove(Object)、HashSet.contains(Object)等集合方法在内部依赖于equals()方法来判断对象相等性。不正确的equals()实现会导致这些方法行为异常，例如移除错误的元素或无法正确查找元素。
- Random实例的重用： 避免在循环或频繁调用的方法中重复创建Random实例，应将其声明为类的成员变量并重用，以保证更好的随机性。
通过理解和实践这些原则，开发者可以避免常见的逻辑错误，编写出更可靠、更易于维护的Java应用程序。在设计自定义类时，始终仔细思考其对象的“相等”定义，并据此正确实现equals()和hashCode()方法。
