Java 检查两个集合是否包含相同元素的方法，与顺序无关？

假设我有两个不同的Hashset，如下所示。如何检查两个Hashset是否包含相同的元素，并且这两个Hashset是否相等，与集合中元素的顺序无关，请告知

Set set1=new HashSet();
          set.add(new Emp("Ram","Trainer",34000));
          set.add(new Emp("LalRam","Trainer",34000));

另一个是

Set set2=new HashSet();
          set.add(new Emp("LalRam","Trainer",34000));
          set.add(new Emp("Ram","Trainer",34000));

员工pojo是

class Emp //implements Comparable
{
      String name,job;
      public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getJob() {
        return job;
    }
    public void setJob(String job) {
        this.job = job;
    }
    public int getSalary() {
        return salary;
    }
    public void setSalary(int salary) {
        this.salary = salary;
    }
    int salary;
      public Emp(String n,String j,int sal)
      {
         name=n;
         job=j;
         salary=sal;
       }
      public void display()
      {
        System.out.println(name+"\t"+job+"\t"+salary);
       }



  public boolean equals(Object o)
      {

         Emp p=(Emp)o;
          return this.name.equals(p.name)&&this.job.equals(p.job) &&this.salary==p.salary;
       }
   public int hashCode()
       {
          return name.hashCode()+job.hashCode()+salary;
       }


      /* public int compareTo(Object o)
       {
          Emp e=(Emp)o;
          return this.name.compareTo(e.name);
           //return this.job.compareTo(e.job);
        //   return this.salary-e.salary;

        }*/
} 

---

假设您已经定义了equals和hashcode，这里有一种方法。对于大型成员来说效率不是很高

检查每个组件中元素的#。如果他们不平等，你就完了[不平等]

循环通过Set1。检查Set2是否包含每个元素，如果不包含，则完成[不相等]。否则，如果你通过了整组，你是平等的

更新：我不知道containsAll，它省去了很多麻烦，基本上实现了这个算法

int s1 = set1.size();
int s2 = set2.size();
if (s1 !=s2) return false;
return set1.containsAll(set2);

---

如果希望数据相等，请正确实现

equals（）

和

hashCode（）

，然后可以使用。当然，您需要确保仅当两个集合的元素数相同时才调用此函数，否则您只能说它们不相等。

执行以下操作：

  setResult = set2.clone();

  if ( setResult.retainAll( set1 ) ){

   //do something with results, since the collection had differences

}

---

使用下面的表达式

set1.containsAll(set2) && set2.containsAll(set1)

引用javadoc：

返回true如果给定对象也是一个集合，则这两个集合具有 相同大小，并且给定集合的每个成员都包含在此集合中。 这可以确保equals方法在不同的应用程序中正常工作 Set接口的实现

因此，只需调用

set1.equals（set2）

就足够了。当且仅当集合包含相同的元素时（假设您已在集合中的对象上正确定义了

equals

和

hashCode

），它将返回

true

除非出于某种原因需要实现自己的方法，否则只需使用

h1.equals（h2）

。下面描述一种可能的实现

检查元素的#是否相同。如果不是，则返回false

克隆集2（如果以后需要保留集2）

迭代集合1，检查是否在克隆集合2中找到每个元素。如果找到，从集合2中移除。如果未找到，则返回false

如果到达迭代的末尾并匹配了集合1的每个元素，则集合是相等的（因为您已经比较了两个集合的大小）

例如：

public boolean isIdenticalHashSet <A> (HashSet h1, HashSet h2) {
    if ( h1.size() != h2.size() ) {
        return false;
    }
    HashSet<A> clone = new HashSet<A>(h2); // just use h2 if you don't need to save the original h2
    Iterator it = h1.iterator();
    while (it.hasNext() ){
        A = it.next();
        if (clone.contains(A)){ // replace clone with h2 if not concerned with saving data from h2
            clone.remove(A);
        } else {
            return false;
        }
    }
    return true; // will only return true if sets are equal
}

