2024年安卓最新LRUCache源码分析，android组件化面试题

最后

在这里我和身边一些朋友特意整理了一份快速进阶为Android高级工程师的系统且全面的学习资料。涵盖了Android初级——Android高级架构师进阶必备的一些学习技能。

附上：我们之前因为秋招收集的二十套一二线互联网公司Android面试真题（含BAT、小米、华为、美团、滴滴）和我自己整理Android复习笔记（包含Android基础知识点、Android扩展知识点、Android源码解析、设计模式汇总、Gradle知识点、常见算法题汇总。）

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

• @param key The key to check.

*/

@Nullable

public synchronized Y get(T key) {

return cache.get(key);

}

/**

• Adds the given item to the cache with the given key and returns any previous entry for the

• given key that may have already been in the cache.

• If the size of the item is larger than the total cache size, the item will not be added to

• the cache and instead {@link #onItemEvicted(Object, Object)} will be called synchronously with

• the given key and item.

• @param key The key to add the item at.

• @param item The item to add.

*/

public synchronized Y put(T key, Y item) {

final int itemSize = getSize(item);

if (itemSize >= maxSize) {

onItemEvicted(key, item);

return null;

}

final Y result = cache.put(key, item);

if (item != null) {

currentSize += getSize(item);

}

if (result != null) {

// TODO: should we call onItemEvicted here?

currentSize -= getSize(result);

}

evict();

return result;

}

/**

• Removes the item at the given key and returns the removed item if present, and null otherwise.

• @param key The key to remove the item at.

*/

@Nullable

public synchronized Y remove(T key) {

final Y value = cache.remove(key);

if (value != null) {

currentSize -= getSize(value);

}

return value;

}

/**

• Clears all items in the cache.

*/

public void clearMemory() {

trimToSize(0);

}

/**

• Removes the least recently used items from the cache until the current size is less than the

• given size.

• @param size The size the cache should be less than.

*/

protected synchronized void trimToSize(int size) {

Map.Entry<T, Y> last;

while (currentSize > size) {

last = cache.entrySet().iterator().next();

final Y toRemove = last.getValue();

currentSize -= getSize(toRemove);

final T key = last.getKey();

cache.remove(key);

onItemEvicted(key, toRemove);

}

}

private void evict() {

trimToSize(maxSize);

}

}

什么是LRU算法？ LRU是Least Recently Used的缩写，即最近最少使用，主要基于这样一个现实：在前面几条指令中使用频繁的数据很可能在后面的几条指令中频繁使用

LruCache采用的集合是LinkedHashMap,这个集合是HashMap的基础上增加了 数据链表的功能，可以看到下面这个构造函数，第一个是初始容量100， 第二个是碰撞因子0.75（即真实容量到达总容量的75%就开始扩容），第三个是链表顺序是否按访问顺序，关于这个容器的代码分析我们放在下一篇文章，在这里我们只需要知道这个集合能记录到你访问数据的次序，最近的访问的会放在链表的前面

private final LinkedHashMap<T, Y> cache = new LinkedHashMap<>(100, 0.75f, true);

initialMaxSize：初始大小，maxSize：最大，currentSize：当前 三个成员变量，创建时this.initialMaxSize 和this.maxSize 一样。 注意setSizeMultiplier函数的作用是传入一个变化乘数，改变当前的最大容量

private final int initialMaxSize;

private int maxSize;

private int currentSize = 0;

public LruCache(int size) {

this.initialMaxSize = size;

this.maxSize = size;

}

public synchronized void setSizeMultiplier(float multiplier) {

if (multiplier < 0) {

throw new IllegalArgumentException(“Multiplier must be >= 0”);

}

maxSize = Math.round(initialMaxSize * multiplier);

evict();

}

evict意思是驱逐，就是把数据清除出缓存，把容量缩减到小于等于maxSize，while循环，处理当前大小大于入参的情况，取出链表中的一个，获取其value的大小，清除，更新当前容器容量，直到符合要求

protected synchronized void trimToSize(int size) {

Map.Entry<T, Y> last;

while (currentSize > size) {

last = cache.entrySet().iterator().next();

final Y toRemove = last.getValue();

currentSize -= getSize(toRemove);

final T key = last.getKey();

cache.remove(key);

onItemEvicted(key, toRemove);

}

}

private void evict() {

trimToSize(maxSize);

}

获取item的大小，默认现在是1 。比如要实现一个Bitmap 缓存是需要返回大小的，缓存的大小是取决于所有bitmap的总大小和，而不是总个数

protected int getSize(Y item) {

return 1;

}

一个清除元素发生的回调，让LruCache 的继承者选择自己做要的事

protected void onItemEvicted(T key, Y item) {

// optional override

}

常规操作不解释

public synchronized int getMaxSize() {

return maxSize;

}

public synchronized int getCurrentSize() {

return currentSize;

}

public synchronized boolean contains(T key) {

return cache.containsKey(key);

}

@Nullable

public synchronized Y get(T key) {

return cache.get(key);

}

ut操作，首先获取待加入的item 大小，如果大于缓存最大容量，就不放进去，直接调用onItemEvicte. 小于缓存最大容量，执行放入，item不为空，更新缓存当前大小。 执行放入的结果result就是说如果之前在容器内key存在，会执行替换value的操作，这时候result!=null,需要把替换出来的item的大小减去， 作者弄了个//TODO，不知道这里是否加上onItemEvicted 的回调，个人感觉应该加上，毕竟数据被清除缓存了，通知下，怎么处理交给继承者。 最后 evict()，因为单个待处理的item大小小于缓存最大容量，但是加入后，有可能超出，这里加个维护容量的代码

