我们经常使用的集合如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方法如果哈希值不同,就根本不用在比较了.

Java如何判断两个集合的元素是否完全相等

    博主最近在工作的时候遇到了这样的一个需求,前端的页面提交一个表单数据，传到后台，我需要做判断这个表单和已有的表单数据是否有完全相同的，如果有相同的数据，那么就返回一个false，这一个表单不能被保存，如果不同，就可以保存到数据库中。
一，实现
1. 最简单粗暴的方法，遍历循环
package list.demo;

import java.io.Serializable;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 判断两个集合是否相等
 */
 public class CheckDiffList implements Serializable {
    public static void main(String[] args) {    
        List<String> list = new ArrayList<>();    
        List<String> list1 = new ArrayList<>();    
        for (int i = 0; i < 1000; i++) {        
            list.add("test" + i);        
            list1.add("test" + (i * 2));    
        }    
        System.out.println(checkDiffrent(list, list1));
    }
    
    /**
     * 方法一：使用循环遍历
     */
     private static boolean checkDiffrent(List<String> list, List<String> list1) {
        long st = System.nanoTime();
        if(list.size() != list1.size()) {
            System.out.println("消耗时间：" + (System.nanoTime() - st));
            return false;
        }
        for(String str : list) {
            if(!list1.contains(str)) {
                System.out.println("消耗时间：" + (System.nanoTime() - st));
                return false;
            }
        }
        System.out.println("消耗时间：" + (System.nanoTime() - st));
        return true;
     }
 }


返回结果为：

消耗时间为： 16657988

false

这是我想到的第一种方法，耗时较长，代码也不够简洁！
2. 使用List的retainAll方法进行比较
package list.demo;

import java.io.Serializable;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 判断两个集合是否相等
 */
 public class CheckDiffList implements Serializable {
    public static void main(String[] args) {    
        List<String> list = new ArrayList<>();    
        List<String> list1 = new ArrayList<>();    
        for (int i = 0; i < 1000; i++) {        
            list.add("test" + i);        
            list1.add("test" + (i * 2));    
        }    
        System.out.println(checkDiffrent1(list, list1));
    }
    
    /**
     * 方法2：利用List的 retainAll的方法进行判断
     */
    private static boolean checkDiffrent1(List<String> list, List<String> list1) {
        long st = System.nanoTime();
        System.out.println("消耗时间为：" + (System.nanoTime() - st));
        return !list.retainAll(list1);
    }
    
}

返回结果为：

消耗时间为：7711

false

但是这个retainAll这个方法有缺陷，如果集合A数组的大小没有改变，则返回false。如果集合A和集合B是完全相同的集合，也会返回false。两个集合没有交集，才会返回true。简单来说，判断两个集合是否有交集，有则返回false，无则返回true（这句话不严谨）。总结来说只有两个任何一个元素都不相等时才会返回true，否则返回false。那这个结果不是我想要的。
3. 利用HashMap的唯一性，把元素当做key，value可以重复。把list存到HashMap中
    我们的需求是判断两个List中的元素是否相同,那么可以这样考虑：用一个map存放list的所有元素，其中的key为list1的各个元素，value为该元素出现的次数,接着把list2的所有元素也放到map里，如果已经存在则value+1，一旦value停止+1，说明有元素不同了，返回false。否则一直遍历直至list2中所有元素，返回true。这样我们只需循环m+n次，大大减少了循环的次数。
package list.demo;

import java.io.Serializable;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 判断两个集合是否相等
 */
 public class CheckDiffList implements Serializable {
    public static void main(String[] args) {    
        List<String> list = new ArrayList<>();    
        List<String> list1 = new ArrayList<>();    
        for (int i = 0; i < 1000; i++) {        
            list.add("test" + i);        
            list1.add("test" + (i * 2));    
        }    
        System.out.println(checkDiffrent1(list, list1));
    }
    
     /** 
      * 方法3 
      * 利用HashMap key唯一，value可以重复的特点，把list中各种元素放到hashMap中 
      */
      private static boolean checkDiffrent2(List<String> list, List<String> list1) {
        long st = System.nanoTime();
        Map<String, Integer> map = new HashMap<>(list.size() + list1.size());
        if (list.size() != list1.size()) {    
            System.out.println("消耗时间为： " + (System.nanoTime() - st));    
            return false;
        }
        for (String str : list) {    
            map.put(str, 1);
        }
        for (String str : list1) {    
            Integer cc = map.get(str);    
            if (null != cc) {        
                continue;    
            }    
            System.out.println("消耗时间为： " + (System.nanoTime() - st));    
            return false;
        }
        System.out.println("消耗时间为： " + (System.nanoTime() - st));
        return true;
      }
}

