private static final Object PRESENT = new Object();

 //执行构造器
         public HashSet() {
                map = new HashMap<>();
           }

        //  第一次add方法的执行过程：
         //   2.add方法 ：调用map的put方法 PRESENT：静态的一个Object对象 用于占位，每一个map的value都是用一个对象
         *         public boolean add(E e) {
         *         return map.put(e, PRESENT)==null; //如果return null的时候就代表执行成功了
         *     }
         *     // 调用hash方法获取到key的hash值
         *     3.  public V put(K key, V value) {
         *         return putVal(hash(key), key, value, false, true);
         *     }
         *     // 通过hash算法获取的key的hash值 此hash值并不等于key原本的hash值
         *         static final int hash(Object key) {
         *         int h;
         *         return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
         *     }
         *
         *     4.得出hash值后 然后去putValue方法判断是否应该把这个值添加进去

         *      final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
         *                    boolean evict) {
         *         Node<K,V>[] tab; Node<K,V> p; int n, i; //定义辅助变量，建议我们在开发的时候，需要用的时候再进行定义临时变量
         *         // 第一次进来 if成立，调用resize()
         *         if ((tab = table) == null || (n = tab.length) == 0) //table 其实就是HashMap里面的那个Node数组[] 存放链表的那个数组
         *             n = (tab = resize()).length;  //resize())执行完后，返回一个初始化容量为16的table[]数组
         *
         *             // 通过key的hash值计算出元素应该存放到table数组的那个索引位置
         *             //并把这个位置的对象赋值给临时变量p，判断p是否为null
         *             //如果p为空，代表这个位置还没有存放过元素，就创建一个node对象，key和value都放进去，next为null，留给第后来添加的元素存放Node对象
         *         if ((p = tab[i = (n - 1) & hash]) == null)
         *             tab[i] = newNode(hash, key, value, null);
         *         else {
         *             Node<K,V> e; K k;
         *             if (p.hash == hash &&
         *                 ((k = p.key) == key || (key != null && key.equals(k))))
         *                 e = 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);
         *                         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) //判断当前这个table数组是否超过了12这个最大容量值，如果超过进行扩容
         *             resize();
         *             // 这个方法其实是一个空方法，是留给子类去实现的
         *         afterNodeInsertion(evict);
         *         return null; //程序走到这儿，就代表我们第一次添加的元素已经成功了
         *     }

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                boolean evict) {
     Node<K,V>[] tab; Node<K,V> p; int n, i;
     //只有第一次add的时候才会执行这个 if
     if ((tab = table) == null || (n = tab.length) == 0)
         n = (tab = resize()).length;
         // 此时这个 方法为false 因为这次添加的元素是我们上次已经添加过的元素，所以算出来的下标1肯定是和上一次算出的下标一致
         // 判断这个数组的下标位置中是否已经有链表元素存在
     if ((p = tab[i = (n - 1) & hash]) == null)
         tab[i] = newNode(hash, key, value, null);
     else {
     //添加重复值的时候执行：
         Node<K,V> e; K k;
         // 此时的这个p就是指向的上面算出来的数组下标里的那个Node对象
         //如果当前索引位置对应的链表的第一个元素和准备添加的这个key的hash值hash值相同
         if (p.hash == hash &&
         //如果hash值相同的情况下 当前准备要加入的key和刚刚计算出来的数组下标对应的那个Node对象的key是同一个对象 或者
         // 当前的这个key不为null然后在和计算出来的那个数组下标对应的那个Node对象里的key进行equals比较，
         //如果没有重写那么调用的就是继承自Object的equals方法，如果重写过，那么就调用重写后的，hashcode方法也是一样，所以建议两个方法都重写

             ((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 {
         // 假如不是红黑树，那就是第三种情况：按照上面第一个情况的方式依次和整个链表进行比较，如果找到条件满足的那就直接break（此元素已经存在）；
         // 结束遍历，return oldValue 那么就代表着添加失败，如果说，比较完后都没有满足条件的（该元素不存在），那就挂载到这个链表的末尾

         // 在把元素添加到最后，立即判断 该链表是否已经到达8个节点，如果到达，调用treeifyBin(tab, hash);方法把当前这个链表转化为红黑树
         判断条件如下：   if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)   resize();
 // 上面条件不成立才进行树化 再进行转红黑树时还进行判断这个数组链表的值是否大于64，如果小于64，还不会转化为红黑树，而是进行数组的扩容，大于64再转红黑树
             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;
                 }
                 // 如果 比的过程中找到一个值与准备添加的元素的值一致，那么就直接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;