手把手教你学会LrhCache算法

最新推荐文章于 2022-09-23 20:55:06 发布
最新推荐文章于 2022-09-23 20:55:06 发布
阅读量334 收藏
点赞数
分类专栏： android基础知识收集

转载：https://blog.csdn.net/carson_ho/article/details/82453606

前言

  • 内存缓存知识在Android开发中实现重要
  • 本文将全面介绍内存缓存的所有相关知识（含LrhCache算法、其原理等），希望您们会喜欢

目录

内存缓存

1. 简介

示意图

下面，将详细介绍 LrhCache算法

2. LrhCache算法

示意图

3. 实现原理

  • LrhCache算法的算法核心 = LRU 算法 + LinkedHashMap数据结构
  • 下面，我将先介绍LRU 算法 和 LinkedHashMap数据结构，最后再介绍LrhCache算法

3.1 LRU 算法

  • 定义：Least Recently Used，即 近期最少使用算法
  • 算法原理：当缓存满时，优先淘汰 近期最少使用的缓存对象 
    采用  LRU 算法的缓存类型：内存缓存（ LrhCache） 、 硬盘缓存（ DisLruCache）

3.2 LinkedHashMap 介绍

  • 数据结构 = 数组 +单链表 + 双向链表
  • 其中，双向链表 实现了 存储顺序 = 访问顺序 / 插入顺序 
    1. 使得LinkedHashMap 中的<key,value>对 按照一定顺序进行排列 
    2. 通过 构造函数 指定LinkedHashMap中双向链表的结构是访问顺序 or 插入顺序

 

/** 
  * LinkedHashMap 构造函数
  * 参数accessOrder = true时，存储顺序（遍历顺序） = 外部访问顺序；为false时，存储顺序（遍历顺序） = 插入顺序
  **/ 
  public LinkedHashMap(int initialCapacity,
                         float loadFactor,
                         boolean accessOrder) {

        super(initialCapacity, loadFactor);
        this.accessOrder = accessOrder;

    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 实例演示

当 accessOrder 参数设置为true时，存储顺序（遍历顺序） = 外部访问顺序

  /** 
    * 实例演示
    **/ 
    // 1. accessOrder参数设置为true时
    LinkedHashMap<Integer, Integer> map = new LinkedHashMap<>(0, 0.75f, true);

    // 2. 插入数据
    map.put(0, 0);
    map.put(1, 1);
    map.put(2, 2);
    map.put(3, 3);
    map.put(4, 4);
    map.put(5, 5);
    map.put(6, 6);

    // 3. 访问数据
        map.get(1);
        map.get(2);

     // 遍历获取LinkedHashMap内的数据
     for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
            System.out.println(entry.getKey() + ":" + entry.getValue());

        }


  /** 
    * 测试结果
    **/ 
   0:0
   3:3
   4:4
   5:5
   6:6
   1:1
   2:2

// 即实现了 最近访问的对象 作为 最后输出
// 该逻辑 = LrhCache缓存算法思想
// 可见LruCache的实现是利用了LinkedHashMap数据结构的实现原理
// 请看LruCache的构造方法

 public LruCache(int maxSize) {
        if (maxSize <= 0) {
            throw new IllegalArgumentException("maxSize <= 0");
        }
        this.maxSize = maxSize;

        this.map = new LinkedHashMap<K, V>(0, 0.75f, true);
        // 创建LinkedHashMap时传入true。即采用了存储顺序 = 外界访问顺序 = 最近访问的对象 作为 最后输出
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51

3.3 LrhCache 算法原理

示意图

  • 示意图

示意图

4. 使用流程

/** 
  * 使用流程（以加载图片为例）
  **/ 

    private LruCache<String, Bitmap> mMemoryCache; 

    // 1. 获得虚拟机能提供的最大内存
    // 注：超过该大小会抛出OutOfMemory的异常 
    final int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024); 

    // 2. 设置LruCache缓存的大小 = 一般为当前进程可用容量的1/8
    // 注：单位 = Kb
    // 设置准则
    //  a. 还剩余多少内存给你的activity或应用使用
    //  b. 屏幕上需要一次性显示多少张图片和多少图片在等待显示
    //  c. 手机的大小和密度是多少（密度越高的设备需要越大的 缓存）
    //  d. 图片的尺寸（决定了所占用的内存大小）
    //  e. 图片的访问频率（频率高的在内存中一直保存）
    //  f. 保存图片的质量（不同像素的在不同情况下显示）
    final int cacheSize = maxMemory / 8; 

    // 3. 重写sizeOf方法：计算缓存对象的大小（此处的缓存对象 = 图片）
    mMemoryCache = new LruCache<String, Bitmap>(cacheSize) { 

        @Override 
        protected int sizeOf(String key, Bitmap bitmap) { 

            return bitmap.getByteCount() / 1024; 
            // 此处返回的是缓存对象的缓存大小（单位 = Kb） ，而不是item的个数
            // 注：缓存的总容量和每个缓存对象的大小所用单位要一致
            // 此处除1024是为了让缓存对象的大小单位 = Kb

        } 
    }; 

    // 4. 将需缓存的图片 加入到缓存
    mMemoryCache.put(key, bitmap); 

    // 5. 当 ImageView 加载图片时，会先在LruCache中看有没有缓存该图片：若有，则直接获取
    mMemoryCache.get(key);
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40

