Java深入集合--linkedHashMap

最新推荐文章于 2021-09-18 11:38:48 发布

kevin_li0719

最新推荐文章于 2021-09-18 11:38:48 发布

阅读量850

点赞数

分类专栏： Java 文章标签： LinkedHashMap

Java 专栏收录该内容

26 篇文章 0 订阅

订阅专栏

原文：http://greemranqq.iteye.com/blog/1931880

LinkedHashMap 源码介绍

一、介绍：

LinkedHashMap 和hashMap 功能类似，都是维护的键值对集合，连遍历以及方法都类似，唯一的区别在于

hashMap 里面的元素是根据hash值来决定存放位置的，是无序的，而LinkedHashMap 维护的是一个按顺序存放的双向链表，是有序的。

所谓的双向链表其实是链表的一种。链表：相当于元素 A->B->C ,也就是我可以通过A 找到B ,从而找到C，可以单向移动。而双向链表：A<->B<->C ，也就是说我可以从B 找到 A 和 C，可以双向移动。

二、源码分析：

Java代码

public class LinkedHashMap<K,V> extends HashMap<K,V> implements Map<K,V>

public class LinkedHashMap<K,V> extends HashMap<K,V> implements Map<K,V>

我们可以看到这东西是继承的HashMap 的，说明拥有hashMap 的功能，那么我们具体来看看不同在哪里呢？

1. 构造函数：

Java代码

public LinkedHashMap(int initialCapacity,float loadFactor,boolean accessOrder) {
super(initialCapacity, loadFactor);
this.accessOrder = accessOrder;
}
public LinkedHashMap(int initialCapacity, float loadFactor) {
super(initialCapacity, loadFactor);
accessOrder = false;
}
public LinkedHashMap(int initialCapacity) {
super(initialCapacity);
accessOrder = false;
}
我们看到3个构造函数，其实都是访问的super(..),也就是hashMap 的构造，区别就在accessOrder
来看看它是什么？

public LinkedHashMap(int initialCapacity,float loadFactor,boolean accessOrder) {
        super(initialCapacity, loadFactor);
        this.accessOrder = accessOrder;
}

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

 public LinkedHashMap(int initialCapacity) {
	super(initialCapacity);
        accessOrder = false;
}
我们看到3个构造函数，其实都是访问的super(..),也就是hashMap 的构造，区别就在accessOrder 
来看看它是什么？

Java代码

//The iteration ordering method for this linked hash map: <tt>true</tt>
//for access-order, <tt>false</tt> for insertion-order.
// 简单说就是这个用来控制元素的顺序，
// true: 是访问的顺序，也就是谁最先访问，就排在第一位
// false:存放顺序，就是你put 元素的时候的顺序
private final boolean accessOrder;

 
     //The iteration ordering method for this linked hash map: <tt>true</tt>
     //for access-order, <tt>false</tt> for insertion-order.
    // 简单说就是这个用来控制元素的顺序，
    // true: 是访问的顺序，也就是谁最先访问，就排在第一位
    // false:存放顺序，就是你put 元素的时候的顺序
    private final boolean accessOrder;

这里稍后再看怎么用的，我们先来分析核心内部类 Entry 类，这几乎是所有map 都需要的东西。

Java代码

private static class Entry<K,V> extends HashMap.Entry<K,V> {
// These fields comprise the doubly linked list used for iteration.
// 这里我们看到，Entry<K,V> 类里面多了了两个属性，专门来方便我们进行链表的前后移动 // 的
Entry<K,V> before, after;
// 这里调用了hashMap 的entry 构造，说明还是用的HashMap 的Entry
Entry(int hash, K key, V value, HashMap.Entry<K,V> next) {
super(hash, key, value, next);
}
// ..剩下的稍后说

