Set集合的不重复性是怎么做到的（Set集合的不重复原理）

因为当我们向Set集合加入数据时，要加入的数据会和集合里的数据比较

会先比较hashCode()的值，如果不同那么jvm就会认为这是两个不同的数据就会直接加入，

而如果hashCode()的值相同，jvm会调用equals()来比较，如果相同就认为是一个数据，否则就是两个数据。（当hashCode()的值不同时就不会继续调用equals()了）

Set集合是一个无序的不可以重复的集合。

Set是一个接口，最常用的实现类就是HashSet，今天我们就拿HashSet为例。

HashSet的底层实现是HashMap ---> （HashSet的值不可重复；而HashMap中key不可以重复，值可以重复。从这一点推测的话，HashSet的底层实现是HashMap是可以理解的）

private transient HashMap map;
 // 用来匹配Map中后面的对象的一个虚拟值
private static final Object PRESENT = new Object();

HashSet如何检查重复？ ：hashCode()和equals(): //相同的对象必须hashCode()相同并且equals()返回true，但hashCode()相同的对象不一定相同。

必须覆盖hashCode()和equals(): hashCode()的默认行为是对在heap上的对象产生独特的值，如果没有override过hashCode()，则该class的两个对象怎样都不会被认为是相同的。

（1）先来看看 HashSet 的几个构造方法

Copy// 默认构造函数 底层创建一个HashMap
    public HashSet() {
        // 调用HashMap的默认构造函数，创建map
        map = new HashMap();
    }

    // 带集合的构造函数
    public HashSet(Collection c) {
        // 创建map。
        map = new HashMap(Math.max((int) (c.size()/.75f) + 1, 16));
        // 将集合(c)中的全部元素添加到HashSet中
        addAll(c);
    }

    // 指定HashSet初始容量和加载因子的构造函数
    public HashSet(int initialCapacity, float loadFactor) {
        map = new HashMap(initialCapacity, loadFactor);
    }

    // 指定HashSet初始容量的构造函数
    public HashSet(int initialCapacity) {
        map = new HashMap(initialCapacity);
    }

    HashSet(int initialCapacity, float loadFactor, boolean dummy) {
        map = new LinkedHashMap(initialCapacity, loadFactor);
    }

（2）HashSet 中的声明

Copyprivate transient HashMap map;

private static final Object PRESENT = new Object(); // 用来匹配Map中后面的对象的一个虚拟值

（3）HashSet的add（）方法

将元素e添加到HashSet中，也就是将元素e作为Key放入HashMap中

    /**
     * 将元素e添加到HashSet中，也就是将元素e作为Key放入HashMap中
     *
     * @param e 要添加到HashSet中的元素
     * @return true 如果不包含该元素
     */
    public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }

（4）可以看出HashSet的add()方法又调用了HashMap中的put()方法，那我们再跳转到HashMap中的put()方法

//HashSet的add()方法又调用了HashMap中的put()方法
    public V put(K key, V value) {
        // 倒数第二个参数false：表示允许旧值替换
        // 最后一个参数true：表示HashMap不处于创建模式
        return putVal(hash(key), key, value, false, true);
    }

（5）HashMap中的put()方法又调用了putVal()方法来实现功能，再看putVal()的源码。

    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node[] tab;
        Node p;
        int n, i;
        //如果哈希表为空，调用resize()创建一个哈希表，并用变量n记录哈希表长度
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        /**
         * 如果指定参数hash在表中没有对应的桶，即为没有碰撞
         * Hash函数，(n - 1) & hash 计算key将被放置的槽位
         * (n - 1) & hash 本质上是hash % n，位运算更快
         */
        if ((p = tab[i = (n - 1) & hash]) == null)
            //直接将键值对插入到map中即可
            tab[i] = newNode(hash, key, value, null);
        else {// 桶中已经存在元素
            Node e;
            K k;
            // 比较桶中第一个元素(数组中的结点)的hash值相等，key相等
            if (p.hash == hash &&
                    ((k = p.key) == key || (key != null && key.equals(k))))
                // 将第一个元素赋值给e，用e来记录
                e = p;
                // 当前桶中无该键值对，且桶是红黑树结构，按照红黑树结构插入
            else if (p instanceof TreeNode)
                e = ((TreeNode) p).putTreeVal(this, tab, hash, key, value);
                // 当前桶中无该键值对，且桶是链表结构，按照链表结构插入到尾部
            else {
                for (int binCount = 0; ; ++binCount) {
                    // 遍历到链表尾部
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        // 检查链表长度是否达到阈值，达到将该槽位节点组织形式转为红黑树
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    // 链表节点的与put操作相同时，不做重复操作，跳出循环
                    if (e.hash == hash &&
                            ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            // 找到或新建一个key和hashCode与插入元素相等的键值对，进行put操作
            if (e != null) { // existing mapping for key
                // 记录e的value
                V oldValue = e.value;
                /**
                 * onlyIfAbsent为false或旧值为null时，允许替换旧值
                 * 否则无需替换
                 */
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                // 访问后回调
                afterNodeAccess(e);
                // 返回旧值
                return oldValue;
            }
        }
        // 更新结构化修改信息
        ++modCount;
        // 键值对数目超过阈值时，进行rehash
        if (++size > threshold)
            resize();
        // 插入后回调
        afterNodeInsertion(evict);
        return null;
    }

从源码中，我们可以看出将一个key-value对放入HashMap中时

首先根据key的hashCode()返回值决定该Entry的存储位置，如果两个key的hash值相同，那么它们的存储位置相同。如果这个两个key的equals比较返回true。那么新添加的Entry的value会覆盖原来的Entry的value，key不会覆盖。且HashSet中add()中 map.put(e, PRESENT)==null 为false，HashSet添加元素失败。因此,如果向HashSet中添加一个已经存在的元素，新添加的集合元素不会覆盖原来已有的集合元素。
看hashmap的put 方法的返回值，map对象在调用put的时候传入一个key和val，会对其key进行一个算法得到一个位置，会把put的数据放到其位置上，如果该位置上已经存在当前key，会对其key映射的val给替换掉，并且返回之前的val，否则返回null。
好了，既然put的返回值原理搞清楚了，就要去看看 set 的add方法的实现，add方法是调用了put方法，并且把key放在了put的key上，val放了一个hashset类的静态常量present：
- 如果put 返回的是null，不是present，就说明 put的key是不存在的，add也会返回true
- 如果put返回的是present，就说明之前的key是存在的，并不是说没有put上，所以add方法返回的false并不是存失败的意思，而是map.put的key是已经存在的，而且已经把val给替换了。

Java-集合-HashSet-(2)源码分析

Java-集合-HashSet-(1)不重复性原理