5. 实例讲解

 


  • 本实例以缓存图片为实例讲解
  • 具体代码 

 

请看注释 
MainActivity.java

public class MainActivity extends AppCompatActivity {

    public static final String TAG = "carsonTest：";
    private LruCache<String, Bitmap> mMemoryCache;
    private ImageView mImageView;
    private Button button;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // 1. 获得虚拟机能提供的最大内存
        // 注：超过该大小会抛出OutOfMemory的异常
        final int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);

        // 2. 设置LruCache缓存的大小 = 一般为当前进程可用容量的1/8
        // 注：单位 = Kb
        final int cacheSize = maxMemory / 8;

        // 3. 重写sizeOf方法：计算缓存对象的大小（此处的缓存对象 = 图片）
        mMemoryCache = new LruCache<String, Bitmap>(cacheSize) {

            @Override
            protected int sizeOf(String key, Bitmap bitmap) {
                return bitmap.getByteCount() / 1024;
                // 此处返回的是缓存对象的缓存大小（单位 = Kb） ，而不是item的个数
                // 注：缓存的总容量和每个缓存对象的大小所用单位要一致
                // 此处除1024是为了让缓存对象的大小单位 = Kb

            }
        };

        // 4. 点击按钮，则加载图片
        mImageView = (ImageView)findViewById(R.id.image);
        button = (Button)findViewById(R.id.btn);
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                // 加载图片 ->>分析1
                loadBitmap("test",mImageView);
            }

        });

    }

    /**
     * 分析1：加载图片
     * 加载前，先从内存缓存中读取；若无，则再从数据源中读取
     **/
    public void loadBitmap(String key, ImageView imageView) {

        // 读取图片前，先从内存缓存中读取：即看内存缓存中是否缓存了该图片
        // 1. 若有缓存，则直接从内存中加载
        Bitmap bitmap = mMemoryCache.get(key);

        if (bitmap != null) {
            mImageView.setImageBitmap(bitmap);
            Log.d(TAG, "从缓存中加载图片 ");

            // 2. 若无缓存，则从数据源加载（此处选择在本地加载） & 添加到缓存
        } else {
            Log.d(TAG, "从数据源（本地）中加载: ");

            // 2.1 从数据源加载
            mImageView.setImageResource(R.drawable.test1);

            // 2.1 添加到缓存
            // 注：在添加到缓存前，需先将资源文件构造成1个BitMap对象（含设置大小）
            Resources res = getResources();
            Bitmap bm = BitmapFactory.decodeResource(res, R.drawable.test1);

            // 获得图片的宽高
            int width = bm.getWidth();
            int height = bm.getHeight();

            // 设置想要的大小
            int newWidth = 80;
            int newHeight = 80;

            // 计算缩放比例
            float scaleWidth = ((float) newWidth) / width;
            float scaleHeight = ((float) newHeight) / height;
            // 取得想要缩放的matrix参数
            Matrix matrix = new Matrix();
            matrix.postScale(scaleWidth, scaleHeight);
            // 构造成1个新的BitMap对象
            Bitmap bitmap_s = Bitmap.createBitmap(bm, 0, 0, width, height, matrix, true);


            // 添加到缓存
            if (mMemoryCache.get(key) == null) {
                mMemoryCache.put(key, bitmap_s);
                Log.d(TAG, "添加到缓存: " + (mMemoryCache.get(key)));
            }


        }
    }

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:focusableInTouchMode="true"
    android:orientation="vertical">

    <ImageView
       android:id="@+id/image"
       android:layout_width="200dp"
       android:layout_height="200dp"
       android:layout_gravity="center"

        />

    <Button
        android:id="@+id/btn"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_margin="10dp"
        android:text="点击加载"
        android:layout_gravity="center"
        />

