java集合之Set篇——HashSet、LinkedHashSet、TreeSet的底层源码解析_hashset linkedhashset treeset底层结构-优快云博客

public class HashSet_Type {
    public static void main(String[] args) {
        HashSet<String> hashSet = new HashSet<>();
        hashSet.add("java");
        hashSet.add("php");
        hashSet.add("java");
        System.out.println(hashSet);//[java, php]
    }
}

为什么上面的代码最后的“java”没有加入到集合里面呢？数据怎么插入的？

public class HashSetType {
    public static void main(String[] args) {
        HashSet<A> hashSet = new HashSet<>();
        for (int i = 0; i < 13; i++) {
            hashSet.add(new A(i));
        }
        System.out.println(hashSet);

    }

}
class A {
    int a;
    public A(int a) {
        this.a = a;
    }

    @Override
    public int hashCode() {
        return 1000;
    }
}

加入那么多条数据，hashSet里面的是怎么存储的，结构什么样？

2.先看结论

（1）插入数据机制

A. 先获取元素的哈希值（hashCode方法)

B. 对哈希值进行运算，得出一个索引值即为要存放在哈希表中的位置号

C. 如果该位置上没有其他元素，则直接存放如果该位置上已经有其他元素，则需要进行equals判断，如果相等，则不再添加。如果不相等则以链表的方式添加。

注意：这里的equals方法是每一个类都可以重写的，可以由程序员自己指定一定的规则判断。

String 方法的equals方法是java内置写好的，比较字符串的内容。

（2）扩容机制

A. HashSet底层是HashMap，第一次添加时，table数组扩容到16，临界值（threshold）是16*加载因子（loadFactor）是0.75=12

B. 如果table数组使用到了临界值12，就会扩容到16*2=32，新的临界值就是32*0.75=24，依次类推

C. 在Java8中，如果一条链表的元素个数到达TREEIFYTHRESHOLD（默认是8）并且table的大小>=MINTREEIFYCAPACITY（默认64），就会进行树化（红黑树），否则仍然采用数组扩容机制

3.两个重要方法

(1)putVal(hash,key,value,false,true)

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[]
        //if语句表示如果当前table是null，或者大小=0
        //就是第一次扩容（默认扩容），到16个空间
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        //(1)用数据对象key的哈希值hash去计算该key应该存放到table表的哪个索引位置
        //并把这个位置的对象table[i]，赋给p
        //(2)判断p是否为nuLL
        //(2.1)如果p为nuLL，表示还没有存放元素，就创建一个Node（hash,key="java"，vaLue=PRESENT,next=null）
        //(2.2)否则后面判断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;
            //满足下面两个条件之一：
            //（1）准备加入的key和p指向的Node结点的key是同一个对象
            //（2）p指向的Node结点的key的equaLs（）和准备加入的key比较后相同
            //就不能加入（即if条件成立）
            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 {
            //最后一种情况就是p是链表了，使用for循环比较
            //（1）依次和该链表的每一个元素比较后，都不相同，则加入到该链表的最后
            //    注意在把元素添加到链表后，立即判断该链表是否已经达到8个结点
            //    ，就调用treeifyBin（）对当前这个链表进行树化（转成红黑树）
            //    注意，在转成红黑树时，要进行判断，判断条件
            //    if (tab == nuLl || (n =tab.length)<MIN_TREEIFY_CAPACITY(64))
            //        resize();数组扩容的方法
            //    如果上面条件成立，先table扩容。
            //    只有上面条件不成立时，才进行转成红黑树
            //（2）依次和该链表的每一个元素比较过程中，如果有相同情况，就直接break
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // 判断该哈希桶是否到达8个
                            treeifyBin(tab, hash);//树化
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            //处理出现相同数据对象的逻辑
            //返回的东西不是null，代表添加数据失败
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;