public synchronized Y put(T key, Y item) {

final int itemSize = getSize(item);

if (itemSize >= maxSize) {

onItemEvicted(key, item);

return null;

}

final Y result = cache.put(key, item);

if (item != null) {

currentSize += getSize(item);

}

if (result != null) {

// TODO: should we call onItemEvicted here?

currentSize -= getSize(result);

}

evict();

return result;

}

清除key出缓存，常规操作，维护当前缓存大小

public synchronized Y remove(T key) {

final Y value = cache.remove(key);

if (value != null) {

currentSize -= getSize(value);

}

return value;

}

让缓存容量小于等于0，起到clearMemory的作用

public void clearMemory() {

trimToSize(0);

}

2、为什么用LinkedHashMap

===================

LruCache原理和用法与LinkedHashMap（阅读量6472，7赞）

为什么要用LinkedHashMap来存缓存呢，这个跟算法有关，LinkedHashMap刚好能提供LRUCache需要的算法。

这个集合内部本来就有个排序功能，当第三个参数是true的时候，数据在被访问的时候就会排序，这个排序的结果就是把最近访问的数据放到集合的最后面。到时候删除的时候就从前面开始删除。

2.1、构造方法

---

LinkedHashMap有个构造方法是这样的：

/**

• Constructs an empty LinkedHashMap instance with the

• specified initial capacity, load factor and ordering mode.

• @param initialCapacity the initial capacity

• @param loadFactor the load factor

• @param accessOrder the ordering mode - true for

•     access-order, <tt>false</tt> for insertion-order
  

• @throws IllegalArgumentException if the initial capacity is negative

•     or the load factor is nonpositive
  

*/

public LinkedHashMap(int initialCapacity,

float loadFactor,

boolean accessOrder) {

super(initialCapacity, loadFactor);

this.accessOrder = accessOrder;

}

2.2、Entity的定义

---

LinkedHashMap内部是使用双向循环链表来存储数据的。也就是每一个元素都持有他上一个元素的地址和下一个元素的地址，看Entity的定义：

/**

• LinkedHashMap entry.

*/

private static class LinkedHashMapEntry<K,V> extends HashMapEntry<K,V> {

// These fields comprise the doubly linked list used for iteration.

LinkedHashMapEntry<K,V> before, after;

LinkedHashMapEntry(int hash, K key, V value, HashMapEntry<K,V> next) {

super(hash, key, value, next);

}

/**

• 从链表中删除这个元素

*/

private void remove() {

before.after = after;

after.before = before;

}

/**

• Inserts this entry before the specified existing entry in the list.

*/

private void addBefore(LinkedHashMapEntry<K,V> existingEntry) {

after = existingEntry;

before = existingEntry.before;

before.after = this;

after.before = this;

}

/**

• 当集合的get方法被调用时，会调用这个方法。

• 如果accessOrder为true，就把这个元素放在集合的最末端。

*/

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();

}

}

2.3、get方法的排序过程

---

看LinkedHashMap的get方法：

最后

**一个零基础的新人，我认为坚持是最最重要的。**我的很多朋友都找我来学习过，我也很用心的教他们，可是不到一个月就坚持不下来了。我认为他们坚持不下来有两点主要原因：

他们打算入行不是因为兴趣，而是因为所谓的IT行业工资高，或者说完全对未来没有任何规划。

刚开始学的时候确实很枯燥，这确实对你是个考验，所以说坚持下来也很不容易，但是如果你有兴趣就不会认为这是累，不会认为这很枯燥，总之还是贵在坚持。

技术提升遇到瓶颈了？缺高级Android进阶视频学习提升自己吗？还有大量大厂面试题为你面试做准备！

提升自己去挑战一下BAT面试难关吧

对于很多Android工程师而言，想要提升技能，往往是自己摸索成长，不成体系的学习效果低效漫长且无助。整理的这些知识图谱希望对Android开发的朋友们有所参考以及少走弯路，本文的重点是你有没有收获与成长，其余的都不重要，希望读者们能谨记这一点。

不论遇到什么困难，都不应该成为我们放弃的理由！

如果有什么疑问的可以直接私我，我尽自己最大力量帮助你！

最后祝各位新人都能坚持下来，学有所成。

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

的IT行业工资高，或者说完全对未来没有任何规划。

刚开始学的时候确实很枯燥，这确实对你是个考验，所以说坚持下来也很不容易，但是如果你有兴趣就不会认为这是累，不会认为这很枯燥，总之还是贵在坚持。

技术提升遇到瓶颈了？缺高级Android进阶视频学习提升自己吗？还有大量大厂面试题为你面试做准备！

提升自己去挑战一下BAT面试难关吧

[外链图片转存中…(img-CT6rvoah-1715817226316)]

对于很多Android工程师而言，想要提升技能，往往是自己摸索成长，不成体系的学习效果低效漫长且无助。整理的这些知识图谱希望对Android开发的朋友们有所参考以及少走弯路，本文的重点是你有没有收获与成长，其余的都不重要，希望读者们能谨记这一点。

不论遇到什么困难，都不应该成为我们放弃的理由！

如果有什么疑问的可以直接私我，我尽自己最大力量帮助你！

最后祝各位新人都能坚持下来，学有所成。

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！