LinkedHashMap源码浅析jdk1.7

最新推荐文章于 2022-08-19 19:46:54 发布

weixin_30888707

最新推荐文章于 2022-08-19 19:46:54 发布

阅读量111

点赞数

文章标签： java python 数据结构与算法

原文链接：http://www.cnblogs.com/kin1492/p/9360068.html

版权

LinkedHahsMap的继承关系

LinkedHashMap直接继承了HahsMap，而linkedHashMap和HashMap在同一个包下，因此HashMap中所有的非private的属性都能拿过来直接用。

LinkedHashMap继承HashMap原来的功能同时进行了修改。主要对原来Entry的结构进行了扩展，在继承父类Entry的基础上，有添加的两个属性Entry<K,V> before, after;和addBefore方法。同时覆盖了父类的init，addEntry,createEntry，transfer等方法，添加了header成员变量。

 private transient Entry<K,V> header;

private static class Entry<K,V> extends HashMap.Entry<K,V> {
        // These fields comprise the doubly linked list used for iteration.
        Entry<K,V> before, after;

        Entry(int hash, K key, V value, HashMap.Entry<K,V> next) {
            super(hash, key, value, next);
        }

        /**
         * Removes this entry from the linked list.
         */
        private void remove() {
            before.after = after;
            after.before = before;
        }

        /**
         * Inserts this entry before the specified existing entry in the list.
         */
        private void addBefore(Entry<K,V> existingEntry) {
            after  = existingEntry;
            before = existingEntry.before;
            before.after = this;
            after.before = this;
        }

        /**
         * This method is invoked by the superclass whenever the value
         * of a pre-existing entry is read by Map.get or modified by Map.set.
         * If the enclosing Map is access-ordered, it moves the entry
         * to the end of the list; otherwise, it does nothing.
         */
        void recordAccess(HashMap<K,V> m) {
            LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;
            if (lm.accessOrder) {
                lm.modCount++;
                remove();
                addBefore(lm.header);
            }
        }

        void recordRemoval(HashMap<K,V> m) {
            remove();
        }
    }

LinkedHashMap的初始化

linkedHashMap所有的构造方法里都调用了父类相关的构造方法，在父类构造中有调用了init方法，而linkedHashMap又覆盖了init方法，因此初始化先执行父类相关的操作，再执行自己init方法

@Override
    void init() {
        header = new Entry<>(-1, null, null, null);
        header.before = header.after = header;
    }

init方法主要是将header实例化，实例化之后就会出现一个Entry类型的header的指针,其before和after都指向自己，如下图所示

LinkedHashMap put操作

linkedHashMap没有覆盖put方法，还是用父类的，因此调用父类的put会完成table属性的初始化，以及计算元素在table中的索引（调用的都是父类相关方法），然后调用addEntry方法，这时会调用自己的addEntry方法，因为linkedHashMap重写了addEntry方法

 void addEntry(int hash, K key, V value, int bucketIndex) {
// 调用父类的addEntry
        super.addEntry(hash, key, value, bucketIndex);

        // Remove eldest entry if instructed
        Entry<K,V> eldest = header.after;
        if (removeEldestEntry(eldest)) {
            removeEntryForKey(eldest.key);
        }
    }

在自己的addEntry方法里面又调用了父类的方法，父类的方法如下：

void addEntry(int hash, K key, V value, int bucketIndex) {
//看是否需要扩容
        if ((size >= threshold) && (null != table[bucketIndex])) {
            resize(2 * table.length);
            hash = (null != key) ? hash(key) : 0;
            bucketIndex = indexFor(hash, table.length);
        }
        // 又调用createEntry
        createEntry(hash, key, value, bucketIndex);
    }

addEntry方法里又调用createEntry,同样linkedHashMap覆盖了父类的createEntry，调用本地的

void createEntry(int hash, K key, V value, int bucketIndex) {
    HashMap.Entry<K,V> old = table[bucketIndex];
    Entry<K,V> e = new Entry<>(hash, key, value, old);
    table[bucketIndex] = e;
    e.addBefore(header);
    size++;
}

把entry添加到数组里面后，又调用了entry对象的addBefore方法，该方法主要是将当前Entry节点的after指针指向header,before指针指向上一次put的entry，header的before指针指向

当前Entry节点，这样在下一次put新的Entry时总能通过header的before指针找到上一次put的Entry，从而维持Entry节点之间的先后顺序。

 private void addBefore(Entry<K,V> existingEntry) {
            after  = existingEntry;
            before = existingEntry.before;
            before.after = this;
            after.before = this;
        }

addBefore传进来的是header,进行如下操作

1. after  = existingEntry;

