Java 比较两个列表的内容

我想比较两个列表的内容，特别是存储在这两个列表中的自定义对象的某个方法，我们称之为

#getID（）

我的方法是有一个方法告诉我这两个列表是否包含具有相同ID的相同条目

List<CustomObject> firstList;
List<CustomObject> secondList;

List-firstList；
第二名单；

循环遍历

firstList

中的每个条目，对其调用getID（），并查看

secondList

中是否有一个对象为getID（）返回相同的值

---

进行此检查的有效方法是什么？最好使用Java 8流，它们在这里非常有用。

如果两个列表都已排序，您可以这样做：

public boolean equalsLists(List<YourClass> a, List<YourClass> b) {
    if (a.size() != b.size()) {
        return false;
    }
    for (int i = 0; i < a.size(); i++) {
        if (!a.get(i).getId().equals(b.get(i).getId()) {
             return false;
        }
    }
    return true;
}

公共布尔等式列表（列表a、列表b）{
如果（a.size（）！=b.size（））{
返回false；
}
对于（int i=0；i

如果可以对元素进行排序，请对它们进行排序，并应用前面显示的相同算法

否则，算法的效率取决于许多因素：

• 两个列表可以相等的频率
• 名单有多长
• If元素可以在列表中出现多次
• 如果可以对所有元素应用一个函数，以便在两个列表不相等的情况下合理安全地知道，则在逐个元素进行比较之前使用该函数（例如，如果要检查的字符串大小不同，则可以计算每个列表的每个id的字符数，如果它们不同，则可以确保返回false）

---

如果两个列表都已排序，则可以执行以下操作：

public boolean equalsLists(List<YourClass> a, List<YourClass> b) {
    if (a.size() != b.size()) {
        return false;
    }
    for (int i = 0; i < a.size(); i++) {
        if (!a.get(i).getId().equals(b.get(i).getId()) {
             return false;
        }
    }
    return true;
}

公共布尔等式列表（列表a、列表b）{
如果（a.size（）！=b.size（））{
返回false；
}
对于（int i=0；i

如果可以对元素进行排序，请对它们进行排序，并应用前面显示的相同算法

否则，算法的效率取决于许多因素：

• 两个列表可以相等的频率
• 名单有多长
• If元素可以在列表中出现多次
• 如果可以对所有元素应用一个函数，以便在两个列表不相等的情况下合理安全地知道，则在逐个元素进行比较之前使用该函数（例如，如果要检查的字符串大小不同，则可以计算每个列表的每个id的字符数，如果它们不同，则可以确保返回false）

---

假设两个列表都已排序，您可以使用

比较器

        Comparator<List<CustomObject>> myComp = new Comparator<List<CustomObject>>() {
            @Override
            public int compare(List<CustomObject> customObjectList, List<CustomObject> t1) {
                for (int i = 0; i < customObjectList.size(); i++) {
                    if (customObjectList.getId().equals(t1.getId())) {
                        // Do your logic here
                    }
                }
            }
        };

        myComp.compare(list1, list2);

Comparator mycop=new Comparator（）{
@凌驾
公共整数比较（列表customObjectList，列表t1）{
对于（int i=0；i

这是一种“Java”方式。如果列表大小不匹配，您将不得不练习某种防御编程。如果它们没有排序，您可以在比较这两个列表之前使用
集合。排序
。
假设两个列表都已排序，您可以使用
比较器

        Comparator<List<CustomObject>> myComp = new Comparator<List<CustomObject>>() {
            @Override
            public int compare(List<CustomObject> customObjectList, List<CustomObject> t1) {
                for (int i = 0; i < customObjectList.size(); i++) {
                    if (customObjectList.getId().equals(t1.getId())) {
                        // Do your logic here
                    }
                }
            }
        };

        myComp.compare(list1, list2);

Comparator mycop=new Comparator（）{
@凌驾
公共整数比较（列表customObjectList，列表t1）{
对于（int i=0；i

这是一种“Java”方式。如果列表大小不匹配，则必须进行某种防御性编程。如果列表未排序，则可以在比较这两个列表之前使用
集合。排序
。
获取重复元素的一种方法是使用以下映射

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;

public class SomeClass {
    protected class Component {
        public String getId() {
            return id;
        }

        public void setId(String id) {
            this.id = id;
        }

        public String getDescription() {
            return description;
        }

        public void setDescription(String description) {
            this.description = description;
        }

        public Component(String id, String description) {
            super();
            this.id = id;
            this.description = description;
        }

        String id;
        String description;

        @Override
        public String toString() {
            // TODO Auto-generated method stub
            return "Id " + this.getId();
        }

    }

    public static void main(String[] args) {

        Component component1 = new SomeClass().new Component("1", "One");
        Component component2 = new SomeClass().new Component("2", "One");
        Component component3 = new SomeClass().new Component("1", "One");
        Component component4 = new SomeClass().new Component("3", "Three");
        Component component5 = new SomeClass().new Component("4", "Four");
        List<Component> list1 = new ArrayList<Component>();
        list1.add(component1);
        list1.add(component2);

        List<Component> list2 = new ArrayList<Component>();
        list1.add(component1);
        list1.add(component2);

        list2.add(component3);
        list2.add(component4);
        list2.add(component5);

        Map<String, Component> result = list2.stream().collect(Collectors.toMap(Component::getId, Function.identity()));

        Set<Component> repeated = list1.stream().filter(component -> result.containsKey(component.getId()))
                .collect(Collectors.toSet());
        repeated.forEach(System.out::println);
    }

}

import java.util.ArrayList；
导入java.util.List；
导入java.util.Map；
导入java.util.Set；
导入java.util.function.function；
导入java.util.stream.collector；
公共类{
受保护类组件{
公共字符串getId（）{
返回id；
}
公共无效集合id（字符串id）{
this.id=id；
}
公共字符串getDescription（）{
返回说明；
}
公共void集合描述（字符串描述）{
this.description=描述；
}
公共组件（字符串id、字符串描述）{
超级（）；
this.id=id；
this.description=描述；
}
字符串id；
字符串描述；
@凌驾
公共字符串toString（）{
//TODO自动生成的方法存根
返回“Id”+this.getId（）；
}
}
公共静态void main（字符串[]args）{
Component component1=新的SomeClass（）。新的组件（“1”，“1”）；
ComponentComponent2=新的SomeClass（）。新的组件（“2”，“1”）；
ComponentComponent3=新的SomeClass（）。新的组件（“1”，“1”）；
ComponentComponent4=新的SomeClass（）。新的组件（“3”，“3”）；
ComponentComponent5=新的SomeClass（）。新的组件（“4”，“4”）；
List list1=新的ArrayList（）；
列表1.添加（组件1）；
列表1.添加（组件2）；
List list2=新的ArrayList（）；
列表1.添加（组件1）；
列表1.添加（组件2）；
列表2.添加（组件3）；
列表2.添加（组件4）；
列表2.添加（组件5）；
映射结果=list2.stream（）.collect（Collectors.toM