 private static class Entry<K,V> extends HashMap.Entry<K,V> {
        // These fields comprise the doubly linked list used for iteration.
        // 这里我们看到，Entry<K,V>  类里面多了了两个属性，专门来方便我们进行链表的前后移动        // 的
        Entry<K,V> before, after;
        // 这里调用了hashMap 的entry 构造，说明还是用的HashMap 的Entry
	Entry(int hash, K key, V value, HashMap.Entry<K,V> next) {
            super(hash, key, value, next);
        }
       // ..剩下的稍后说
}

Java代码

继续来看这些属性怎么利用起来的。对于集合，我们肯定要关注他的存放元素和取元素的方法啦：
当我们找遍整个类的时候发现，没有找到put 方法- -。但是LinkedHashMap 肯定是可以调用put的，因为继承了hashMap,
那我们把 hashMap 的put方法先取出来吧

继续来看这些属性怎么利用起来的。对于集合，我们肯定要关注他的 存放元素 和 取元素的方法啦：
当我们找遍整个类的时候发现，没有找到put 方法- -。但是LinkedHashMap 肯定是可以调用put的，因为继承了hashMap,
那我们把 hashMap 的put方法先取出来吧

Java代码

public V put(K key, V value) {
if (key == null)
return putForNullKey(value);
int hash = hash(key.hashCode());
// 这里都是调用 hashMap 计算位置什么的，前面hashMap 已经分析过啦
int i = indexFor(hash, table.length);
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
// 这里被重写了 A
e.recordAccess(this);
return oldValue;
}
}
modCount++;
// 这里被重写了 B
addEntry(hash, key, value, i);
return null;
}

 public V put(K key, V value) {
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key.hashCode());
        // 这里都是调用 hashMap 计算位置什么的，前面hashMap 已经分析过啦
        int i = indexFor(hash, table.length);
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                // 这里被重写了 A
                e.recordAccess(this);
                return oldValue;
            }
        }

        modCount++;
        // 这里被重写了 B 
        addEntry(hash, key, value, i);
        return null;
    }

从上面看出和hashMap 没啥区别，关键就看重写的方法啦，特别是e.recordAccess 这个方法在hashMap 介绍中，不是提到不知道干什么的嘛，这里详细来看看。

Java代码

private static class Entry<K,V> extends HashMap.Entry<K,V> {
/**
* 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;
// 如果参数为true,也就是根据访问顺序
if (lm.accessOrder) {
// 迭代控制的变量
lm.modCount++;
remove();
addBefore(lm.header);
}
}
// 这里我们发现 before和after 虽然定义了属性，是哪儿赋值的呢？为什么不为null呢？
// 请回到构造函数，我们发现有一个init()方法，以前是没用的，这里也进行了重写，请看 // 后面init 方法
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;
}
// 整个
}

private static class Entry<K,V> extends HashMap.Entry<K,V> {
	/**
         * 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;
            // 如果参数为true,也就是根据访问顺序
            if (lm.accessOrder) {
                // 迭代控制的变量
                lm.modCount++;
                remove();
                addBefore(lm.header);
            }
        }
	
	// 这里我们发现 before和after 虽然定义了属性，是哪儿赋值的呢？为什么不为null呢？
        // 请回到 构造函数，我们发现有一个init()方法，以前是没用的，这里也进行了重写，请看         // 后面init 方法
        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;
        }
        // 整个

}

init() 方法：

Java代码

/**
* The head of the doubly linked list.
*/
private transient Entry<K,V> header;
void init() {
// 这里默链表表头是header,并让hash值为-1,其他都为null,仅仅是作为一个标志位
// 初始化这个节点
header = new Entry<K,V>(-1, null, null, null);
// 赋值在这里，默认这是起点，相当于还没有其他元素
header.before = header.after = header;
}

    /**
     * The head of the doubly linked list.
     */
  private transient Entry<K,V> header;
  void init() {
        // 这里默链表 表头是header,并让hash值为-1,其他都为null,仅仅是作为一个标志位
        // 初始化这个节点
        header = new Entry<K,V>(-1, null, null, null);
        // 赋值在这里，默认这是起点，相当于还没有其他元素
        header.before = header.after = header;
    }

可能上面的文字描述很难理解，我们假设：这个双链表结构相当于一条一节一节连起来的项链，当然每一节肯定有链接前before 和 after 这样的连接位置（属性），中间才是宝石（数据）。然后，一般项链都有一个明显的位置，方便你去下来的（header），那里其实是用来首位相连的，当我们觉得长度不够，需要添加一个宝石的时候，首先会从那里打开，也就是执行（remove）方法，然后把你需要的宝石连接在最后的位置(after = existingEntry,before = existingEntry.before;);，从程序上来说就是把那个header 的位置，原先连接器的先取掉掉，那个位置就从新连接新的元素。

继续讲解put 方法，继续往下看还有一个addEntry(hash, key, value, i)方法，也进行了重写

Java代码

void addEntry(int hash, K key, V value, int bucketIndex) {
// 存放元素
createEntry(hash, key, value, bucketIndex);
// Remove eldest entry if instructed, else grow capacity if appropriate
Entry<K,V> eldest = header.after;
// 这里始终返回的是false，也就是说方便我们扩展，重写的- -！
if (removeEldestEntry(eldest)) {
removeEntryForKey(eldest.key);
} else {
if (size >= threshold)
resize(2 * table.length);
}
}
void createEntry(int hash, K key, V value, int bucketIndex) {
// 通过key 和长度计算出的位置，去获得那个元素，可能为空
HashMap.Entry<K,V> old = table[bucketIndex];
// 然后在这个位置创建一个新元素，并让next 指向old
Entry<K,V> e = new Entry<K,V>(hash, key, value, old);
// 把这个元素放进数组的这个位置
table[bucketIndex] = e;
// 然后把header 的after before属性，和元素节点从新连接起来
// 元素就在header 之前了，也就是可以保证最先访问(这里通过Set 集合遍历顺序是反的- -!)
e.addBefore(header);
size++;
}