把当前节点（比如是A）的after指向header(existingEntry传递的都是header), 因此A.after--->header

2. before = existingEntry.before;

当前节点的before指向 header所指向的before(header.before=B)，A.before---->B

3. before.after = this;

也就是 B.after---->A

4. after.before = this;

相当于header.before--->A

如果是第一次添加,上面的B就是header对应如下图

linkedHashMap的Entry之间按照元素的put的先后顺序形成了双向循环链表，hashMap中元素与元素没有先后顺序，没法知道元素的put先后顺序，而linkedHashMap每次添加元素时都能通过header找到上一次添加的元素，通过after,和before记录当前元素前面的entry与后面的entry的联系。

LinkedHashMap和HashMap的结构的比较

linkedHashMap

HashMap

LinkedHashMap的迭代

public static void main(String[]args){
        LinkedHashMap<String,String> lm = new LinkedHashMap();
        lm.put("1","python");
        lm.put("2","java");
        lm.put("3","c++");
        //变量linkdeHashMap
        //方式一:迭代器迭代
        Iterator<Map.Entry<String,String>> i = lm.entrySet().iterator();
        while(i.hasNext()){
            Map.Entry<String,String> entry = i.next();
            System.out.println(entry.getKey()+":"+entry.getValue());
        }
        //方式二：for循环  迭代entrySet,keySet,values,这里只写了entrySet
        for(Map.Entry<String,String> e:lm.entrySet()){
            System.out.println(e.getKey()+":"+e.getValue());
        }
        //方式一和方式二，本质上是一样的只不过方式一是手动获取迭代器，手动调用迭代器的next方法，方式二jvm自动帮你调用iterator获取迭代器和执行迭代器的next方法
        //只不过方式一可以对迭代器进行操作，比如迭代的时候删除元素，方式二不能显示的获取迭代器，也就没法对迭代器操作，写法简单一点
    }

1:python
2:java
3:c++
1:python
2:java
3:c++

输出的顺序和元素添加的顺序是一样的，因为linkedHashMap自己重写了父类的迭代器，从header.after开始迭代

private abstract class LinkedHashIterator<T> implements Iterator<T> {
        Entry<K,V> nextEntry    = header.after;
        Entry<K,V> lastReturned = null;

        /**
         * The modCount value that the iterator believes that the backing
         * List should have.  If this expectation is violated, the iterator
         * has detected concurrent modification.
         */
        int expectedModCount = modCount;

        public boolean hasNext() {
            return nextEntry != header;
        }

        public void remove() {
            if (lastReturned == null)
                throw new IllegalStateException();
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();

            LinkedHashMap.this.remove(lastReturned.key);
            lastReturned = null;
            expectedModCount = modCount;
        }
//每次调用迭代器的next方法，都会执行该方法
        Entry<K,V> nextEntry() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            if (nextEntry == header)
                throw new NoSuchElementException();

            Entry<K,V> e = lastReturned = nextEntry;//初始状态为header.after,
            nextEntry = e.after;//一次迭代之后，nextEntry指向到当前元素的after
            return e;
        }
    }

HashMap遍历通过table的索引遍历，从table的索引0开始，之后遍历0索引处形成的链表，再从1开始......，而添加元素时散列的位置具有不确定性，第一个添加的

可能散列到最后一个位置了，因此不能确保按照元素添加时的顺序输出。

private abstract class HashIterator<E> implements Iterator<E> {
        Entry<K,V> next;        // next entry to return
        int expectedModCount;   // For fast-fail
        int index;              // current slot   index从0开始
        Entry<K,V> current;     // current entry

        HashIterator() {
            expectedModCount = modCount;
            if (size > 0) { // advance to first entry
                Entry[] t = table;
//从table中找到第一个不为空的索引位置，比如索引为0的位置没有元素为null,index++继续循环,到索引为1的位置,判断该位置是否有entry,直到找到第一个不为空的索引位置
                while (index < t.length && (next = t[index++]) == null)
                    ;
            }
        }

        public final boolean hasNext() {
            return next != null;
        }
//调用迭代器的next方法，会执行该方法
        final Entry<K,V> nextEntry() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            Entry<K,V> e = next;
            if (e == null)
                throw new NoSuchElementException();
   
            if ((next = e.next) == null) {
//当前索引形成的链没有下一entry，index++到下一个索引位置
                Entry[] t = table;
                while (index < t.length && (next = t[index++]) == null)//迭代时按照索引
                    ;
            }
            current = e;
            return e;
        }

        public void remove() {
            if (current == null)
                throw new IllegalStateException();
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            Object k = current.key;
            current = null;
            HashMap.this.removeEntryForKey(k);
            expectedModCount = modCount;
        }
    }