结果：

消耗时间为： 4243019

false

此方法使用了HashMap中key必须唯一，但是value可以重复的原因。但是HashMap是不同步的，所以线程不安全。
4. 利用MD5加密法来判断两个集合是否相等
package list.demo;

import java.io.Serializable;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 判断两个集合是否相等
 */
 public class CheckDiffList implements Serializable {
    public static void main(String[] args) {    
        List<String> list = new ArrayList<>();    
        List<String> list1 = new ArrayList<>();    
        for (int i = 0; i < 1000; i++) {        
            list.add("test" + i);        
            list1.add("test" + (i * 2));    
        }    
        System.out.println(checkDiffrent1(list, list1));
    }
    
     /** 
      * md5加密法使用 
      * 方法4 
      */
     private static boolean getDiffrent3(List<String> list, List<String> list1) {    
        long st = System.nanoTime();  
        /** 使用Security的md5方法进行加密 */
        String str = SecureUtil.md5(list.toString());     
        String str1 = SecureUtil.md5(list1.toString());
        System.out.println("消耗时间为： " + (System.nanoTime() - st)); 
        return str.equals(str1);
    }
}

结果：

消耗时间为： 88603223

false

这个方法很新奇吧，是我没有想到的，最好不要用这种方法，如果你在实际项目中使用这种方法，被打死了，请不要找我emmm~
5. 使用Java8的新特性steam流去比较两个数组是否相等
package list.demo;

import java.io.Serializable;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 判断两个集合是否相等
 */
 public class CheckDiffList implements Serializable {
    public static void main(String[] args) {    
        List<String> list = new ArrayList<>();    
        List<String> list1 = new ArrayList<>();    
        for (int i = 0; i < 1000; i++) {        
            list.add("test" + i);        
            list1.add("test" + (i * 2));    
        }    
        System.out.println(checkDiffrent4(list, list1));
    }
    
     /** 
      * 使用stream流去比较两个数组是否相等
      * 方法5
      */
     private static boolean checkDiffrent4(List<String> list, List<String> list1) {    
        long st = System.nanoTime();  
        System.out.println("消耗时间为： " + (System.nanoTime() - st)); 
        /** 先将集合转成stream流进行排序然后转成字符串进行比较 */
        return list.stream().sorted().collect(Collectors.joining())
                        .equals(list1.stream().sorted().collect(Collectors.joining()));
       }
}

结果：

99273484

false

利用了Java8的新特性然后用collect(Collectors.joining())进行比较，虽然比较耗时，但是很好用是真的。
6. 使用list转成字符串进行比较是否相等
package list.demo;

import java.io.Serializable;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 判断两个集合是否相等
 */
 public class CheckDiffList implements Serializable {
    public static void main(String[] args) {    
        List<String> list = new ArrayList<>();    
        List<String> list1 = new ArrayList<>();    
        for (int i = 0; i < 1000; i++) {        
            list.add("test" + i);        
            list1.add("test" + (i * 2));    
        }    
        System.out.println(checkDiffrent4(list, list1));
    }
    
     /** 
      * 使用list自带的sort方法先进性排序，然后转成toString去判断两个集合是否相等
      * 方法6
      */
     private static boolean checkDiffrent5(List<String> list, List<String> list1) { 
        long st = System.nanoTime();
        System.out.println("消耗时间为： " + (System.nanoTime() - st)); 
        list.sort(Comparator.comparing(String::hashCode));  
        list1.sort(Comparator.comparing(String::hashCode)); 
        return list.toString().equals(list1.toString());
    }
}

