我们经常使用的集合如ArrayList,LinkedList，Vector, 
 **你在调用contains()方法的时候, 或者是你在根据对象移除元素 remove(Object o) 你知道他们是如何判断集合中的元素是否 
 是相等的吗**? 
 接下来我们跟着源码去详细探究一下 
 数据数据结构不同判断的依据就不同,我们先来看一下List类的判断依据.
 
先简单的了解一下 
 List类 : 有序，可以有重复元素。 
 
ArrayList 底层是一个对象数组 
 private transient Object[] elementData; 
 LinkedList 属于链式数据结构,底层用的是一个Node类的节点,包括指针域和数据域.
 
private static class Node { 
 E item; 
 Node next; 
 Node prev;
 
    Node(Node<E> prev, E element, Node<E> next) {
        this.item = element;
        this.next = next;
        this.prev = prev;
    }
}
 
ArrayList LinkedList他们都是线程不同步的 Vector非常类似ArrayList，但是Vector是同步的。, ArrayList LinkedList多线程访问会抛出 ConcurrentModificationException。如果想使他们线程同步的可以使用 Collections.synchronizedList 方法将该集合“包装”起来
 
回归正题
 
我们想知道他们如何判断集合元素是否相等,我们应该想到的是contains(Object o)方法,接下来我们看一下contains(Object o)方法
 
  public boolean contains(Object o) {
        return indexOf(o) >= 0;
    }
 
他的方法内部调用了indexOf(o)这个方法,我们继续追踪看一下indexOf(o)方法
 
   public int indexOf(Object o) {
        if (o == null) {
            for (int i = 0; i < size; i++)
                if (elementData[i]==null)
                    return i;
        } else {
            for (int i = 0; i < size; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }
 
看到这里我们应该能明白了 先判断要查找的元素是否为空,不为空的话就调用equals方法.由此我们得到一个结论 
 List类中判断元素是否相等依赖的是equals方法.
 
set类 : 无序，不允许重复
 
HashSet : 
 此实现不是同步的 
 我们知道HashSet它不允许出现重复元素,他是如何保证元素唯一的呢,我们应该首先想到的是看他的add()方法 
 如下
 
public boolean add(E e) { 
 return map.put(e, PRESENT)==null; 
 } 
 这里出现了一个map我们找找看看他是什么
 
我们在上面看到了他的定义 
 
 private transient HashMap<E,Object> map;

 
现在我们知道了HashSet的内部其实是一个HashMap来维护的,众所周知HashMap的键是不允许有相同的,不用说HashMap的键就是HashSet的值,接下来我们只需要知道HashMap的键是如何保证唯一的就行了
 
我们就要追踪HashMap的添加元素方法 put(K key, V value) 
 
public V put(K key, V value) {
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);
        }
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key);
        int i = indexFor(hash, table.length);
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }
 
虽然有点麻烦我们只需要仔细看看 一定可以看明白 抓住最重要的一句
 
e.hash == hash && ((k = e.key) == key || key.equals(k))
 
现在我们也知道了HashSet 和HaspMap 保证元素唯一的办法是 先比较两个元素的哈希值,如果哈希值相等,在比较元素的地址是否相同,或者调用两个元素的equals方法如果哈希值不同,就根本不用在比较了.

public class ListUtils {

    /**
     * 判断集合元素是否相等（无序）
     */
    public static boolean isEqualCollection(Collection a, Collection b){

        if (a.size() !=b.size()) {  // size是最简单的相等条件
            return false;
        }
        Map mapa = getCardinalityMap(a);
        Map mapb = getCardinalityMap(b);

        // 转换map后，能去掉重复的，这时候size就是非重复项，也是先决条件
        if (mapa.size() !=mapb.size()) {
            return false;
        }
        Iterator it =mapa.keySet().iterator();
        while (it.hasNext()) {
            Object obj = it.next();
            // 查询同一个obj，首先两边都要有，而且还要校验重复个数，就是map.value
            if (getFreq(obj,mapa) != getFreq(obj, mapb)) {
                return false;
            }
        }
        return true;
    }


    public static Map getCardinalityMap(Collection coll) {
        Map count = new HashMap();
        Iterator it = coll.iterator();
        for (it.hasNext()) {
            Object obj =it.next();
            Integer c =(Integer) count.get(obj);
            if (c == null)
                count.put(obj, 1);
            else {
                count.put(obj, new Integer(c.intValue() + 1));
            }
        }
        return count;
    }

    private static final int getFreq(Object obj, Map freqMap) {
        Integer count =(Integer) freqMap.get(obj);
        if (count != null) {
            return count.intValue();
        }
        return 0;
    }

}

测试代码demo：
 
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class Test {
    public static void main(String[] args) {
        List<String> arrayList = new ArrayList<>();
        arrayList.add("a");
        arrayList.add("b");
        arrayList.add("c");
        List<String> linkList = new LinkedList<>();
        linkList.add("a");
        linkList.add("b");
        linkList.add("c");
        System.out.println(arrayList.equals(linkList));
    }
}
 
输出结果如下：
 
 可以发现结果是相等的，符合预期。
 
那么接着看看用于比较的equals方法，如下：
 
public boolean equals(Object o) {
    //==比较引用地址，如果相等，说明是一个对象，返回true
    if (o == this)
        return true;
    //看下类型是否是List
    if (!(o instanceof List))
        return false;
     //通过迭代器来访问list的所有元素
    ListIterator<E> e1 = listIterator();
    ListIterator<?> e2 = ((List<?>) o).listIterator();
   //比较大小
    while (e1.hasNext() && e2.hasNext()) {
        E o1 = e1.next();
        Object o2 = e2.next();
        //只要不相等，就返回false
        if (!(o1==null ? o2==null : o1.equals(o2)))
            return false;
    }
    //比较长度是否相等
    return !(e1.hasNext() || e2.hasNext());
}
 
可以发现比较集合是否相等的逻辑就是顺序比较每一个元素是否相等以及长度是否相等。那如果两个集合里的元素相等的，只是顺序不同呢，修改如下：
 
 运行结果如下：
 
 结果就变为false了。说明使用equals方法来比较集合是否相等，元素顺序也是评判的标准之一。

第一种：遍历循环
 
for(String str : list) {
   if(!list1.contains(str)) {
      return false;
   }
}
 
第二种：使用list中的retainAll方法
 
java 取交集方法retainAll
 
有两个集合A和B，判断这两个集合是否包含相同的对象或元素，可以使用retainAll方法：A.retainAll(B)。如果存在相同元素，A仅保留相同的元素。如果不存在相同元素，A会变为空。
 
总的来说：如果集合A和集合B是完全相同的集合，也会返回false。两个集合没有交集，才会返回true
 
第三种：使用md5的加密算法（可以了解，最好不要使用，比第一种循环比较还慢）
 
String str = SecureUtil.md5(list.toString());     
String str1 = SecureUtil.md5(list1.toString());
return str.equals(str1);
 
第四种：java8的stream流
 
return list.stream().sorted().collect(Collectors.joining())
.equals(list1.stream().sorted().collect(Collectors.joining()));
 
第五种：使用list自带的sort方法先进性排序，然后转成toString去判断两个集合是否相等（速度最优，推荐使用）
 
list.sort(Comparator.comparing(String::hashCode));  
list1.sort(Comparator.comparing(String::hashCode)); 
return list.toString().equals(list1.toString());