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

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

覆盖Object.equals()在Person类，使person1.equals(person2)返回真/假。

Answer 2

结账this回答。

您应该实施Comparable。假设所有字段将不会 为空（为简单起见），年龄是一个int，和比较排名 是最后的，第一，年龄，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); 
} 

你也可以@覆盖你的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; 
} 

Answer 3

如果您想将两个列表进行比较，你将不得不遍历两个，但如果你的名单分类而您只需要要知道，如果他们是平等的人还是没有，那么你只需要检查两个列表一次的每个列表元素，这应该是在年底快得多大名单：

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(...)方法类，如果你总是比较名称和年龄。然后，您的代码中的比较可以缩短为person1.equals(person2)。

或者，使用Comparable接口，该接口向类中添加方法int compareTo(T object)，与Comparator的做法相同。

Answer 4

只要两个人具有相同的年龄和姓名，但这并不意味着对所有人都是如此，您就返回真实。

要达到此目的，在您的方法中，您应该在比较失败后立即返回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 5

以下两种解决方案在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()) 
    )); 
} 

解决方案2

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

这意味着你需要实现Person对象里面自己的equals和hashCode。

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

Answer 6

从你的问题，我认为你只是要检查给出了两个列表中是否包含相同的数据或不（相同数量的人员和相同的数据） 重写了hashCode，等于在Person类方法来检查只有名字和年龄。

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。