    void addEntry(int hash, K key, V value, int bucketIndex) {
        // 存放元素
        createEntry(hash, key, value, bucketIndex);

        // Remove eldest entry if instructed, else grow capacity if appropriate
        Entry<K,V> eldest = header.after;
        // 这里始终返回的是false，也就是说 方便我们扩展，重写的- -！
        if (removeEldestEntry(eldest)) {
            removeEntryForKey(eldest.key);
        } else {
            if (size >= threshold)
                resize(2 * table.length);
        }
 }
 void createEntry(int hash, K key, V value, int bucketIndex) {
        // 通过key 和长度 计算出的位置，去获得那个元素，可能为空
        HashMap.Entry<K,V> old = table[bucketIndex];
        // 然后在这个位置创建一个新元素，并让next 指向old
	Entry<K,V> e = new Entry<K,V>(hash, key, value, old);
        // 把这个元素放进数组的这个位置
        table[bucketIndex] = e;
        // 然后把header 的after before属性，和元素节点从新连接起来
        // 元素就在header 之前了，也就是可以保证最先访问(这里通过Set 集合遍历顺序是反的- -!)
        e.addBefore(header);
        size++;
    }

上面可以看出，linkedHashMap，元素默认是放在链表前，也就是根据存放顺序放的，而实际情况还是用的hashMap 里面的table 数组，元素位置是随机存放的，只是linkedHashMap扩展，加入了属性，对每个元素存放的位置进行了像链表结构那样的链接。那么当我们设置accessOrder=true 的时候如何才控制根据访问顺序进行排列呢？首先请看get 方法：

Java代码

} // 也进行了重写
public V get(Object key) {
// 调用父类的get方法
Entry<K,V> e = (Entry<K,V>)getEntry(key);
if (e == null)
return null;
// 这里还是调用的刚才的方法，把当前元素放在header 之前，也就完成了根据访问顺序排序
e.recordAccess(this);
return e.value;
}

    }    // 也进行了重写
    public V get(Object key) {
        // 调用父类的get方法
        Entry<K,V> e = (Entry<K,V>)getEntry(key);
        if (e == null)
            return null;
        // 这里还是调用的刚才的方法，把当前元素放在header 之前，也就完成了 根据访问顺序排序
        e.recordAccess(this);
        return e.value;
    }

上面对该集合实现双链表结构的原理以及代码大概讲述了一下，可以去看看图例更加清晰，下面继续看看一些方法。

Java代码

