自定义LinkedList的Id类equals方法：如何实现按需比较属性

原equals方法存在两个核心问题：一是逻辑不符合需求，只要number或name任一相等就返回true，无法满足多场景的精确匹配；二是健壮性缺失，没有做类型校验和空值处理，容易抛出ClassCastException或NullPointerException。

由于Java中Object.equals()是实例绑定的固定逻辑，无法直接动态切换，推荐以下两种实用方案实现多场景的相等判断：

方案1：使用自定义比较器（Comparator） #

通过实现Comparator<Id>接口，为不同场景定义专属的比较规则，在需要判断相等时调用对应比较器的方法：

定义各类比较器 #

// 仅比较number的比较器
public class IdNumberComparator implements Comparator<Id> {
    @Override
    public int compare(Id o1, Id o2) {
        if (o1 == null || o2 == null) {
            return o1 == o2 ? 0 : -1;
        }
        return o1.getNumber().equalsIgnoreCase(o2.getNumber()) ? 0 : 1;
    }
    
    // 封装相等判断方法
    public boolean equals(Id a, Id b) {
        return compare(a, b) == 0;
    }
}

// 仅比较name的比较器
public class IdNameComparator implements Comparator<Id> {
    @Override
    public int compare(Id o1, Id o2) {
        if (o1 == null || o2 == null) {
            return o1 == o2 ? 0 : -1;
        }
        return o1.getName().equalsIgnoreCase(o2.getName()) ? 0 : 1;
    }
    
    public boolean equals(Id a, Id b) {
        return compare(a, b) == 0;
    }
}

// 先比较name，再比较number（两者都相等才判定相等）
public class IdNameThenNumberComparator implements Comparator<Id> {
    @Override
    public int compare(Id o1, Id o2) {
        if (o1 == null || o2 == null) {
            return o1 == o2 ? 0 : -1;
        }
        int nameCompare = o1.getName().equalsIgnoreCase(o2.getName()) ? 0 : 1;
        if (nameCompare != 0) {
            return nameCompare;
        }
        return o1.getNumber().equalsIgnoreCase(o2.getNumber()) ? 0 : 1;
    }
    
    public boolean equals(Id a, Id b) {
        return compare(a, b) == 0;
    }
}

场景化使用示例 #

Id id1 = new Id("001", "Alice");
Id id2 = new Id("002", "Alice");

// 场景1：仅判断name相等
IdNameComparator nameComparator = new IdNameComparator();
boolean isNameEqual = nameComparator.equals(id1, id2); // 返回true

// 场景2：仅判断number相等
IdNumberComparator numberComparator = new IdNumberComparator();
boolean isNumberEqual = numberComparator.equals(id1, id2); // 返回false

// 场景3：name和number都相等才判定相等
IdNameThenNumberComparator bothComparator = new IdNameThenNumberComparator();
boolean isBothEqual = bothComparator.equals(id1, id2); // 返回false

方案2：让Id类支持注入比较策略（策略模式） #

如果希望在Id实例内部动态切换比较逻辑，可以通过策略模式实现，让类本身具备灵活调整判断规则的能力：

修改Id类，添加策略支持 #

import java.util.Objects;
import java.util.function.BiPredicate;

public class Id {
    private String number;
    private String name;
    // 默认比较策略：先name后number，两者都相等才判定相等
    private BiPredicate<Id, Id> equalsStrategy = (a, b) -> {
        if (a == null || b == null) return a == b;
        return a.name.equalsIgnoreCase(b.name) && a.number.equalsIgnoreCase(b.number);
    };

    public Id() {
        this.number = "";
        this.name = "";
    }

    public Id(String number, String name) {
        this.number = number;
        this.name = name;
    }

    // 省略getter、setter方法...
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public String getNumber() { return number; }
    public void setNumber(String number) { this.number = number; }

    // 允许外部自定义比较策略
    public void setEqualsStrategy(BiPredicate<Id, Id> equalsStrategy) {
        this.equalsStrategy = equalsStrategy;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Id id = (Id) o;
        return equalsStrategy.test(this, id);
    }

    // 注意：equals逻辑变更后，hashCode需保持一致，这里示例为默认策略下的实现
    @Override
    public int hashCode() {
        return Objects.hash(number.toLowerCase(), name.toLowerCase());
    }
}

动态切换策略示例 #

Id id1 = new Id("001", "Alice");
Id id2 = new Id("002", "Alice");

// 场景1：仅比较name
id1.setEqualsStrategy((a, b) -> a.getName().equalsIgnoreCase(b.getName()));
System.out.println(id1.equals(id2)); // true

// 场景2：仅比较number
id1.setEqualsStrategy((a, b) -> a.getNumber().equalsIgnoreCase(b.getNumber()));
System.out.println(id1.equals(id2)); // false

// 场景3：name和number都相等才返回true
id1.setEqualsStrategy((a, b) -> 
    a.getName().equalsIgnoreCase(b.getName()) && a.getNumber().equalsIgnoreCase(b.getNumber())
);
System.out.println(id1.equals(id2)); // false

关键注意事项 #

1. 如果将Id对象放入HashMap、HashSet等哈希集合，必须保证hashCode和equals逻辑严格一致，否则会出现集合存储、查找异常。策略模式下动态切换规则时，不建议使用这类集合。
2. 所有比较逻辑必须处理空值情况，避免空指针异常。
3. 原代码中equals方法存在变量名错误（e应为i），已在方案中修正。

内容的提问来源于stack exchange，提问作者Grenny