public synchronized int getMaxSize() {
return maxSize;
}
/**
- Returns the sum of the sizes of all items in the cache.
*/
public synchronized int getCurrentSize() {
return currentSize;
}
/**
-
Returns true if there is a value for the given key in the cache.
-
@param key The key to check.
*/
public synchronized boolean contains(T key) {
return cache.containsKey(key);
}
/**
-
Returns the item in the cache for the given key or null if no such item exists.
-
@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方法：
public V get(Object key) {
LinkedHashMapEntry<K,V> e = (LinkedHashMapEntry<K,V>)getEntry(key);
if (e == null)
return null;
e.recordAccess(this);
return e.value;
}
具体是怎么进行排序的，画个图看看：
2.3.1、初始化
当LinkedHashMap初始化的时候，会有一个头节点header。
void init() {
header = new LinkedHashMapEntry<>(-1, null, null, null);
header.before = header.after = header;
总结
可以看出，笔者的工作学习模式便是由以下 「六个要点」 组成：
❝ 多层次的工作/学习计划 + 番茄工作法 + 定额工作法 + 批处理 + 多任务并行 + 图层工作法❞
希望大家能将这些要点融入自己的工作学习当中，我相信一定会工作与学习地更富有成效。
下面是我学习用到的一些书籍学习导图，以及系统的学习资料。每一个知识点，都有对应的导图，学习的资料，视频，面试题目。
**如：我需要学习 **Flutter的知识。（大家可以参考我的学习方法）
- Flutter 的思维导图（无论学习什么，有学习路线都会事半功倍）
- Flutter进阶学习全套手册
- Flutter进阶学习全套视频
大概就上面这几个步骤，这样学习不仅高效，而且能系统的学习新的知识。
《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》，点击传送门，即可获取！
。
void init() {
header = new LinkedHashMapEntry<>(-1, null, null, null);
header.before = header.after = header;
总结
可以看出，笔者的工作学习模式便是由以下 「六个要点」 组成：
❝ 多层次的工作/学习计划 + 番茄工作法 + 定额工作法 + 批处理 + 多任务并行 + 图层工作法❞
希望大家能将这些要点融入自己的工作学习当中，我相信一定会工作与学习地更富有成效。
下面是我学习用到的一些书籍学习导图，以及系统的学习资料。每一个知识点，都有对应的导图，学习的资料，视频，面试题目。
**如：我需要学习 **Flutter的知识。（大家可以参考我的学习方法）
- Flutter 的思维导图（无论学习什么，有学习路线都会事半功倍）
[外链图片转存中…(img-QzX7RJ3t-1715791316299)]
- Flutter进阶学习全套手册
[外链图片转存中…(img-pxHrtAms-1715791316303)]
- Flutter进阶学习全套视频
[外链图片转存中…(img-7r2mHgVy-1715791316304)]
大概就上面这几个步骤，这样学习不仅高效，而且能系统的学习新的知识。
《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》，点击传送门，即可获取！
1006
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