1.keySet()，entrySet（），values方法：
这里还是调用的父类的，但是它重写了几个方法：
// 这是重写的
Iterator<K> newKeyIterator() { return new KeyIterator(); }
Iterator<V> newValueIterator() { return new ValueIterator(); }
terator<Map.Entry<K,V>> newEntryIterator() { return new EntryIterator(); }
// 这里返回值方式类似，都是通过 nextEntry()返回不同的内容，但是继承对象变成了LinkedHashIterator，不是原来的 // HashIterator
private class KeyIterator extends LinkedHashIterator<K> {
public K next() { return nextEntry().getKey(); }
}
// 看看区别吧
private abstract class LinkedHashIterator<T> implements Iterator<T> {
// 后一个节点
Entry<K,V> nextEntry = header.after;
// 最后返回的节点
Entry<K,V> lastReturned = null;
// 迭代的那个变量控制
int expectedModCount = modCount;
// 如果下一个元素师头元素，说明已经到底呢，没有其他元素了
public boolean hasNext() {
return nextEntry != header;
}
// 获得下一个元素
Entry<K,V> nextEntry() {
// 这里就不明白了，当排序参数设置为true 是，有lm.modCount ++,这里进行.next 迭代的时候，老报错
// 不明白的意义了
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
// 这里元素迭代完了，直接抛异常- -，不懂为什么这样设计
if (nextEntry == header)
throw new NoSuchElementException();
// 返回下一个元素，并且将nextEntry 指向下下一个元素
Entry<K,V> e = lastReturned = nextEntry;
nextEntry = e.after;
return e;
}
// 删除
public void remove() {
// 这里同上
if (lastReturned == null)
throw new IllegalStateException();
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
// 这里看出lastReturned 作用就是记录遍历的当前位置，方便删除
// 这里直接调用removeEntryForKey 方法就好了，这个- - 看着不爽，反正又不要返回值
LinkedHashMap.this.remove(lastReturned.key);
lastReturned = null;
expectedModCount = modCount;
}
}

 1.keySet()，entrySet（），values方法：
  这里还是调用的父类的，但是它重写了几个方法：
  // 这是重写的
  Iterator<K> newKeyIterator()   { return new KeyIterator();   }
  Iterator<V> newValueIterator() { return new ValueIterator(); }
  terator<Map.Entry<K,V>> newEntryIterator() { return new EntryIterator(); }
  // 这里返回值方式类似，都是通过 nextEntry()返回不同的内容，但是继承对象变成了LinkedHashIterator，不是原来的  // HashIterator
  private class KeyIterator extends LinkedHashIterator<K> {
	public K next() { return nextEntry().getKey(); }
   }
   // 看看区别吧
   private abstract class LinkedHashIterator<T> implements Iterator<T> {
        // 后一个节点
	Entry<K,V> nextEntry    = header.after;
        // 最后返回的节点
	Entry<K,V> lastReturned = null;

	// 迭代的那个变量控制
	int expectedModCount = modCount;
        // 如果下一个元素师头元素，说明已经到底呢，没有其他元素了
        public boolean hasNext() {
            return nextEntry != header;
	}
       // 获得下一个元素
       Entry<K,V> nextEntry() {
            // 这里就不明白了，当排序参数设置为true 是，有lm.modCount ++,这里进行.next 迭代的时候，老报错
            // 不明白的意义了
	    if (modCount != expectedModCount)
		throw new ConcurrentModificationException();
            // 这里元素迭代完了， 直接抛异常- -，不懂为什么这样设计
            if (nextEntry == header)
                throw new NoSuchElementException();
            // 返回下一个元素，并且将nextEntry 指向下下一个元素
            Entry<K,V> e = lastReturned = nextEntry;
            nextEntry = e.after;
            return e;
	}
        // 删除
        public void remove() {
            // 这里同上
	    if (lastReturned == null)
		throw new IllegalStateException();
	    if (modCount != expectedModCount)
		throw new ConcurrentModificationException();
	    // 这里看出lastReturned 作用就是记录遍历的当前位置，方便删除
            // 这里直接调用removeEntryForKey 方法就好了，这个- - 看着不爽，反正又不要返回值
            LinkedHashMap.this.remove(lastReturned.key);
            lastReturned = null;
            expectedModCount = modCount;
	}
   }

Java代码

2.containsKey() 这里是访问hashMap 的方法，这里就不说了。
containsValue() 进行了重写
public boolean containsValue(Object value) {
// Overridden to take advantage of faster iterator
// 这里仅仅是通过链表的两个属性进行遍历，hashMap 是通过table 数组进行遍历，效果差不 // 多
if (value==null) {
for (Entry e = header.after; e != header; e = e.after)
if (e.value==null)
return true;
} else {
for (Entry e = header.after; e != header; e = e.after)
if (value.equals(e.value))
return true;
}
return false;

2.containsKey() 这里是访问hashMap 的方法，这里就不说了。
   containsValue() 进行了重写

   public boolean containsValue(Object value) {
        // Overridden to take advantage of faster iterator
        // 这里仅仅是通过链表的两个属性进行遍历，hashMap 是通过table 数组进行遍历，效果差不        // 多
        if (value==null) {
            for (Entry e = header.after; e != header; e = e.after)
                if (e.value==null)
                    return true;
        } else {
            for (Entry e = header.after; e != header; e = e.after)
                if (value.equals(e.value))
                    return true;
        }
        return false;

最近我不能直接在iteye 进行编辑，不知道为什么，老是卡死，都是记事本写了，复制过来，没图片和格式，望见谅！

总结：1.linkedhashMap 是继承于hashMap 也就是拥有了他一切功能

2.他是双链表结构，好处可以存取顺序

3.可以进行扩展，用来对那些最近访问元素的优先获得权

4.存放效率，如果构造参数设置为true ，由于要维护链表结构，效率比hashMap 低一点，但是默认是放在最后，能直接从header 进行操作，效率其实没多大影响。

5.get 元素类似。如果构造参数为true ,需要进行链表的操作，效率低于hashMap,否则效率一样。

6.通过Iterator.keySet().iterator() 这样迭代，数据3000000 的情况，数据默认一个数字，linkedhashMap 慢几十毫秒，基本没影响。如果构造参数为true ，则linkedHashMap 迭代异常。

Java代码