</LinearLayout>
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 测试结果 
    第1次点击加载图片时，由于无缓存则从本地加载 
    第2次（以后）点击加载图片时，由于有缓存，所以直接从缓存中读取 
    示意图

6. 源码分析

此处主要分析 写入缓存 & 获取缓存 ，即put（）、 get（）

6.1 添加缓存：put()

  • 源码分析
/** 
  * 使用函数（以加载图片为例）
  **/ 
  mMemoryCache.put（key，bitmap）；

/** 
  * 源码分析
  **/ 
 public final V put(K key, V value) {

        // 1. 判断 key 与 value是否为空
        //  若二者之一味空，否则抛出异常
        if (key == null || value == null) {
            throw new NullPointerException("key == null || value == null");
        }

        V previous;

        synchronized (this) {

            // 2. 插入的缓存对象值加1
            putCount++; 

            // 3. 增加已有缓存的大小
            size += safeSizeOf(key, value); 

            // 4. 向map中加入缓存对象
            previous = map.put(key, value);

            // 5. 若已有缓存对象，则缓存大小恢复到之前
            if (previous != null) {
                size -= safeSizeOf(key, previous);
            }
        }

        // 6. 资源回收（移除旧缓存时会被调用）
        // entryRemoved()是个空方法，可自行实现
        if (previous != null) {
            entryRemoved(false, key, previous, value);
        }

        // 7. 添加缓存对象后，调用需判断缓存是否已满
        // 若满了就删除近期最少使用的对象-->分析2
        trimToSize(maxSize);

        return previous;
    }