结果：

2570

false

个人感觉先将集合转成字符串，然后进行equal(),进行判断是一个比较优秀的方法， 比起用循环编辑要简洁很多。
二，总结
    上面的六种方法的耗时时间依次是checkDiffrent5 < checkDiffrent1 < checkDiffrent2 < checkDiffrent < checkDiffrent3 < checkDiffrent4。所以最好的方法是使用list.sort()方法来进行排序，在用toString进行equal比较。

Security源代码地址：Security地址

附下我写的所有代码：
package list.demo;

import java.io.Serializable;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 判断两个集合是否相等
 */
 public class CheckDiffList implements Serializable {
    public static void main(String[] args) {    
        List<String> list = new ArrayList<>();    
        List<String> list1 = new ArrayList<>();    
        for (int i = 0; i < 1000; i++) {        
            list.add("test" + i);        
            list1.add("test" + (i * 2));    
        }    
        System.out.println(checkDiffrent(list, list1));
    }
    
    /**
     * 方法一：使用循环遍历
     */
     private static boolean checkDiffrent(List<String> list, List<String> list1) {
        long st = System.nanoTime();
        if(list.size() != list1.size()) {
            System.out.println("消耗时间：" + (System.nanoTime() - st));
            return false;
        }
        for(String str : list) {
            if(!list1.contains(str)) {
                System.out.println("消耗时间：" + (System.nanoTime() - st));
                return false;
            }
        }
        System.out.println("消耗时间：" + (System.nanoTime() - st));
        return true;
     }
     
      /**
     * 方法2：利用List的 retainAll的方法进行判断
     */
    private static boolean checkDiffrent1(List<String> list, List<String> list1) {
        long st = System.nanoTime();
        System.out.println("消耗时间为：" + (System.nanoTime() - st));
        return !list.retainAll(list1);
    }
    
    /** 
      * 方法3 
      * 利用HashMap key唯一，value可以重复的特点，把list中各种元素放到hashMap中 
      */
      private static boolean checkDiffrent2(List<String> list, List<String> list1) {
        long st = System.nanoTime();
        Map<String, Integer> map = new HashMap<>(list.size() + list1.size());
        if (list.size() != list1.size()) {    
            System.out.println("消耗时间为： " + (System.nanoTime() - st));    
            return false;
        }
        for (String str : list) {    
            map.put(str, 1);
        }
        for (String str : list1) {    
            Integer cc = map.get(str);    
            if (null != cc) {        
                continue;    
            }    
            System.out.println("消耗时间为： " + (System.nanoTime() - st));    
            return false;
        }
        System.out.println("消耗时间为： " + (System.nanoTime() - st));
        return true;
      }
      
       /** 
      * md5加密法使用 
      * 方法4 
      */
     private static boolean getDiffrent3(List<String> list, List<String> list1) {    
        long st = System.nanoTime();  
        /** 使用Security的md5方法进行加密 */
        String str = SecureUtil.md5(list.toString());     
        String str1 = SecureUtil.md5(list1.toString());
        System.out.println("消耗时间为： " + (System.nanoTime() - st)); 
        return str.equals(str1);
    }
    
    /** 
      * 使用stream流去比较两个数组是否相等
      * 方法5
      */
     private static boolean checkDiffrent4(List<String> list, List<String> list1) {    
        long st = System.nanoTime();  
        System.out.println("消耗时间为： " + (System.nanoTime() - st)); 
        /** 先将集合转成stream流进行排序然后转成字符串进行比较 */
        return list.stream().sorted().collect(Collectors.joining())
                        .equals(list1.stream().sorted().collect(Collectors.joining()));
       }
       
       /** 
      * 使用list自带的sort方法先进性排序，然后转成toString去判断两个集合是否相等
      * 方法6
      */
     private static boolean checkDiffrent5(List<String> list, List<String> list1) { 
        long st = System.nanoTime();
        System.out.println("消耗时间为： " + (System.nanoTime() - st)); 
        list.sort(Comparator.comparing(String::hashCode));  
        list1.sort(Comparator.comparing(String::hashCode)); 
        return list.toString().equals(list1.toString());
    }
 }

