在Java中比较两个单独列表中的项目

我有一个方法，它包含两个列表——类型都是

Person

。

Person

类有大量属性，但我想检查列表是否仅基于name和age属性包含相同的项，如果它们相等，则返回true，否则返回false

有没有更好的方法可以让我这样做

public boolean compareTwoLists(List<Person> list1, List<Person> list2)
{
    for (Person person1 : list1)
    {
        for (Person person2 : list2)
        {
            if (person1.getAge().equals(person2.getAge() && person1.getName().equals(person2.getName())))
            {
                return true;
            }
        }
    }
    return false;
}

public boolean compareTowolist（列表1、列表2）
{
对于（个人1:list1）
{
对于（个人2:list2）
{
if（person1.getAge（）.equals（person2.getAge（）&&person1.getName（）.equals（person2.getName（）））
{
返回true；
}
}
}
返回false；
}

覆盖Person类中的

对象.equals（）

，以便

person1.equals（person2）

根据您的成员值返回true/false。

检查答案

您应该实现可比较的。假设所有字段都不会 为简单起见，该年龄为int，并比较排名 最后，首先是年龄，比较法非常简单：

您还可以@Override您的equals方法，让它像这样检查年龄和姓名

public boolean equals(Object p) {
    ... // More code here - null checks
    if(p.getName().equals(this.name) && p.getAge() == this.age) 
       return true;
    else 
       return false;
}

---

如果您想比较这两个列表，您必须迭代这两个列表，但是如果您的列表是排序的，并且您只想知道它们是否相等，那么您只需要检查两个列表的每个列表元素一次，对于大型列表，这应该会更快：

public boolean compareTwoLists(List<Person> list1, List<Person> list2) {

    // Lists don't have the same size, objects missing in
    // list one or two. I your lists have the same size, skip this.
    if (list1.size() != list2.size() {
        return false;
    }

    Iterator<Person> it1= list1.iterator();
    Iterator<Person> it2= list2.iterator();

    while (it1.hasNext()) {
        Person person1 = it1.next();
        Person person2 = it2.next();

        // Age or name do not match, objects differ, lists are not equal.
        if ((!person1.next().getAge().equals(person2.getAge()) || (!person1.getName().equals(person2.getName()))))
            return false;
    }

    // All items are the same.
    return true;

}

如果您总是比较姓名和年龄，您还可以考虑覆盖

Person

类的

equals（…）

方法。然后，可以在代码中将比较缩短为

person1.equals（person2）

---

或者，使用

Comparable

接口，该接口向类中添加一个方法

int compareTo（T object）

，该方法与

Comparator
相同，只要两个人年龄和姓名相同，就返回true，但这并不意味着对所有人都是true

要实现这一点，在方法中，当比较失败时，应立即返回
false
。

循环完成后，如果未返回
false
，则表示所有元素都具有相同的年龄和名称值。因此，您返回
true
：

public boolean compareTwoLists(List<Person> list1, List<Person> list2){
  for (Person person1 : list1) {
    for (Person person2 : list2) {
      if (!person1.getAge().equals(person2.getAge() || !person1.getName().equals(person2.getName()))) {
        return false;
      }
    }
  }
  return true;
}

public boolean compareTowolist（列表1、列表2）{
对于（个人1:list1）{
对于（个人2:list2）{
如果（！person1.getAge（）.equals（person2.getAge（）| |！person1.getName（）.equals（person2.getName（）））{
返回false；
}
}
}
返回true；
}
以下两种解决方案均采用Java 8。我更喜欢第一个，因为你不会弄乱Person类。但是，如果您绝对确定不会损坏任何东西，那么第二种解决方案对读者来说就更清楚了

解决方案1

public boolean compareTwoLists(List<Person> list1, List<Person> list2) {

    return list2.stream().anyMatch(l2 -> list1.stream().anyMatch(l1 ->
         l1.getName().equals(l2.getName()) &&
         l1.getAge().equals(l2.getAge())
    ));
}

从你的问题来看，我想你只是想检查给定的两个列表是否包含相同的数据（相同的人数和相同的数据）
重写Person类中的hashcode和equals方法以仅检查姓名和年龄

public class Person {

private String name;
private int age;

// other fields
private String address;

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

public int getAge() {
    return age;
}

public void setAge(int age) {
    this.age = age;
}

public String getAddress() {
    return address;
}

public void setAddress(String address) {
    this.address = address;
}

@Override
public int hashCode() {
    final int prime = 31;
    int result = 1;
    result = prime * result + age;
    result = prime * result + ((name == null) ? 0 : name.hashCode());
    return result;
}

@Override
public boolean equals(Object obj) {
    if (this == obj)
        return true;
    if (obj == null)
        return false;
    if (getClass() != obj.getClass())
        return false;
    Person other = (Person) obj;
    if (age != other.age)
        return false;
    if (name == null) {
        if (other.name != null)
            return false;
    } else if (!name.equals(other.name))
        return false;
    return true;
}}

然后只需在给定函数中传递两个列表：

public boolean isListEqual(List<Person> list1, List<Person> list2) {
    if (list1.size() != list2.size()) {
        return false;
    } else {
        for (Person p : list1) {
            if (!list2.contains(p)) {
                return false;
            }
        }
        return true;
    }
}

公共布尔isListEqual（列表1、列表2）{
如果（list1.size（）！=list2.size（））{
返回false；
}否则{
对于（人员p:list1）{
如果（！list2.contains（p））{
返回false；
}
}
返回true；
}
}


它检查两者是否具有相同的长度，否则返回false
否则，第一个列表中的所有人都应该出现在第二个列表中，如果没有，则返回false
唯一可行的方法是重写
.equals（）
方法。否则，它将检查对象引用。如果不是所有成员都相等，该怎么办？如果您想检查两个列表的相等性，则添加了一种更快的排序方法。
public boolean compareTwoLists(List<Person> list1, List<Person> list2) {
    return list2.stream().anyMatch(list1::contains);
}

@Override
    public boolean equals(Object o)
    {
        if (this == o)
            return true;
        if (o == null || getClass() != o.getClass())
            return false;

        Person person = (Person) o;

        if (age != null ? !age.equals(person.age) : person.age != null)
            return false;
        return name != null ? name.equals(person.name) : person.name == null;
    }

    @Override
    public int hashCode()
    {
        int result = age != null ? age.hashCode() : 0;
        result = 31 * result + (name != null ? name.hashCode() : 0);
        return result;
    }

public class Person {

private String name;
private int age;

// other fields
private String address;

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
}

public int getAge() {
    return age;
}

public void setAge(int age) {
    this.age = age;
}

public String getAddress() {
    return address;
}

public void setAddress(String address) {
    this.address = address;
}

@Override
public int hashCode() {
    final int prime = 31;
    int result = 1;
    result = prime * result + age;
    result = prime * result + ((name == null) ? 0 : name.hashCode());
    return result;
}

@Override
public boolean equals(Object obj) {
    if (this == obj)
        return true;
    if (obj == null)
        return false;
    if (getClass() != obj.getClass())
        return false;
    Person other = (Person) obj;
    if (age != other.age)
        return false;
    if (name == null) {
        if (other.name != null)
            return false;
    } else if (!name.equals(other.name))
        return false;
    return true;
}}

public boolean isListEqual(List<Person> list1, List<Person> list2) {
    if (list1.size() != list2.size()) {
        return false;
    } else {
        for (Person p : list1) {
            if (!list2.contains(p)) {
                return false;
            }
        }
        return true;
    }
}