HashMap于LinkedHashMap

HashMap

HashMap是数组加上单链表的形式

# 构造函数

public HashMap() {
    // 4, 0.75f
    this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}

# put

public V put(K key, V value) {
    return putVal(hash(key), key, value, false, true);
}
// 哈希算法, 不讨论
static final int hash(Object key) {
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

public V put(K key, V value) {
    if (table == EMPTY_TABLE) {
        // 初始化数组容器, 长度为4
        inflateTable(threshold); 
    }
    if (key == null)
        return putForNullKey(value);
    // 计算哈希值
    int hash = sun.misc.Hashing.singleWordWangJenkinsHash(key);
    // int i = 哈希值 & (数组长度-1); 是为了不超出下标
    int i = indexFor(hash, table.length);
    for (HashMapEntry e = table[i]; e != null; e = e.next) {
        Object k;
        // 匹配 对应的key, 和哈希值
        // 如果匹配到覆盖原值
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            V oldValue = e.value;
            e.value = value;
            e.recordAccess(this);
            return oldValue;
        }
    }

    modCount++;
    // 没有匹配到, 链表中添加新的节点
    addEntry(hash, key, value, i);
    return null;
}

// key 为 NULL 时的方法
private V putForNullKey(V value) {
    // e 赋值为 tabel[0], 可见将 key为 null, 分配到了数组中的0下标
    for (HashMapEntry e = table[0]; e != null; e = e.next) {
        // e 不为空, 并且key == null时, 覆盖旧value
        if (e.key == null) {
            V oldValue = e.value;
            e.value = value;
            // 给子类重写, 空方法
            e.recordAccess(this);
            return oldValue;
        }
    }
    modCount++;
    // int hash, K key, V value, int bucketIndex
    addEntry(0, null, value, 0);
    return null;
}

// 给链表添加元素
void addEntry(int hash, K key, V value, int bucketIndex) {
    // 当存储的元素 >= 阈值(默认为3) 并且数组当前下标中的元素不等于空
    if ((size >= threshold) && (null != table[bucketIndex])) {
        // 以原数组长度的2倍扩容
        resize(2 * table.length);
        hash = (null != key) ? sun.misc.Hashing.singleWordWangJenkinsHash(key) : 0;
        bucketIndex = indexFor(hash, table.length);
    }

    createEntry(hash, key, value, bucketIndex);
}
// bucketIndex为要放进容器的下标
// 创建 Entry插入到 table数组 bucketIndex下标链表中的头部
void createEntry(int hash, K key, V value, int bucketIndex) {
    HashMapEntry e = table[bucketIndex];
    // 哈希值, key, value, next指针
    table[bucketIndex] = new HashMapEntry<>(hash, key, value, e);
    size++;
}
// 扩容数组
void resize(int newCapacity) {
    HashMapEntry[] oldTable = table;
    int oldCapacity = oldTable.length;
    if (oldCapacity == MAXIMUM_CAPACITY) {
        threshold = Integer.MAX_VALUE;
        return;
    }

    HashMapEntry[] newTable = new HashMapEntry[newCapacity];
    transfer(newTable);
    table = newTable;
    threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}
// 将原有数据迁移到扩容后的数组当中
void transfer(HashMapEntry[] newTable) {
    int newCapacity = newTable.length;
    // 外不循环, 遍历远table元素
    for (HashMapEntry e : table) {
        // 内部循环, 遍历table元素中的链表
        while(null != e) {
            HashMapEntry next = e.next;
            // 根据新的数组长度重新计算下标
            int i = indexFor(e.hash, newCapacity);
            // 相当于将 Node e插入到当前下标链表中的头部
            e.next = newTable[i];
            newTable[i] = e;
            e = next;
        }
    }
}

# get

public V get(Object key) {
    if (key == null)
        return getForNullKey();
    // 根据key 获取对应的 Entry
    Map.Entry entry = getEntry(key);

    return null == entry ? null : entry.getValue();
}

// 获取 key 为 NULL的 value
private V getForNullKey() {
    if (size == 0) {
        return null;
    }
    // 在 下标为0的 链表中循环查找
    for (HashMapEntry e = table[0]; e != null; e = e.next) {
        if (e.key == null)
            return e.value;
    }
    return null;
}

final Map.Entry getEntry(Object key) {
    if (size == 0) {
        return null;
    }

    int hash = (key == null) ? 0 : sun.misc.Hashing.singleWordWangJenkinsHash(key);
    // 遍历链表
    for (HashMapEntry e = table[indexFor(hash, table.length)];
         e != null;
         e = e.next) {
        Object k;
        // 匹配 哈希值和 key
        if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k))))
            return e;
    }
    return null;
}

