Question

我有一个方法，它接受两个列表 - 都是Person类型。 Person类具有大量属性，但我想检查列表是否仅包含基于名称和年龄属性的相同项目，如果它们相等则返回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;
}

Answer 1

下面的两个解决方案都在Java 8中。我更喜欢第一个解决方案，因为你不会弄乱Person类。但是， 如果你绝对不会破坏任何东西 ，第二种解决方案对于读者来说更清楚。

解决方案1 

pip install nameofwheelfile.whl

解决方案2

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对象中实现自己的equals和hashcode。

public boolean compareTwoLists(List<Person> list1, List<Person> list2) {
    return list2.stream().anyMatch(list1::contains);
}

Answer 2

覆盖Person类中的Object.equals()，以便person1.equals(person2)根据您的成员值返回true / false。

Answer 3

查看this回答。

你应该实现Comparable。假设所有字段都不会为null（为简单起见），该年龄是一个int，并比较排名是last，first，age，compareTo方法很简单：

public int compareTo(Person other) {
    int i = firstName.compareTo(other.firstName);
    if (i != 0) return i;

    i = lastName.compareTo(other.lastName);
    if (i != 0) return i;

    return Integer.compare(age, other.age);
}

你也可以@Override你的等于方法来检查年龄和名字，如下

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;
}

Answer 4

如果你想要比较两个列表，你将不得不迭代这两个列表，但如果你的列表是排序而你只想知道，如果它们相同或不相同，那么你只有检查两个列表的每个列表元素一次，对于大型列表最终应该快得多：

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;

}

此外，您可以将方法编写为Comparator，这样可以使其更具可重用性或适合排序，因为您可以返回0（列表相同），-1（第一个列表）是小的），1（第一个列表更大）或其他意义为您的目的：

class PersonListComparator implements Comparator<List<Person>> {
    @Override public int compare(List<Person> list1, List<Person> list2) {
        // Your code
    }
}

如果您总是比较姓名和年龄，您还可以考虑覆盖equals(...)课程的Person方法。然后，比较可以缩短为代码中的person1.equals(person2)。

或者，使用Comparable界面，该界面为您的类添加方法int compareTo(T object)，与Comparator相同。

Answer 5

一旦两个人的年龄和姓名相同，你就会返回真实，但这并不意味着所有人都是如此。

为实现这一目标，在您的方法中，您应该在比较失败后立即返回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;
}

Answer 6

根据您的问题，我认为您只想检查给定的两个列表是否包含相同的数据（相同数量的人和相同的数据）在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;
    }
}

检查两者是否长度相同，否则返回false
否则第一个列表中的所有人员都应该出现在第二个列表中，如果没有则返回false。

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

6 个答案: