4.HashSet

说HashSet就是说HashMap。

1.简介

• HashSet 基于 HashMap 来实现的:table数组+链表(table 是 HashMap$Node[] 类型,存储的也是 HashMap$Node节点)，是一个不允许有重复元素的集合。
• HashSet 允许有 null 值，只能有一个（不重复）。
• HashSet 是无序的，即不会记录插入的顺序。
• HashSet 不是线程安全的， 如果多个线程尝试同时修改 HashSet，则最终结果是不确定的。 您必须在多线程访问时显式同步对 HashSet 的并发访问。 

2.构造器

static final long serialVersionUID = -5024744406713321676L;  
  
    // 底层使用HashMap来保存HashSet中所有元素。  
    private transient HashMap<E,Object> map;  
      
    // 定义一个虚拟的Object对象作为HashMap的value，将此对象定义为static final。  
    private static final Object PRESENT = new Object();  
  
    /** 
     * 默认的无参构造器，构造一个空的HashSet。 
     *  
     * 实际底层会初始化一个空的HashMap，并使用默认初始容量为16和加载因子0.75。 
     */  
    public HashSet() {  
    map = new HashMap<E,Object>();  
    }  
  
    /** 
     * 构造一个包含指定collection中的元素的新set。 
     * 
     * 实际底层使用默认的加载因子0.75和足以包含指定 
     * collection中所有元素的初始容量来创建一个HashMap。 
     * @param c 其中的元素将存放在此set中的collection。 
     */  
    public HashSet(Collection<? extends E> c) {  
    map = new HashMap<E,Object>(Math.max((int) (c.size()/.75f) + 1, 16));  
    addAll(c);  
    }  
  
    /** 
     * 以指定的initialCapacity和loadFactor构造一个空的HashSet。 
     * 
     * 实际底层以相应的参数构造一个空的HashMap。 
     * @param initialCapacity 初始容量。 
     * @param loadFactor 加载因子。 
     */  
    public HashSet(int initialCapacity, float loadFactor) {  
    map = new HashMap<E,Object>(initialCapacity, loadFactor);  
    }  
  
    /** 
     * 以指定的initialCapacity构造一个空的HashSet。 
     * 
     * 实际底层以相应的参数及加载因子loadFactor为0.75构造一个空的HashMap。 
     * @param initialCapacity 初始容量。 
     */  
    public HashSet(int initialCapacity) {  
    map = new HashMap<E,Object>(initialCapacity);  
    }  
  
    /** 
     * 以指定的initialCapacity和loadFactor构造一个新的空链接哈希集合。 
     * 此构造函数为包访问权限，不对外公开，实际只是是对LinkedHashSet的支持。 
     * 
     * 实际底层会以指定的参数构造一个空LinkedHashMap实例来实现。 
     * @param initialCapacity 初始容量。 
     * @param loadFactor 加载因子。 
     * @param dummy 标记。 
     */  
    HashSet(int initialCapacity, float loadFactor, boolean dummy) {  
    map = new LinkedHashMap<E,Object>(initialCapacity, loadFactor);  
    } 

3.添加机制

（1）添加流程：先hash 再eaqual

• 首先得到该元素的hash值 并将hash值转换为索引值（hash 不是hashcode）
• 找到存储数据表table，看这个索引值的位置是否为空
• 如果为空 直接加入
• 如果有元素，就用eaquls对其挂载的链表 逐个比较，若相同就放弃添加，若不同添加到最后
• 在JAVA8中，首先table表》=64 其次挂载链表长度》8，就会就行红黑树化

（2）代码详解

    //1.执行add()
     public boolean add(E e) {e:存入的元素
        return map.put(e, PRESENT)==null;
    }
    //2.执行put()
     public V put(K key, V value) { 
        return putVal(hash(key), key, value, false, true);
    }
    // 3. 算出hash值
     static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);  //与右移后的h异或
    }
    //4.执行
     final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;  //定义辅助变量
        //table就是HashMap的一个数组，类型是Node[]
        //如果table 为null 或大小为0  则扩容
        if ((tab = table) == null || (n = tab.length) == 0)
        //resize()里利用负载因子0.75 计算新的tab大小
            n = (tab = resize()).length;
        //i 是 该元素的索引 P是 table[i]
        if ((p = tab[i = (n - 1) & hash]) == null)  //如果当前位置为空
            tab[i] = newNode(hash, key, value, null);  //创建并放入该位置
        else {          //如果当前位置不为空
            Node<K,V> e; K k;
            //先比较算出当前位置对应元素的hash与待加入元素hash是否相等
            //准备加入的元素和P指向的node节点的元素是一个对象
            //或者不是一个对象但内容相同
            if (p.hash == hash &&  
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            //在判断 P是不是红黑树
            //如果是 就调用 红黑树对应的添加方法
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)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);
                        //判断链表到达8个了没
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            //树化
                            //注意 在树华时 要先就行判断
                            //if ((tab = table) == null || (n = tab.length) == 0)
                            // n = (tab = resize()).length;
                            //上面条件成立 先扩容 不成立 才树化
                            treeifyBin(tab, hash);
                        break;
                    }
                    //有相同的 直接break 放弃添加
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

 （3）注意事项

key:存入的元素 value: PRESENT 占位置用的(因为Map存放的是键值对 而Set 只有key)

hashCode （）与 equals （）的相关规定 ：

1. 如果两个对象相等，则 hashcode 一定也是相同的

hashCode 是 jdk 根据对象的地址或者字符串或者数字算出来的 int 类型的数值

2. 两个对象相等 , 对两个 equals 方法返回 true

3. 两个对象有相同的 hashcode 值，它们也不一定是相等的

4. 综上， equals 方法被覆盖过，则 hashCode 方法也必须被覆盖

5. hashCode() 的默认行为是对堆上的对象产生独特值。如果没有重写 hashCode() ，则该 class 的两个

对象无论如何都不会相等（即使这两个对象指向相同的数据）。

== 与 equals 的区别

1. == 是判断两个变量或实例是不是指向同一个内存空间 equals 是判断两个变量或实例所指向的内存

空间的值是不是相同

2. == 是指对内存地址进行比较 equals() 是对字符串的内容进行比较

4.扩容机制 

• 第一次添加时，table数组扩容到16，临界值(threshold)=16×0.75(负载因子loadFactor)=12
• 如果table的size达到12，就会二倍扩容扩容到16×2=32, 新的临界值=32×0.75=24,以此类推。
• 扩展后 Node 对象的位置要么在原位置，要么移动到原偏移量两倍的位置。

注：每次加入一个元素 table的size就会++，不一定非要占用数组的个数达到临界值才扩容。即挂载在链表上的元素+数组里的元素到达临界值就扩容。