LinkedHashMap实现访问有序原理及实现LRUCache

11人阅读 评论(0) 收藏 举报
分类:

相信大家在平常的开发中都接触过HashMap和LinkedHashMap,但对他们之间的区别可能有些人还不是很清楚-------LinkedHashMap可控制按插入顺序读取和按访问顺序读取,今天我就来说下LinkedHashMap的访问有序的特性和基于LinkedHashMap实现的LCUCache缓存对象。

所谓的访问有序就是指LinkedHashMap将近期访问的元素置后,访问越频繁的元素越往后移,前面的元素则是最久未被访问的元素,基于这一特性。我们可以用LinkedHashMap实现LCUCache缓存对象。

本次源码讲解是基于jdk1.8版本。

LinkedHashMap通过继承HashMap获得了大部分通用代码,其中就包括put方法,LinkedHashMap并没有覆写HashMap的put方法,只复写了get方法。

public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }
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  //如果put的key已经存在,则覆盖value并且将这个节点移到链表最后
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);   //将参数节点移到链表最后,这个方法在HashMap并没有具体实现方法,回调LinkedHashMap中的具体实现
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);//节点插入后的操作,是否删除最老的节点。这个方法在HashMap并没有具体实现方法,回调LinkedHashMap中的具体实现
        return null;
    }
// Callbacks to allow LinkedHashMap post-actions
    void afterNodeAccess(Node<K,V> p) { }
    void afterNodeInsertion(boolean evict) { }
    void afterNodeRemoval(Node<K,V> p) { }

LinkedHashMap虽没有覆写HashMap的put方法,但是为了满足LinkedHashMap的特性,HashMap也给LinkedHash留了几个回调入口,即在put方法中调用LinkedHashMap的afterNodeInsertionafterNodeAccess方法。

下面剖析下这俩个函数在LinkedHashMap的具体实现逻辑。

afterNodeInsertion

 void afterNodeInsertion(boolean evict) { // possibly remove eldest    在往链表尾部插入新元素时,是否将首部最老元素移除
        LinkedHashMap.Entry<K,V> first;
        if (evict && (first = head) != null && removeEldestEntry(first)) {
            K key = first.key;
            removeNode(hash(key), key, null, false, true);
        }
    }
 protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {  //默认是不移除首部最老元素,如需实现自定义的LRUCache对象,则根据需要复写该方法
	return false;
}

afterNodeAccess

 void afterNodeAccess(Node<K,V> e) { // move node to last   将访问的节点移至链表末尾,并且修改modcount
        LinkedHashMap.Entry<K,V> last;
        if (accessOrder && (last = tail) != e) {
            LinkedHashMap.Entry<K,V> p =
                (LinkedHashMap.Entry<K,V>)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;
        }
    }

通过上面的代码来理清下LinkedHashMap的put逻辑。即在添加新元素的时候,如果不存在key的映射,则默认将新的节点连接到尾部,否则替换value值并将该节点移到尾部。在完成新的节点插入后,LinkedHashMap可根据removeEldestEntry函数的返回值判断是否执行删除首部最老元素,从而将最久未被使用的元素剔除,这也是LCUCache实现的基本原理,默认是不删除。

LinkedHashMap相对于HashMap的最大不同就是get逻辑了,下面开始讲解其是如何实现按访问顺序进行迭代的。

  public V get(Object key) {
        Node<K,V> e;
        if ((e = getNode(hash(key), key)) == null)
            return null;
        if (accessOrder)  //accessOrder时LinkedHashMap的一个成员变量,通过他控制LinkedHashMap是按插入顺序迭代还是按访问顺序迭代
            afterNodeAccess(e);//如果accseeOrder为true的话,则将当前访问节点移至末尾,从而改变迭代顺序
        return e.value;
    }
从代码可以看出,LinkedHashMap有accessOrder控制其迭代方式,所以我们如果要求LinkedHashMap由访问顺序进行迭代的话,则需要调用
  public LinkedHashMap(int initialCapacity,
                         float loadFactor,
                         boolean accessOrder) {
        super(initialCapacity, loadFactor);
        this.accessOrder = accessOrder;
    }

构造方法实例化LinkedHashMap对象,其默认是按插入顺序进行迭代的。当开启按访问顺序迭代,我们每get一个key的时候,linkedHashMap就会将该节点移至末尾,所以链表前端都是最少最近使用对象(least currently  used ,LCU),从而实现按访问顺序进行迭代。

如何通过LinkedHashMap实现LCUCache呢?
/**
 * LinkedHashMap通过设置accssOrder来判断是使用查询顺序进行迭代还是访问顺序进行迭代
 * 通过继承LinkedHashMap实现LRUCache缓存类
 * @author lujunfa
 *
 */
class LRUCache extends LinkedHashMap<String, Object>{
	
