LinkedHashset底层源码分析

LinkedHashset底层源码分析

1.测试代码:

package com.heyuanhang.conllention_;

import java.util.*;

/**
 * @Author 何远航
 * @Date: 2021/4/20 11:04
 * @Version 1.8
 */
public class LinkedHashSetSource {
    public static void main(String[] args) {
        LinkedHashSet linkedHashSet = new LinkedHashSet();
        linkedHashSet.add("heyuanhang");
        linkedHashSet.add("heyu");
        System.out.println(linkedHashSet);
    }
}

(1)LinkedHashSet linkedHashSet = new LinkedHashSet()执行LinkedHashSet的无参构造时做了一些什么？

不妨debug看一下:

a.调用父类的有参构造

public LinkedHashSet() {
        super(16, .75f, true);
    }

b.进入其父类的构造方法

 HashSet(int initialCapacity, float loadFactor, boolean dummy) {
        map = new LinkedHashMap<>(initialCapacity, loadFactor);
    }

由这儿可以看出来，原来LikedHashSet底层相当于LikedHashMap

c.进入LinkedHashMap的构造方法

public LinkedHashMap(int initialCapacity, float loadFactor) {
        super(initialCapacity, loadFactor);
        accessOrder = false;
    }

d.进入其父类HashMap的构造方法

public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);
         //类加载因子,初始化为0.75
        this.loadFactor = loadFactor;
        //控制数组table容量的临界值，当超过这个临界值后就进行2倍扩容
        this.threshold = tableSizeFor(initialCapacity);
    }

经过上述源码的追踪，终于知道了执行LinkedHashSet linkedHashSet = new LinkedHashSet()后，初始化了加载因子以及初始化了table的容量的临界值为16，同时HashMap底层维护的table默认为空。

（2）向LinkedHashSet中添加数据即执行linkedHashSet.add("heyuanhang");进入add方法：

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

这儿的方法的执行流程在，关于HashSet的底层源码分析中有这个方法的详细讲解

（3）这儿看一下put方法:

public V put(K key, V value) {
      /*
      hash方法是根据key的hashCode值按照一定的算法得到
      一个hash值，用于计算出key要插入table的位置
      */
        return putVal(hash(key), key, value, false, true);
    }

（4）进入hash方法

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

（5）进入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;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        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)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

（关于上述方法的详解请点击进入）
关于上述的方法只需要强调的是newNode方法，在向LinkedHashSet中添加元素时，就是在这儿添加的，值得注意的是table存放的数据是HashMap$Node类型的，但是在LinkedHashSet中的table中存放的是HashMap$Entry类型的元素。这是为什么？

看源码:

 static class Entry<K,V> extends HashMap.Node<K,V> {
        Entry<K,V> before, after;
        Entry(int hash, K key, V value, Node<K,V> next) {
            super(hash, key, value, next);
        }
    }

原来LinkedHashSet底层是一个数组(table)加上双向链表,而链表结点正是Entry<K,V>类型的,在添加第一个元素时也就是存入到链表结点中，这个Entry<K,V>继承了Node，因此Node类型的数组中，当然可以存放链表结点，这也体现了多态性。

（6）好了，现在接着讲执行LinkedHashSet添加操作时的newNode方法

  Node<K,V> newNode(int hash, K key, V value, Node<K,V> e) {
        LinkedHashMap.Entry<K,V> p =
            new LinkedHashMap.Entry<K,V>(hash, key, value, e);
        linkNodeLast(p);
        return p;
    }

执行完这个方法后，就会生成一个链表结点，然后就会tab[i] = newNode(hash, key, value, null);赋值给tab[i],这个i就是根据待添加元素的hash值而计算得的，因此就完成了，向table中添加了一个链表结点。

当添加第二个元素后table数组的结构:

其实就是当加入一个元素后就会形成链的形成，前一个结点的after指向后一个结点，后一个结点的before指向前一个结点。