# remove

public V remove(Object key) {
    Map.Entry e = removeEntryForKey(key);
    return (e == null ? null : e.getValue());
}

final Map.Entry removeEntryForKey(Object key) {
    if (size == 0) {
        return null;
    }
    int hash = (key == null) ? 0 : sun.misc.Hashing.singleWordWangJenkinsHash(key);
    int i = indexFor(hash, table.length);
    HashMapEntry prev = table[i];
    HashMapEntry e = prev;

    while (e != null) {
        HashMapEntry next = e.next;
        Object k;
        if (e.hash == hash &&
                ((k = e.key) == key || (key != null && key.equals(k)))) {
            modCount++;
            size--;
            // prev == e 表明第一次循环就中标
            if (prev == e)
                table[i] = next;
            else
                // 前一个Node 连接 nextNode
                prev.next = next;
            // 子类重写, 空方法
            e.recordRemoval(this);
            return e;
        }
        prev = e;
        e = next;
    }

    return e;
}

# entrySet()

// entrySet() 和 keySet() 都是一个意思
private Set> entrySet0() {
    Set> es = entrySet;
    return es != null ? es : (entrySet = new EntrySet());
}
// EntrySet
public final void forEach(Consumer> action) {
    HashMapEntry[] tab;
    if (action == null)
        throw new NullPointerException();
    if (size > 0 && (tab = table) != null) {
        int mc = modCount;
        // 外部循环遍历 tab 数组
        for (int i = 0; i < tab.length; ++i) {
            // 内部循环 遍历链表
            // 规则是从 下标 0开始遍历链表, 链表结束后 在遍历下标1 ...
            for (HashMapEntry e = tab[i]; e != null; e = e.next) {
                action.accept(e);
                // 等号不成立, 说明出现了并发错误
                if (modCount != mc) {
                    throw new ConcurrentModificationException();
                }
            }
        }
    }
}
// HashIterator
// KeySet 调用 iterator 会调用该方法获取Entry, 在调用getKey
// 规则也和 foreach() 一样也是从下标0开始 遍历
final Map.Entry nextEntry() {
    if (modCount != expectedModCount)
        throw new ConcurrentModificationException();
    HashMapEntry e = next;
    if (e == null)
        throw new NoSuchElementException();

    if ((next = e.next) == null) {
        HashMapEntry[] t = table;
        while (index < t.length && (next = t[index++]) == null)
        ;
    }
    current = e;
    return e;
}

LinkedHashMap

LinkedHashMap继承于HashMap, 利用双向循环链表保证顺序

# init

void init() {
    // 初始化header, before和after都指向自己
    header = new LinkedHashMapEntry<>(-1, null, null, null);
    header.before = header.after = header;
}

# put

void createEntry(int hash, K key, V value, int bucketIndex) {
    HashMapEntry old = table[bucketIndex];
    LinkedHashMapEntry e = new LinkedHashMapEntry<>(hash, key, value, old);
    table[bucketIndex] = e;
    // 到上面和 HashMap一样, 插入到当前下标链表的头部
    e.addBefore(header);
    size++;
}

// 该方法传入 header
// 如果说双向循环链表中 header为头部, 那么这里就是插入到队尾
private void addBefore(LinkedHashMapEntry existingEntry) {
    // 新元素 after 指向 header
    after  = existingEntry;
    // 新元素 before 指向队尾, 也有可能是header
    before = existingEntry.before;
    // 原队尾元素 after 指向新元素
    before.after = this;
    // header.before 指向新元素
    after.before = this;
}

void transfer(HashMapEntry[] newTable) {
    int newCapacity = newTable.length;
    // 因为每个元素之前都有链表关系, 所以这里没有必要双重循环, 数组和链表
    // 元素 e 从header.after开始
    for (LinkedHashMapEntry e = header.after; e != header; e = e.after) {
        int index = indexFor(e.hash, newCapacity);
        e.next = newTable[index];
        newTable[index] = e;
    }
}

# remove()

void recordRemoval(HashMap m) {
    remove();
}
private void remove() {
    before.after = after;
    after.before = before;
}

# foreach()

public void forEach(BiConsumer action) {
    if (action == null)
        throw new NullPointerException();
    int mc = modCount;
    // header.after 开始直到 header为止, header不参与
    for (LinkedHashMapEntry e = header.after; modCount == mc && e != header; e = e.after)
        action.accept(e.key, e.value);
    if (modCount != mc)
        throw new ConcurrentModificationException();
}