	public LRUCache(boolean accessOrder) {//true 设置缓存为访问排序,即最新访问节点都排在队列的最后,最前面的都是最久未被使用的节点
		// TODO Auto-generated constructor stub
		super(16,(float) 0.75,accessOrder);
	} 
	/**
	 * 复写removeEldestEntry方法,实现当·达到阈值删除最久未使用的节点
	 */
	@Override
	protected boolean removeEldestEntry(java.util.Map.Entry<String, Object> eldest) {
		// TODO Auto-generated method stub
		if(size()>5)
		return true;
		else 
			return false;
	}
}
public class LRUCacheDemon {
		public static void main(String[] args) {
			LRUCache cache = new LRUCache(true);
			cache.put("1", "lujunfa");
			cache.put("2", "lujunfa2");
			cache.put("3", "lujunfa3");
			cache.put("4", "lujunfa4");
			cache.put("5", "lujunfa5");
			cache.get("3");//将3节点排到最后
			Iterator iterator = cache.entrySet().iterator();
			while(iterator.hasNext()){
				System.out.println(iterator.next());
			}
			
			System.out.println("当cache中的数据容量大于5时,会丢弃最久未被使用的");
			cache.put("6", "lujunfa6");//设置LRUCache的缓存大小为5,所以当达到最大容量还往缓存放数据时,则前面的部分会被删除
			cache.put("7", "lujunfa7");
			Iterator iterator2 = cache.entrySet().iterator();
			while(iterator2.hasNext()){
				System.out.println(iterator2.next());
			}
			
			
			
		}
}




查看评论

图像分割原理

-
  • 1970年01月01日 08:00

2018 Android面试心得,已拿到offer

从16年毕业至今,就职过两家公司,大大小小项目做了几个,非常感谢我的两位老大,在我的android成长路上给予我很多指导,亦师亦友的关系。从年前至今参加面试了很多公司,也收到了几家巨头的offer,还...
  • qq_27053103
  • qq_27053103
  • 2018-03-15 14:05:37
  • 1751

LinkedHashMap 实现 LruCache 的底层数据结构?

LinkedHashMap LinkedHashMap 是 HashMap 的子类,其数据结构是和 HashMap 是差不多的,也是由数组组成,每一个数组的元素都是由链表去维护。但是 Linked...
  • lwj_zeal
  • lwj_zeal
  • 2017-06-07 11:55:33
  • 594

LRUCache原理及HashMap LinkedHashMap内部实现原理

LRUCache HashMap LinkedHashMap内部实现原理
  • hlglinglong
  • hlglinglong
  • 2015-11-27 17:11:18
  • 2328

LinkedHashMap如何实现迭代时有序

LinkedHashMap具有可预知的迭代顺序,根据链表中元素的顺序可以分为:按插入顺序的链表,和按访问顺序(调用get方法)的链表。   默认是按插入顺序排序,如果指定按访问顺序排序,那么调用get...
  • u011299745
  • u011299745
  • 2016-10-21 00:05:30
  • 1443

LinkedHashMap及LruCache是如何实现最少用最先淘汰算法

LinkedHashMap及LruCache是如何实现最少用最先淘汰算法LinkedHashMap是链表的方式保存,它的最小单元是LinkedEntry。但是这些单元又是保存在一个hashtable里...
  • u012947056
  • u012947056
  • 2017-09-07 14:16:27
  • 181

Android中LruCache到底是如何配合LinkedHashMap实现LRU算法

LruCache是Android3.1提供的一个缓冲类,support包中也有。它对数据的存储采用了近期最少使用算法。 Android开发中,如网络加载图片,如果不进行缓存,那么流量的消耗和体验是很...
  • u013568090
  • u013568090
  • 2016-06-25 12:38:50
  • 505

java 基于linkedhashmap实现LRUCache

所谓LRU就是最近最少被使用的意思,LRU算法的
  • pingnanlee
  • pingnanlee
  • 2014-10-29 14:40:35
  • 3012

利用LinkedHashMap实现一个简单的LUR(Least Recently Used 近期最少使用算法)的cache的两种方法

利用LinkedHashMap实现一个简单的LUR(Least Recently Used 近期最少使用算法)的cache的两种方法在做LeetCode题目的时候遇到的这个算法,简单的学习了下Link...
  • tonyNiko
  • tonyNiko
  • 2016-04-24 16:09:09
  • 738

HashMap和有序LinkedHashMap实现对比

LinkedHashMap:LinkedHashMap简单来说是一个有序的HashMap,其是HashMap的子类,HashMap是无序的。接下来我们通过对比分析HashMap和LinkedHashM...
  • qq924862077
  • qq924862077
  • 2017-07-05 12:29:51
  • 3122
    个人资料
    等级:
    访问量: 844
    积分: 111
    排名: 122万+
    文章存档