如何比较对象列表及其属性，然后在 Java 中更新原始列表

Question

我有一个具有列表作为其属性的对象，例如public class A {  private String aName;  private List<B> bList;}public class B {  private String bName;}假设我们有两个A's 列表：List<A> existingList = new ArrayList<A>();// populate it with a list of A's which in turn, each has its own list of B'sList<A> newList = new ArrayList<A>();// populate it with possibly some new A's and/or, an existing A which its property B has new items考虑到这一点，我想知道比较这两个列表的最快方法，并将这两个列表A的增量添加到existingList.请注意，我们也在比较两个列表中的B' As 列表，因此如果有匹配A的 's，但它们的B's 有一个 delta，我们应该能够将它添加到existingList' As bList。同样，如果我们检测到某个项目已从 中删除newList，我们应该将其从 中删除existingList。

Answer 1

如果您关心顺序，那么只需使用 equals 方法：

list1.equals(list2);

从javadoc：

比较指定对象与此列表是否相等。当且仅当指定对象也是一个列表时返回 true，两个列表具有相同的大小，并且两个列表中所有对应的元素对都相等。（如果 (e1==null ? e2==null : e1.equals(e2)) 两个元素 e1 和 e2 相等。）换句话说，如果两个列表以相同的顺序包含相同的元素，则它们被定义为相等. 此定义确保 equals 方法在 List 接口的不同实现中正常工作。

如果您想独立检查顺序，可以将所有元素复制到 Sets 并在结果 Sets 上使用 equals：

public static <T> boolean listEqualsIgnoreOrder(List<T> list1, List<T> list2) {
    return new HashSet<>(list1).equals(new HashSet<>(list2));
    }

这种方法的一个限制是它不仅忽略了顺序，而且还忽略了重复元素的频率。例如，如果 list1 是 ["A", "B", "A"] 并且 list2 是 ["A", "B", "B"]，那么 Set 方法会认为它们是相等的。

如果您需要对订单不敏感但对重复的频率敏感，您可以：

在比较它们之前对两个列表（或副本）进行排序，或者将所有元素复制到 Multiset。

Answer 2

这有效：

package collection.delta;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.List;

import java.util.function.Predicate;

import java.util.stream.Collectors;

import collection.delta.model.A;

import collection.delta.model.B;

public class App {

    public static void main( String[] args ) {

        List<A> originalA = new ArrayList<A>();

        List<A> newA = new ArrayList<A>();

        List<B> bListOriginalA1 = new ArrayList<B>();

        bListOriginalA1.add(new B("originalA1_B1"));

        bListOriginalA1.add(new B("originalA1_B2"));

        bListOriginalA1.add(new B("originalA1_B3"));

        bListOriginalA1.add(new B("originalA1_B4"));

        A originalA1 = new A("originalA1", bListOriginalA1);

        List<B> bListOriginalA2 = new ArrayList<B>();

        bListOriginalA2.add(new B("originalA2_B1"));

        bListOriginalA2.add(new B("originalA2_B2"));

        bListOriginalA2.add(new B("originalA2_B3"));

        bListOriginalA2.add(new B("originalA2_B4"));

        A originalA2 = new A("originalA2", bListOriginalA2);

        List<B> bListOriginalA3 = new ArrayList<B>();

        bListOriginalA3.add(new B("originalA3_B1"));

        bListOriginalA3.add(new B("originalA3_B2"));

        bListOriginalA3.add(new B("originalA3_B3"));

        bListOriginalA3.add(new B("originalA3_B4"));

        A originalA3 = new A("originalA3", bListOriginalA3);

        originalA.add(originalA1);

        originalA.add(originalA2);

        originalA.add(originalA3);

        List<B> bListNewA1 = new ArrayList<B>();

        bListNewA1.add(new B("originalA1_B1"));

        bListNewA1.add(new B("originalA1_B2"));

        bListNewA1.add(new B("originalA1_B3"));

        bListNewA1.add(new B("originalA1_B4"));

        A newA1 = new A("originalA1", bListNewA1);

        List<B> bListNewA2 = new ArrayList<B>();

        bListNewA2.add(new B("originalA2_B1"));

        bListNewA2.add(new B("originalA2_B3"));

        bListNewA2.add(new B("originalA2_B4"));

        bListNewA2.add(new B("originalA2_B2"));

        A newA2 = new A("originalA2", bListNewA2);

        List<B> bListNewA3 = new ArrayList<B>();

        bListNewA3.add(new B("originalA3_B1"));

        bListNewA3.add(new B("originalA3_B2"));

        bListNewA3.add(new B("originalA3_B5"));

        bListNewA3.add(new B("originalA3_B4"));

        A newA3 = new A("originalA3", bListNewA3);

        List<B> bListNewA4 = new ArrayList<B>();

        bListNewA4.add(new B("A4_B1"));

        bListNewA4.add(new B("A4_B2"));

        bListNewA4.add(new B("A4_B3"));

        bListNewA4.add(new B("A4_B4"));

        A newA4 = new A("originalA4", bListNewA4);

        newA.add(newA1);

        newA.add(newA2);

        newA.add(newA3);

        newA.add(newA4);

        List<A> result = newA.stream()

                .filter(not(new HashSet<A>(originalA)::contains))

                .collect(Collectors.toList());

        A tempA = null;

        B tempB = null;

        List<B> bList = null;

        for (A a : result) {

            if (!containsName(originalA, a.getaName())) {

                originalA.add(a);

            } else {

                tempA = getAIfPresent(originalA, a.getaName());

                if (tempA != null) {

                    bList = a.getbList().stream()

                            .filter(not(new HashSet<B>(tempA.getbList())::contains))

                            .collect(Collectors.toList());

                    if (bList != null) {

                        tempA.getbList().addAll(bList);

                    }

                }

            }

        }

        System.out.println("");

    }

    public static <T> Predicate<T> not(Predicate<T> predicate) {

        return predicate.negate();

    }

    public static boolean containsName(final List<A> list, final String name){

        return list.stream().map(A::getaName).filter(name::equals).findFirst().isPresent();

    }

    public static A getAIfPresent(final List<A> list, final String name) {

        return list.stream().filter(x -> x.getaName().equalsIgnoreCase(name)).findFirst().orElse(null);

    }

}

Answer 3

第 1 步：为这两个类实现equals()和hashCode。

第 2 步：将列表转换为集合。

第 3 步：使用一种或多种Set方法addAll、removeAll和/或retainAll进行集合运算，例如并集、交集和差集。