Set接口实现类—HashSet

 Hashset概述

1.  Hashset实现了Set接口
2.  Hashset实际上是HashMap，看源码

    public HashSet() {
           map = new HashMap<>();
       }

3. 可以存放 null 值，但只能有一个
4. Hashset不保证元素是有序的，取决于hash后，再确定索引的结构。（即，不保证存放元素的顺序和取出一致）
5. 不能有重复元素/对象。

 HashSet扩容机制

1. HashSet 底层是HashMap，第一次添加时，table数组扩容到 16，临界值（threshold）是16*加载因子（loadFactor）是0.75 = 12
2. 添加一个元素时，先得到hash值，转换为索引值
3. 找到存储数据表的table，看这个索引位置是否已经存放有元素
4. 如果没有，直接加入
5. 如果有，调用 equals 方法比较，如果相同，就放弃添加，如果不相同，则添加到最后。     注意：这里的 equals 方法不能单纯的认为是比较内容，是由程序员决定的，可以进行方法重写。
6. 如果table数组使用到了临界值 12，就会扩容到16*2 = 32，新的临界值就是32*0.75 = 24，依次类推。
7. 在JAVA8中，如果一条链表的元素个数到达 TREEIFY_THRESHOLD（默认是8），并且table大小大于等于 MIN_TREEIFY_CAPACITY（默认是64），就会进行树化（红黑树），否则仍然采用数组扩容机制。

举例进行源码分析

public class HashSetSource {
    public static void main(String[] args) {
        HashSet hashSet = new HashSet();
        hashSet.add("java");
        hashSet.add("php");
        hashSet.add("java");
        System.out.println("hashset: "+hashSet); //hashset: [java, php]

        /*
        HashSet 源码解读
          1、执行HashSet()
          源码：public HashSet(){
                 map = new HashMap<>();
               }

          2、 执行add()
            public boolean add(E e) { // e="java"
            return map.put(e, PRESENT)==null; //PRESENT没什么意义，表示占位的意思
            }

          3、 执行put(), 该方法会执行hash(key)方法 得到key对应的hash值  算法：(h = key.hashCode()) ^ (h >>> 16)
              public V put(K key, V value) { //key="java"  value= PRESENT (始终都是)
            return putVal(hash(key), key, value, false, true);
            }

          4、 执行 putVal
              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的一个数组，类型是 Nodep[]
               // if 语句表示如果当前table 是null，或者大小=0，就是第一次扩容，扩容到16个空间
               if ((tab = table) == null || (n = tab.length) == 0)
               n = (tab = resize()).length;
               // 根据key，得到hash，去计算key应该存放到table表的哪个索引位置 i，并把这个位置的对象赋给变量 p
               // 判断 p 是否为null
               // 如果是null，表示索引 i 这个位置还没有存放元素，就创建一个Node (key="java",value=PRESENT)
               // 就放在该位置  table[i] = newNode(hash, key, value, null);
               if ((p = tab[i = (n - 1) & hash]) == null)
               tab[i] = newNode(hash, key, value, null);
               else
             {
                  Node<K,V> e; K k;
                  //如果当前索引位置对应的链表的第一个元素和准备添加的key的hash值一样
                  //并且满足下面两个条件之一：
                  // 1、准备加入的 key 和 p 指向的Node结点的 key 是同一个对象
                  // 2、p指向的Node结点的 key 的equals() 和准备加入的key比较后是相同的
                  // 就不能加入
                  if (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))
                      e = p;
                  //判断 p 是不是一个红黑树，如果是一颗红黑树，就调用 putTreeVal ，来进行添加
                  else if (p instanceof TreeNode)
                      e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
                  else
                 { // 如果table对应索引位置，已经是一个链表，就使用for循环来进行比较
                   // 依次和该链表的每一个元素比较后，都不相同，则加入到该链表的最后
                   // 注意：在把元素添加到链表后，立即判断：该链表是否已经达到8个结点
                   //      是的话，就调用treeifyBin() 对当前这个链表进行树化(转成红黑树)
                   // 注意：在转成红黑树时，要进行判断，判断条件：
                   //  if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
                   //       resize();
                   // 如果上面条件成立，先对数组table进行扩容
                   // 只有上面条件不成立时，才进行转成红黑树
                   // 依次和该链表的每一个元素比较过程中，如果有相同情况，就直接break
                    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;
                       }
                      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) //每加入一个结点Node，size就会加一， size > 12 就进行扩容
            resize(); //扩容方法
        afterNodeInsertion(evict); //空方法
        return null; //返回null，代表成功了
    }

         */


    }
}