/** 
  * 分析1：trimToSize(maxSize)
  * 原理：不断删除LinkedHashMap中队尾的元素，即近期最少访问的元素，直到缓存大小 < 最大值
  **/ 
  public void trimToSize(int maxSize) {

        //死循环
        while (true) {
            K key;
            V value;
            synchronized (this) {
                // 判断1：若 map为空 & 缓存size ≠ 0 或 缓存size < 0，则抛出异常
                if (size < 0 || (map.isEmpty() && size != 0)) {
                    throw new IllegalStateException(getClass().getName()
                            + ".sizeOf() is reporting inconsistent results!");
                }

                // 判断2：若缓存大小size < 最大缓存 或 map为空，则不需删除缓存对象，跳出循环
                if (size <= maxSize || map.isEmpty()) {
                    break;
                }

                // 开始删除缓存对象
                // 使用迭代器获取第1个对象，即队尾的元素 = 近期最少访问的元素
                Map.Entry<K, V> toEvict = map.entrySet().iterator().next();
                key = toEvict.getKey();
                value = toEvict.getValue();
                // 删除该对象 & 更新缓存大小
                map.remove(key);
                size -= safeSizeOf(key, value);
                evictionCount++;
            }
            entryRemoved(true, key, value, null);
        }
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84

至此，关于添加缓存：put()的源码分析完毕。

6.2 获取缓存：get（）

  • 作用：获取缓存 & 更新队列

    1. 当调用 get() 获取缓存对象时，就代表访问了1次该元素
    2. 访问后将会更新队列，使得整个队列是按照 访问顺序 排列

  • 示意图如下 
    示意图

上述更新过程是在 get()中完成

  • 源码分析
/** 
  * 使用函数（以加载图片为例）
  **/ 
  mMemoryCache.get（key）；

/** 
  * 源码分析
  **/ 
  public final V get(K key) {

        // 1. 判断输入的合法性：若key为空，则抛出异常
        if (key == null) {
            throw new NullPointerException("key == null");
        }

        V mapValue;
        synchronized (this) {

            // 2. 获取对应的缓存对象 & 将访问的元素 更新到 队列头部->>分析3
            mapValue = map.get(key);

            if (mapValue != null) {
                hitCount++;
                return mapValue;
            }
            missCount++;
        }

/** 
  * 分析1：map.get(key)
  * 实际上是 LinkedHashMap.get() 
  **/ 
  public V get(Object key) {

        // 1. 获取对应的缓存对象
        LinkedHashMapEntry<K,V> e = (LinkedHashMapEntry<K,V>)getEntry(key);
        if (e == null)
            return null;

        // 2. 将访问的元素更新到队列头部 ->>分析4
        e.recordAccess(this);


        return e.value;
    }
/** 
  * 分析2：recordAccess（）
  **/ 
  void recordAccess(HashMap<K,V> m) {

            LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;

            // 1. 判断LinkedHashMap存储顺序是否按访问排序排序：根据构造函数传入的参数accessOrder判断
            if (lm.accessOrder) {
                lm.modCount++;
                // 2. 删除此元素
                remove();
                // 3. 将此元素移动到队列的头部
                addBefore(lm.header);
            }
        }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62

至此，关于获取缓存：get()的源码分析完毕。

7. 总结

本文全面讲解了内存缓存的相关知识，含LrhCache算法、原理等，下面是部分总结

  • 原理 
    示意图

  • 示意图 
    示意图

  • 源码流程 
    示意图

oneblue123
关注
专栏目录
Android内存缓存之LruCache
郭宝的博客
11-04 497
LruCache是什么？ LruCache 是least recentlly used 的简称，意思是最近最少使用算法，它可以实现将最近最少使用的对象回收掉，从而保证内存不会超出范围可将LruCache当成一个容器，它就相当于一个map集合。   为什么使用LruCache来管理内存？          因为从Android 2.3以后，垃圾回收机制会更倾向于回收持有软引用和弱引...
LRU Cache的简单c++实现
热门推荐
笑笑的程序人生
09-05 1万+
什么是 LRU LRU Cache是一个Cache的置换算法，含义是“最近最少使用”，把满足“最近最少使用”的数据从Cache中剔除出去，并且保证Cache中第一个数据是最近刚刚访问的，因为这样的数据更有可能被接下来的程序所访问。 LRU的应用比较广泛，最基础的内存页置换中就用了，对了，这里有个概念要清楚一下，Cache不见得是CPU的高速缓存的那个Cache，这里的Cache直接翻译为缓
Android内存缓存：手把手教你学会LrhCache算法
Carson带你学Android
09-06 9247
前言 内存缓存知识在Android开发中实现重要 本文将全面介绍内存缓存的所有相关知识（含LrhCache算法、其原理等），希望您们会喜欢 目录 1. 简介 下面，将详细介绍 LrhCache算法 2. LrhCache算法 3. 实现原理 LrhCache算法的算法核心 = LRU 算法 + LinkedHashMap数据结构 下面...
Android内存优化之内存缓存
东辉在线的专栏
06-16 3310
前言： 上面两篇博客已经讲了图片的基本知识和图片的加载方法及优化，所有的这些优化都是为了避免应用出现OOM这个问题。一个好的应用程序不仅要健壮不能出错还要方便用户使用，对于用户来说你的应用不仅要美观还要流畅，很快的呈现给他想要的。很快的加载图片除了加载的优化外还需要缓存，下面这篇博客将会讲图片缓存。 什么是缓存？ 缓存技术原理就是把用户访问的所有对象看作一个全集，经过算法标记哪些
谈谈LruCache算法的底层实现原理及其内部源码
weixin_34049948的博客
08-20 664
前言 我们在对数据进行操作的时候，为了避免流量或者性能的消耗，我们对于一些数据都会进行缓存处理，而对数据的缓存的要点不仅仅只有我们所熟悉的存储缓存和使用缓存，还有删除缓存。对于添加和获取缓存很好理解，那么为什么还要对缓存进行删除呐？原因很简单，因为我们的手机容量是有限的，如果我们拼命的写入缓存，那么终有一天内存会满导致程序奔溃，这显然不是我们想要的结果，于是我们在写入缓存的时候并非无脑写入，而是在...
手把手教你学dsp2812,手把手教你学dsp2812pdf下载,C,C++
09-10
《手把手教你学DSP2812》是一本专为初学者设计的 DSP（Digital Signal Processor）学习指南，主要围绕TI公司的TMS320F2812 DSP芯片进行讲解。这本书以其全面且易懂的特性，为读者提供了一个深入理解数字信号处理及其...
入门机器学习：手把手教你实现简单的算法
01-03
图像分类 - 使用机器学习算法对图片进行分类，可以应用于自动识别车辆模型、品类识别、安防等领域。 推荐系统 - 比如在电商平台上，根据用户的历史购买行为和喜好，使用机器学习算法生成个性化推荐，提高用户粘性、...
手把手教你使用Python实现机器学习算法.pdf
06-16
本文“手把手教你使用Python实现机器学习算法”将引导初学者逐步掌握如何利用Python进行机器学习实践。 首先，我们关注的库是`scikit-learn`（简称sklearn），这是一个强大的机器学习库，提供了各种预处理、模型...
手把手教你学DSP：基于TMS320F28335
10-16
手把手教你学DSP：基于TMS320F28335 手把手教你学DSP：基于TMS320F28335 手把手教你学DSP：基于TMS320F28335 手把手教你学DSP：基于TMS320F28335 手把手教你学DSP：基于TMS320F28335 手把手教你学DSP：基于TMS320F...
手把手教你用Java编写AdaBoost算法.zip
最新发布
04-30
AdaBoost算法Java实现提供了高效的分类解决方案。该资源包含完整的Java源代码、教程文档、示例数据和测试脚本，旨在帮助用户快速理解和应用AdaBoost算法。适用于对机器学习感兴趣的开发者、数据科学家以及需要提升...
Android文件缓存与内存缓存
10-19
可以解决listview组件加载网络图片时候出现的图片错位，以及缓存等
android LruCache内存缓存学习（重写sizeOf方法）
写博客只为学习
04-11 1503
什么是缓存？ 缓存技术原理就是把用户访问的所有对象看作一个全集，经过算法标记哪些是用户经常访问的对象，把这些对象放到一个集合里，这个集合是全集一个子集，下一次用户再访问的时候会先从这个子集集合中查找用户要访问的对象如果找到就直接返回这个对象，如果没有找到则再去全集中查找。当然了我这里说的只是原理性的东西，缓存是有很多算法的，并且有的不止一级缓存，这里就不过多讲了。 为什么要用到缓存？ 有缓存
带你了解Android常见的内存缓存算法
徐公，微信公众号同名
07-15 6583
带你了解Android常见的内存缓存算法本片博客主要简介以下两个问题 介绍一下常见的内存缓存算法 怎样实现这些算法 大家应该对ImageLoader这个框架都不陌生吧，一个很强大的图片加载框架，虽然作者去年的时候已经停止维护了，但里面的许多东西还是值得我们去学习的。本篇博客讲解的内存缓存算法正是基于ImageLoader的实现基础之上的常见的几种缓存算法 （1）LRU即Least RecentlyU
LRU Cache
weixin_30674525的博客
05-23 176
LRU Cache 题目链接：https://oj.leetcode.com/problems/lru-cache/ Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations:getandset. ge...
LRU cache算法
timeshark的专栏
10-14 311
LRU cache算法实现。 数据结构：hashmap 和 双向链表 #include #include #include //被注释部分是判断大端小端的代码 //union{ // short s; // char a[sizeof(short)]; //}un; // //using namespace std; // //int main() //{ // un.s = 0x010
LruCache算法
alex
11-04 2545
LruCache （Least Recently Used Cache）近期最少使用 当初接触LRU算法是在学习操作系统时接触到，内存管理的一种页面置换算法，采用局部性原理。 Android开发中，imageLoader等一些开源框架中使用此算法。LruCache的原理 内部存在一个LinkedHashMap和maxSize，给出来put和get方法，每次put图片时计算缓存中所有
LRUCache算法
大魔王
06-13 1560
设计一种数据结构实现LRU算法，查询以及插入操作时间复杂度为O(1)，并且满足最近最少使用原则。如果一个数据在最近一段时间没有被访问到，那么在将来它被访问的可能性也很小。当限定的空间已存满数据时，应当把最久没有被访问到的数据淘汰。 Design and implement a data structure for Least Recently Used (LRU) cache. It shou...
Android LruCache
mChenys的博客
09-23 2015
当调用put()方法时，就会在集合中添加元素，并调用trimToSize()判断缓存是否已满，如果满了就用LinkedHashMap的迭代器删除队首元素，即近期最少访问的元素。当调用LruCache的get()方法获取集合中的缓存对象时，就代表访问了一次该元素，将会更新队列，保持整个队列是按照访问顺序排序。有以上结果可以看出，这个设置为true时，如果对一个元素进行了操作(put,get)，就会把那个元素放到集合的最后，设置为false时，无论怎么操作，集合元素的顺序都是按照插入的顺序来进行存储的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值