public boolean-isidentialhashset（HashSet h1，HashSet h2）{
如果（h1.size（）！=h2.size（））{
返回false；
}
HashSet clone=newhashset（h2）；//如果不需要保存原始h2，只需使用h2即可
迭代器it=h1.Iterator（）；
while（it.hasNext（））{
A=it.next（）；
如果（clone.contains（A））{//如果不涉及保存来自h2的数据，则将clone替换为h2
克隆。删除（A）；
}否则{
返回false；
}
}
return true；//仅当集合相等时才返回true
}

1-获取一个集合（我们称之为“差异”），其中包含一个集合中有而另一个集合中没有的项-

收集差异=CollectionUtils.subtract（Collection1，Collection2）

2-检查大小==0

如果是-两个集合具有相同的元素； 如果没有-存在一些差异，然后您必须打印“差异”存在的所有项目

不确定是否取决于项目顺序。 我以这种方式比较集合

当您不知道集合的类型时，这是一个冗长但（希望）有效的解决方案：

public static <T> boolean equalIgnoreOrder(Collection<T> c1, Collection<T> c2) {
    int size1 = c1.size();  // O(1) for most implementations, but we cache for the exceptions.
    if (size1 != c2.size()) {
        return false;
    }
    Set<T> set;
    Collection<T> other;
    if (c1 instanceof Set) {
        set = (Set<T>) c1;
        other = c2;
    } else if (c2 instanceof Set) {
        set = (Set<T>) c2;
        other = c1;
    } else if (size1 < 12 ) { // N^2 operation OK for small N
        return c1.containsAll(c2);
    } else {
        set = new HashSet<>(c1);
        other = c2;
    }
    return set.containsAll(other);  // O(N) for sets
}

公共静态布尔值重新排序（集合c1、集合c2）{
int size1=c1.size（）；//O（1）对于大多数实现，但我们缓存例外情况。
如果（size1！=c2.size（））{
返回false；
}
集合；
收集其他；
if（集合的c1实例）{
set=（set）c1；
其他=c2；
}else if（集合的c2实例）{
set=（set）c2；
其他=c1；
}否则，如果（大小1<12）{//N^2，则小N的操作正常
返回c1.containsAll（c2）；
}否则{
set=新哈希集（c1）；
其他=c2；
}
返回set.containsAll（其他）；//对于集合为O（N）
}

首先定义“等于”。等于参考值还是等值？如果后者为Emp类定义了equals和hashcode？假设

Emp

对

equals（）

和

hashcode（）

有适当的覆盖（考虑到它在哈希表中的存在，它可能会这样做），您可以比较集合上的计数，然后尝试将一个集合中的每个元素添加到另一个集合中。如果

add（）

方法返回

true

，则存在差异。这与比较任何其他集合没有区别。请参阅：。虽然这是.net，但java实现应该基本相同。我推荐Daniel Jennings或mbillings的答案，因为我很确定投票率最高的答案违反了微软的使用条款。首先，在

集合中讨论元素顺序是没有意义的。集合没有隐式顺序。第二，你还没有明确说明“等于”是什么意思。对于集合，可以是“两个集合包含对实际元素的同一组引用”，或“集合A中的所有元素与集合B中相应的元素进行相等比较（通过
equals（）
）。你似乎想要后一个定义，这是一个更难实现的问题。这个问题是重复的，正确的答案是：你能发布代码，让理解更清楚吗。。！MJB请您更新完整的代码，使理解更清楚。。！！我想，这比做一个以尺寸检查为前缀的容器要贵。太棒了！我不记得了。如果您只知道在哪里可以找到，那么在标准API中可以找到多少东西，这真是太神奇了。：）不错！不知道等号是为集合定义的！这是正确的答案，比公认的答案简单得多+1.请你把代码贴出来，这样会使理解更清楚。。！这不是一个好答案，下面的答案应该是哈