在Java中检查列表是否包含另一个列表中的项目的最快方法是什么，两个列表都属于同一类型？

Question

假设我有一个名为 MyClass 的类，如下所示：

public class MyClass
{
     //Identifier is alpha-numeric. If the identifier starts will 'ZZ'
     //is special special identifier.
     private String identifier = null;
     //Date string format YYYY-MM-DD
     private String dateString = null;
     //Just a flag (not important for this scenario)
     private boolean isCoolCat = false;
     //Default Constructor and getters/setters implemented
     //Overrides the standard Java equals() method.
     //This way, when ArrayList calls contains() for MyClass objects
     //it will only check the Date (for ZZ identifier) 
     //and identifier values against each other instead of
     //also comparing the isCoolCat indicator value.
     @Override
     public boolean equals(Object obj)
     {
          if(this == obj)
          {
               return true;
          }
          if(obj == null)
          {
               return false;
          }
          if(getClass() != obj.getClass())
          {
               return false;
          }
          MyClass other = (MyClass) obj;
          if(this.identifier == null)
          {
               if(other.identifier != null)
               {
                    return false;
               }
          } else if(!this.identifier.equals(other.identifier)) {
               return false;
          }
          if(other.identifier.startsWith("ZZ"))
          {
               if(!this.dateString.equals(other.dateString))
               {
                    return false;
               }
          }
          return true;
     }
}

在另一个类中，我有两个 MyClass 类型的 List，每个包含 100,000 个对象。我需要检查一个列表中的项目是否在另一个列表中，我目前完成此操作如下：

`

List<MyClass> inList = new ArrayList<MyClass>();
List<MyClass> outList = new ArrayList<MyClass>();
inList = someMethodForIn();
outList = someMethodForOut();
//For loop iterates through inList and check if outList contains
//MyClass object from inList if it doesn't then it adds it.
for(MyClass inObj : inList)
{
     if(!outList.contains(inObj))
     {
          outList.add(inObj); 
     }
}

我的问题是：这是完成此任务的最快方法吗？如果不能，您能否向我展示一个更好的实现，它将给我带来性能提升？列表大小并不总是 100,000。目前在我的平台上，100,000 大小大约需要 2 分钟。假设它可以在 1 到 1,000,000 之间变化。

Answer 1

您想为此使用Set。 Set 有一个 contains 方法，可以在 O(1) 时间内确定对象是否在集合中。

从List<MyClass> 转换为Set<MyClass> 时需要注意的几点：

1. 您将失去元素的顺序
2. 您将丢失重复的元素
3. 您的MyClass 需要实现hashcode() 和equals() 和they should be consistent。

要将您的List 转换为Set，您可以使用：

Set<MyObject> s1 = new HashSet<>(inList);
Set<MyObject> s2 = new HashSet<>(outList);

---

这个Java doc 解释了如何找到两个集合的并集、交集和差集。特别是，您似乎对联盟感兴趣：

// transforms s2 into the union of s1 and s2. (The union of two sets 
// is the set containing all of the elements contained in either set.)
s2.addAll(s1)

Answer 2

2 分钟比较 2 个非常大的列表，在这里可能不会节省太多时间，所以根据您的应用程序，您是否可以设置一个标志，以便依赖于此的东西在完成之前无法运行并将其推送到它自己的线程中，并且让用户做其他事情（同时也告诉他们这是在进行中。）或者至少设置一个进度条。让用户知道应用程序很忙，并告诉他们（ish）在像这样的非常复杂的计算中只需要几分钟的时间就可以了，并且可能比仅仅节省几秒钟的时间更好。如果用户知道他们会等多久，并且你告诉他们有时间去喝杯咖啡，他们会非常容忍延迟。

Answer 3

散列！哈希始终是答案！

此代码的当前复杂度为O(nm)，其中n 是inList 的大小，m 是outList 的大小。

您可以使用HashSet 将复杂性降低到O(n)。因为contains 现在会占用O(1)

可以这样做，

   HashSet<MyClass> outSet = new HashSet<>(outList);
   for(MyClass inObj : inList)
   {
        if(!outSet.contains(inObj))
        {
              outList.add(inObj); 
         }
    }

---

来源和来源。

returning difference between two lists in java

Time complexity of contains(Object o), in an ArrayList of Objects

HashSet.contains performance