JDK源码==》LinkedHashMap类学习

文章目录

1、linkedHashMap的主要成员变量及构造2、get通过键名查找定的数据3、put、replace、remove，由于该类没有重写对应的put、replace、remove方法，所以引用父类HashMap的方法，但是对应的功能方法里面执行的方法却有重写4、containsValue查询是否存在对应的Value值5、clear清空6、linkedHashMap与HashMap的关联

在linkedHashMap中这三个方法对应的重写方法

1、linkedHashMap的主要成员变量及构造

public class linkedHashMap
        extends HashMap
        implements Map {
        
        // 双向链表的头部
        transient linkedHashMap.Entry head;
        // 双向链表的尾部
        transient linkedHashMap.Entry tail;
        // 此链接哈希映射的迭代排序方法:true用于访问顺序，false用于插入顺序
        final boolean accessOrder;
        
        public linkedHashMap(int initialCapacity, float loadFactor) {
            super(initialCapacity, loadFactor);
            accessOrder = false;
    	}
    	
    	public linkedHashMap(int initialCapacity) {
            super(initialCapacity);
            accessOrder = false;
    	}
    	
    	public linkedHashMap() {
            super();
            accessOrder = false;
    	}
    	
    	public linkedHashMap(Map m) {
            super();
            accessOrder = false;
            putMapEntries(m, false);
    	}
        
        public linkedHashMap(int initialCapacity,float loadFactor,boolean accessOrder) {
            super(initialCapacity, loadFactor);
            this.accessOrder = accessOrder;
    	}
    	...........................

}

2、get通过键名查找定的数据

	// 使用了HashMap中的内部类
	static class Node implements Map.Entry {
        final int hash;
        final K key;
        V value;
        Node next;

        Node(int hash, K key, V value, Node next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }
		...................
    }
	public V get(Object key) {
        Node e;
        // 使用了HashMap中的getNode方法查询对应的节点
        if ((e = getNode(hash(key), key)) == null)
            return null;
        if (accessOrder)
            afterNodeAccess(e);
        return e.value;
    }

3、put、replace、remove，由于该类没有重写对应的put、replace、remove方法，所以引用父类HashMap的方法，但是对应的功能方法里面执行的方法却有重写

	void reinitialize() {
        super.reinitialize();
        head = tail = null;
    }

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

    Node replacementNode(Node p, Node next) {
        linkedHashMap.Entry q = (linkedHashMap.Entry)p;
        linkedHashMap.Entry t =
            new linkedHashMap.Entry(q.hash, q.key, q.value, next);
        transferlinks(q, t);
        return t;
    }

    TreeNode newTreeNode(int hash, K key, V value, Node next) {
        TreeNode p = new TreeNode(hash, key, value, next);
        linkNodeLast(p);
        return p;
    }

    TreeNode replacementTreeNode(Node p, Node next) {
        linkedHashMap.Entry q = (linkedHashMap.Entry)p;
        TreeNode t = new TreeNode(q.hash, q.key, q.value, next);
        transferlinks(q, t);
        return t;
    }

4、containsValue查询是否存在对应的Value值

	public boolean containsValue(Object value) {
        for (linkedHashMap.Entry e = head; e != null; e = e.after) {
            V v = e.value;
            if (v == value || (value != null && value.equals(v)))
                return true;
        }
        return false;
    }

5、clear清空

	public void clear() {
        super.clear();
        head = tail = null;
    }

6、linkedHashMap与HashMap的关联

在HashMap类中可以看到有三个方法如下，没有实现方法体，但是在linkedHashMap类中这三个方法有方法体，有对应的实现，该注释说明了允许linkedHashMap的后期回调

在linkedHashMap中这三个方法对应的重写方法

	void afterNodeRemoval(Node e) { // unlink
        linkedHashMap.Entry p =
            (linkedHashMap.Entry)e, b = p.before, a = p.after;
        p.before = p.after = null;
        if (b == null)
            head = a;
        else
            b.after = a;
        if (a == null)
            tail = b;
        else
            a.before = b;
    }

    void afterNodeInsertion(boolean evict) { // possibly remove eldest
        linkedHashMap.Entry first;
        if (evict && (first = head) != null && removeEldestEntry(first)) {
            K key = first.key;
            removeNode(hash(key), key, null, false, true);
        }
    }

    void afterNodeAccess(Node e) { // move node to last
        linkedHashMap.Entry last;
        if (accessOrder && (last = tail) != e) {
            linkedHashMap.Entry p =
                (linkedHashMap.Entry)e, b = p.before, a = p.after;
            p.after = null;
            if (b == null)
                head = a;
            else
                b.after = a;
            if (a != null)
                a.before = b;
            else
                last = b;
            if (last == null)
                head = p;
            else {
                p.before = last;
                last.after = p;
            }
            tail = p;
            ++modCount;
        }
    }