Never ignore Equals/hashCode contract

name、email、number、gstNumber

这些属性中的任何一个都可能导致重复，这意味着or

你对重复的implies的定义，这些属性中的任何一个都应该匹配，而其他属性可能是not.

这意味着不可能提供与给定定义匹配且不违反hashCode contract的实现equals/hashCode.

如果根据equals方法，两个对象相等，则在这两个对象的每个对象上调用hashCode方法必须产生same integer result.

I.e. if you implement equals in such a way they any (not all) of these properties: name、email、number、gstNumber could match, and that would enough to consider the two objects equal, then there's no way to implement hashCode correctly.

因此，您不能在基于散列的集合中使用带有损坏的equals/hashCode实现的对象，因为相同的对象可能会出现在不同的存储桶中(因为它们可能会产生不同的散列).即HashMap将不能识别复制的密钥，因此具有groupingBy()和Function.identity()作为classifier功能的groupingBy将不能正常工作.

Therefore, to address this problem, you need to implement equals() based on all 4 properties: name、email、number、gstNumber (i.e. all these values have to be equal), and similarly all these values must contribute to hash-code.

How to determine Duplicates

没有简单的方法来通过多个标准来确定重复项.你们提供的解决方案not是可行的，因为我们不能依赖equals/hashCode.

唯一的方法是 for each End每个属性分别生成HashMap(即，在本例中我们需要4个贴图).但我们能不能另辟蹊径，避免对每个 map 重复相同的步骤，并对逻辑进行硬编码？

是的，我们可以.

我们可以创建一个定制的泛型累加类型(它适用于任何类--没有硬编码逻辑)，它将封装确定重复项的所有逻辑，并在幕后维护任意数量的映射.在使用给定集合中的所有元素后，此自定义对象将知道其中的所有重复项.

这就是它可以被实施的方式.

将用作定制Collector的容器的定制累计类型.它的构造函数要求varargs为functions，每个函数对应于在判断对象是否重复时应考虑的属性.

public static class DuplicateChecker<T> implements Consumer<T> {
    
    private List<DuplicateHandler<T>> handles;
    private Set<T> duplicates;

    @SafeVarargs
    public DuplicateChecker(Function<T, ?>... keyExtractors) {
        this.handles = Arrays.stream(keyExtractors)
            .map(DuplicateHandler::new)
            .toList();
    }

    @Override
    public void accept(T t) {
        handles.forEach(h -> h.accept(t));
    }
    
    public DuplicateChecker<T> merge(DuplicateChecker<T> other) {
        for (DuplicateHandler<T> handler: handles) {
            other.handles.forEach(handler::merge);
        }
        
        return this;
    }

    public DuplicateChecker<T> finish() {
        duplicates = handles.stream()
            .flatMap(handler -> handler.getDuplicates().stream())
            .flatMap(Set::stream)
            .collect(Collectors.toSet());
        
        return this;
    }
    
    public boolean isDuplicate(T t) {
        return duplicates.contains(t);
    }
}

一个帮助器类，表示封装HashMap的单个创建数(如name、email等).keyExtractor用于从类型T的对象获取key.

public static class DuplicateHandler<T> implements Consumer<T> {
    private Map<Object, Set<T>> itemByKey = new HashMap<>();
    private Function<T, ?> keyExtractor;

    public DuplicateHandler(Function<T, ?> keyExtractor) {
        this.keyExtractor = keyExtractor;
    }

    @Override
    public void accept(T t) {
        itemByKey.computeIfAbsent(keyExtractor.apply(t), k -> new HashSet<>()).add(t);
    }

    public void merge(DuplicateHandler<T> other) {
        other.itemByKey.forEach((k, v) ->
            itemByKey.merge(k,v,(oldV, newV) -> { oldV.addAll(newV); return oldV; }));
    }
    
    public Collection<Set<T>> getDuplicates() {
        Collection<Set<T>> duplicates = itemByKey.values();
        duplicates.removeIf(set -> set.size() == 1); // the object is proved to be unique by this particular property
        
        return duplicates;
    }
}

这就是负责生成副本映射的方法，该方法将从干净的代码中使用.给定的集合将被划分为两个部分:一个映射到key个true个副本，另一个映射到key个false-唯一对象.

public static <T> Map<Boolean, List<T>> getPartitionByProperties(Collection<T> parties,
                                                                 Function<T, ?>... keyExtractors) {
    
    DuplicateChecker<T> duplicateChecker = parties.stream()
        .collect(Collector.of(
            () -> new DuplicateChecker<>(keyExtractors),
            DuplicateChecker::accept,
            DuplicateChecker::merge,
            DuplicateChecker::finish
        ));
    
    return parties.stream()
        .collect(Collectors.partitioningBy(duplicateChecker::isDuplicate));
}

这就是你如何将它应用到你的特定 case 中.

main()个

public static void main(String[] args) {
    List<Party> parties = // initializing the list of parties
    
    Map<Boolean, List<Party>> isDuplicate = partitionByProperties(parties,
            Party::getName, Party::getNumber,
            Party::getEmail, Party::getGstNumber);
}