public static void main(String[] args){
    List<String> list1 = new ArrayList<String>();
    list1.add("A");
    list1.add("C");
    list1.add("D");
    String str1 = getListId(list1);
    System.out.println(str1);
    
    List<String> list2 = new ArrayList<String>();
    list2.add("A");
    list2.add("D");
    list2.add("C");
    String str2 = getListId(list2);
    System.out.println(str2);
    
    boolean flag = str1.equals(str1);
    System.out.println(flag);
}

private static String getListId(List<String> list){
    StringBuffer listBuf = new StringBuffer();
    if(list != null){
    	// 对作为参数的list进行排序
    	// 使得参与比较的list集合都有相同的排序规则
        Collections.sort(list);
        listBuf.append(list.toString());
    }
    return listBuf.toString();
}

输出结果：
[A, C, D]

[A, C, D]

true

                    
首先记住两句话
相等的两个对象,即equals(Object)方法判断两个对象相等,那么他们必须要有相同的hashcode
hashcode相同的两个对象,他们可能相同,也可能不相同
简单地说可以这么理解,hashcode是java实现中经常用到的比如在HashMap HashSet,根据hashcode不等就可以断定两个对象不等,如果相等再去比较equals,大大减少了equals的调用次数,效率就高很多了
原理搜一下有很多文章,不再多说
重点说一下应用,大家或许看到很多地方说:
重写equals方法要同步重写hashcode,具体的怎么写却不知道
接下来就主要说一下,具体的怎么实现(小白围观,老鸟勿扰)
其实开场的两句话也是这个意思
场景:
当你需要实现你自己的对象上的逻辑相等时,需要重写equals方法
比如一个学生类
name,age,sex,class…等多重属性
假设就是public student{   //这么一个类
name
age
sex
class
}
(简写一下,不要较真…)
 
用自然语言说的话,就是姓名,性别,年龄,班级一样,在这个类上的话,我们就可以认为两个对象是相等的了
对吧
换成java语言就是

public boolean equals(Object obj) {

if (obj instanceof Student) {   
            Student student= (Student ) obj;   
                        if(this.name.equals(student.name) && this.age.equals(student.age)

                     &&this.sex.equals(student.sex)&&this.class.equals(student.class)        ){
                
                return true;
            }
            else{
                return false;
            }  
        //非该类实例,直接返回false
        } else{
            
            return false;
        }

}


很简单,比较相等,至少得是学生..不是直接返回false
如果是学生实例,就比较一下,姓名年龄性别班级,都相等了就是相等了
 
怎么保障重写equals方法后,这两个对象实例的hashcode也是一样的呢?
所有的hashcode都返回一样的值?答案是可以的在某些情况下,但是某些情况下你就要悲剧了,所以当然不要
常用的办法是用:判断相等的条件  用到的属性  来重写
直白点就是:利用刚才使用到的姓名 性别 年龄 班级 这几个属性的值来重写hashcode
使用它们的组合方式
可以使用这样子的形式
a1*属性1的int形式+a2 属性2的int形式+….
a为系数
所谓属性的int形式,大家要知道hashcode都是数值
这样子才能保障最后的结果也是一个int值,简单就这么理解吧
而且还有就是比如string已经有了他自己的hashcode实现了,可以直接调用的
比如我们的例子
我们可以这样子
 
 

public int hashCode() {
    // TODO Auto-generated method stub
    //根据判断是否相等的属性,来重写hashCode
     return ( this.name.hashCode() + this.sex.hashCode()+age+this.class.hashcode() );

}

系数可以随便,你甚至都可以用this.name.hashCode() *age
形式上可以变化多端
但是要注意几个条件就好了
1,相同的对象的hashcode肯定是相同的
2,最后生成的结果不能大于int的取值范围
3,尽可能的科学保证不是随随便便的一个对象hashcode都相等
 
友情提示:
[1]. HashSet判断、删除和添加元素等操作依据的是被操作元素所在的类的hashCode()和equals( )这两个方法。
[2]. ArrayList做同等的操作，依据的仅仅是equals( )方法