Set的子类HashSet的全面说明

特点

1. HashSet实现了Set接口
2. HashSet实际上是HashMap
3. 可以存放null值，但是只能有一个null值
4. HashSet不保证存放元素顺序和取出顺序一致
5. 不能有重复元素

HashSet底层机制

1. 底层是HashMap，HashMap底层是(数组+链表+红黑树)
2. 添加一个元素时，先得到hash值，然后把它转成索引值
3. 然后找到存储数据表table，看这个索引位置是否已经存放元素
4. 如果没有，直接加入
5. 如果有，调用equals方法对准备加入元素和已有元素进行比较，如果相同，则放弃添加，如果不相同，则添加至最后
6. 在Java8中，如果一条链表的元素个数达到TREEIFY_THRESHOLD(默认为8)，并且table的大小>=MIN_TREEIFY_CAPACITY(默认64)，就会进行树化

package aggregate.setClass;

import java.util.HashSet;

public class HashSetSource {
    public static void main(String[] args) {
        HashSet set = new HashSet();
        set.add("java");
        set.add("php");
        set.add("java");
        System.out.println(set);

        /*
         //1.执行HashSet

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


        //2.执行add方法

            public boolean add(E e) {
                return map.put(e, PRESENT)==null;
        }


        //3.执行put方法

            public V put(K key, V value) {  //value = PRESENT
            return putVal(hash(key), key, value, false, true);
        }


        //4.执行put中的hash方法，得到hash值

             static final int hash(Object key) {
            int h;
            return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
        }



        //5.继续执行put方法
               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 ((tab = table) == null || (n = tab.length) == 0)     //table就是HashMap的一个数组，类型为Node
                n = (tab = resize()).length;            //第一次扩容，为table赋值16
            if ((p = tab[i = (n - 1) & hash]) == null)      //根据key得到hash，去计算该key应该存放到table表的哪个索引，并将该值赋给p
                tab[i] = newNode(hash, key, value, null);       //如果p ==null，则将新增节点newNode赋给tab[i]
            else {
                Node<K,V> e; K k;
                //如果当前索引位置对应的tab[i]不为空，且第一个元素的hash值与准备添加的元素hash值一样
                //并且满足以下两个条件之一：
                //(1)准备加入的key和p指向的Node节点的key是同一个对象
                //(2)p指向的Node节点的key调用equals()方法和准备加入的key比较后相同
                //则不能加入这个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);

                //如果tab索引位置已经是一个链表，就使用for循环比较
                else {
                //依次与该链表的每一个值比较，若都不相同，则加入该链表最后
                //在把元素添加到链表之后，立即判断该链表是否已经达到8个节点
                //  1.若已经达到8个节点，则再判断该tab数组是否已经达到转成红黑树最小容量，即64
                //  2.若没达到，则进行扩容，若已达到，则调用treeifyBin，对当前链表进行树化
                //若有相同则break
                    for (int binCount = 0; ; ++binCount) {
                        //判断p.next是否为空，将元素加入尾部
                        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;
            //每加入一个节点Node(k,v,h,next)，size就会+1，所以当加入的元素到达临界值threshold时，就会扩容
            if (++size > threshold)
                resize();
            afterNodeInsertion(evict);
            return null;
        }
         */
    }
}