比较 Java 中的两个对象列表

Question

我需要一些帮助来解决比较两个对象列表（TestFoo 类型）时遇到的问题。目标是检测列表之间的差异，删除不匹配的项目，并在存储库中执行一些必要的清理。以下是我正在采取的方法和遇到的问题的简要概述：

目标：

我需要比较现有项目和新项目（均为 TestFoo 类型）。

我在做什么：

现有的ESItems和newItems都被转换为排序集（SortedSet）。 我使用比较器根据 uniqueItemDetailId 属性对这些集合进行排序。 排序后，我使用 .equals() 比较集合。 但是，即使列表包含不同的值，比较 (sortedExistingESItems.equals(sortedNewESItems)) 也不会触发 if 块，并且代码的行为不符合预期。

Comparator<TestFoo> budgetItemComparator = Comparator.comparing(TestFoo::getUniqueItemDetailId);

SortedSet<TestFoo> sortedExistingESItems = new TreeSet<>(itemComparator);
sortedExistingESItems.addAll(existingESItems);

SortedSet<TestFoo> sortedNewESItems = new TreeSet<>(budgetItemComparator);
sortedNewESItems.addAll(newItems);

if (!sortedExistingESItems.equals(sortedNewESItems)) {
    finalSavingTestFooItems.addAll(newItems);
    testFooRepository.deleteAll(existingESItems);
}

这是 TestFoo 类的骨架：

public class TestFoo {
    @Id
    private String id;
    @Field(type = Keyword)
    private String uniqueId;
    @Field(type = Keyword)
    private String uniqueIdDetailId;
    @Field(type = Keyword)
    private String uniqueIdSyncGuId;
    @Field(type = Keyword, index = false)
    private String name;
    @Field(type = Keyword)
    private String yearId;
    @Field(type = Keyword)
    private Set<String> types;
    @Field(type = Keyword)
    private Set<String> managers;
    @Field(type = Nested, includeInParent = true)
    private Set<TestHigh> hierarchies;
    @Field(type = Nested, includeInParent = true)
    private Set<TestTeam> teamMembers;

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        TestFoo that = (TestFoo) o;
        return Objects.equals(uniqueId, that.uniqueId) &&
               Objects.equals(uniqueIdDetailId, that.uniqueIdDetailId) &&
               Objects.equals(uniqueIdSyncGuId, that.uniqueIdSyncGuId) &&
               Objects.equals(name, that.name) &&
               Objects.equals(yearId, that.yearId) &&
               Objects.equals(types, that.types) &&
               Objects.equals(managers, that.managers) &&
               Objects.equals(hierarchies, that.hierarchies) &&
               Objects.equals(teamMembers, that.teamMembers);
    }

    @Override
    public int hashCode() {
        return Objects.hash(uniqueId, uniqueIdDetailId, uniqueIdSyncGuId, name, yearId, types, managers, hierarchies, teamMembers);
    }
}

@Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class TestHigh {
    
        @Field(type = Keyword)
        private String code;
    
        @Field(type = Keyword)
        private Set<String> values;
    
     
    
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            TestHigh that = (TestHigh) o;
            return Objects.equals(code, that.code) &&
                    Objects.equals(values, that.values) 
                 
        }
    
        @Override
        public int hashCode() {
            return Objects.hash(code, values);
        }
    
    }
    
    @Data
    @AllArgsConstructor
    @NoArgsConstructor
    public class TestTeam {
        @Field(type = Keyword)
        private String teamMemberId;
    
        @Field(type = Long)
        private Long startDate;
    
    
    
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            TestTeam that = (TestTeam) o;
            return Objects.equals(teamMemberId, that.teamMemberId) &&
                    Objects.equals(startDate, that.startDate) 
                  ;
        }
    
        @Override
        public int hashCode() {
            return Objects.hash(teamMemberId, startDate);
        }

Answer 1

要定义一个特定的排序顺序，可以：

• 更改您的类以实现

  Comparable

  以启用自然顺序排序，或者
• 定义要传递给

  Comparator

  实现的构造函数的

  SequencedSet

  。

…但不是两者兼而有之。两者都做是多余且令人困惑的。

巧合的是，我今天就这个话题写了一个很长的答案。请参阅此处的示例代码，以及更多讨论。