Android提供的LruCache类简介(1)

13. * 

    If your cached values hold resources that need to be explicitly released,

14. * override {@link #entryRemoved}.

15. * 如果你cache的某个值需要明确释放，重写entryRemoved()

16. * 

    If a cache miss should be computed on demand for the corresponding keys,

17. * override {@link #create}. This simplifies the calling code, allowing it to

18. * assume a value will always be returned, even when there’s a cache miss.

19. * 如果key相对应的item丢掉啦，重写create().这简化了调用代码，即使丢失了也总会返回。

20. * 

    By default, the cache size is measured in the number of entries. Override

21. * {@link #sizeOf} to size the cache in different units. For example, this cache

22. * is limited to 4MiB of bitmaps: 默认cache大小是测量的item的数量，重写sizeof计算不同item的

23. *  大小。

24. * 

       {@code

25. *   int cacheSize = 4 * 1024 * 1024; // 4MiB

26. *   LruCache<String, Bitmap> bitmapCache = new LruCache<String, Bitmap>(cacheSize) {

27. *       protected int sizeOf(String key, Bitmap value) {

28. *           return value.getByteCount();

29. *       }

30. *   }}

31. *

32. * 

    This class is thread-safe. Perform multiple cache operations atomically by

33. * synchronizing on the cache: 

       {@code

34. *   synchronized (cache) {

35. *     if (cache.get(key) == null) {

36. *         cache.put(key, value);

37. *     }

38. *   }}

39. *

40. * 

    This class does not allow null to be used as a key or value. A return

41. * value of null from {@link #get}, {@link #put} or {@link #remove} is

42. * unambiguous: the key was not in the cache.

43. * 不允许key或者value为null

44. *  当get（），put（），remove（）返回值为null时，key相应的项不在cache中

45. */

46. public class LruCache<K, V> {

47. private final LinkedHashMap<K, V> map;

48. /** Size of this cache in units. Not necessarily the number of elements. */

49. private int size; //已经存储的大小

50. private int maxSize; //规定的最大存储空间

51. private int putCount;  //put的次数

52. private int createCount;  //create的次数

53. private int evictionCount;  //回收的次数

54. private int hitCount;  //命中的次数

55. private int missCount;  //丢失的次数

56. /**

57. * @param maxSize for caches that do not override {@link #sizeOf}, this is

58. *     the maximum number of entries in the cache. For all other caches,

59. *     this is the maximum sum of the sizes of the entries in this cache.

60. */

61. public LruCache(int maxSize) {

62. if (maxSize <= 0) {

63. throw new IllegalArgumentException(“maxSize <= 0”);

64. }

65. this.maxSize = maxSize;

66. this.map = new LinkedHashMap<K, V>(0, 0.75f, true);

67. }

68. /**

69. * Returns the value for {@code key} if it exists in the cache or can be

70. * created by {@code #create}. If a value was returned, it is moved to the

71. * head of the queue. This returns null if a value is not cached and cannot

72. * be created. 通过key返回相应的item，或者创建返回相应的item。相应的item会移动到队列的头部，

73. * 如果item的value没有被cache或者不能被创建，则返回null。

74. */

75. public final V get(K key) {

76. if (key == null) {

77. throw new NullPointerException(“key == null”);

78. }

79. V mapValue;

80. synchronized (this) {

81. mapValue = map.get(key);

82. if (mapValue != null) {

83. hitCount++;  //命中

84. return mapValue;

85. }

86. missCount++;  //丢失

87. }

88. /*

89. * Attempt to create a value. This may take a long time, and the map

90. * may be different when create() returns. If a conflicting value was

91. * added to the map while create() was working, we leave that value in

92. * the map and release the created value.

93. * 如果丢失了就试图创建一个item

94. */

95. V createdValue = create(key);

96. if (createdValue == null) {

97. return null;

98. }

99. synchronized (this) {

100. createCount++;//创建++

101. mapValue = map.put(key, createdValue);

102. if (mapValue != null) {

103. // There was a conflict so undo that last put

104. //如果前面存在oldValue，那么撤销put（）

105. map.put(key, mapValue);

106. } else {

107. size += safeSizeOf(key, createdValue);

108. }

109. }

110. if (mapValue != null) {

111. entryRemoved(false, key, createdValue, mapValue);

112. return mapValue;

113. } else {

114. trimToSize(maxSize);

115. return createdValue;

116. }

117. }

118. /**

119. * Caches {@code value} for {@code key}. The value is moved to the head of

120. * the queue.

121. *

122. * @return the previous value mapped by {@code key}.

123. */

124. public final V put(K key, V value) {

125. if (key == null || value == null) {

126. throw new NullPointerException(“key == null || value == null”);

127. }

128. V previous;

129. synchronized (this) {

130. putCount++;

131. size += safeSizeOf(key, value);

132. previous = map.put(key, value);

133. if (previous != null) {  //返回的先前的value值

134. size -= safeSizeOf(key, previous);

135. }

136. }

137. if (previous != null) {

138. entryRemoved(false, key, previous, value);

139. }

140. trimToSize(maxSize);

141. return previous;

142. }

143. /**

144. * @param maxSize the maximum size of the cache before returning. May be -1

145. *     to evict even 0-sized elements.

146. *  清空cache空间

147. */

148. private void trimToSize(int maxSize) {

149. while (true) {

150. K key;

151. V value;

152. synchronized (this) {

153. if (size < 0 || (map.isEmpty() && size != 0)) {

154. throw new IllegalStateException(getClass().getName()

155. + “.sizeOf() is reporting inconsistent results!”);

156. }

157. if (size <= maxSize) {

158. break;

159. }

160. Map.Entry<K, V> toEvict = map.eldest();

161. if (toEvict == null) {

162. break;

163. }

164. key = toEvict.getKey();

165. value = toEvict.getValue();

166. map.remove(key);

167. size -= safeSizeOf(key, value);

168. evictionCount++;

169. }

170. entryRemoved(true, key, value, null);

171. }

172. }

173. /**

174. * Removes the entry for {@code key} if it exists.

175. * 删除key相应的cache项，返回相应的value

176. * @return the previous value mapped by {@code key}.

177. */

178. public final V remove(K key) {

179. if (key == null) {

180. throw new NullPointerException(“key == null”);

181. }

182. V previous;

183. synchronized (this) {

184. previous = map.remove(key);

185. if (previous != null) {

186. size -= safeSizeOf(key, previous);

187. }

188. }

189. if (previous != null) {

190. entryRemoved(false, key, previous, null);

191. }

192. return previous;

193. }

194. /**

195. * Called for entries that have been evicted or removed. This method is

196. * invoked when a value is evicted to make space, removed by a call to

197. * {@link #remove}, or replaced by a call to {@link #put}. The default

198. * implementation does nothing.

199. * 当item被回收或者删掉时调用。改方法当value被回收释放存储空间时被remove调用，

200. * 或者替换item值时put调用，默认
     实现什么都没做。

201. * 

     The method is called without synchronization: other threads may

202. * access the cache while this method is executing.

203. *

204. * @param evicted true if the entry is being removed to make space, false

205. *     if the removal was caused by a {@link #put} or {@link #remove}.

206. * true—为释放空间被删除；false—put或remove导致

207. * @param newValue the new value for {@code key}, if it exists. If non-null,

208. *     this removal was caused by a {@link #put}. Otherwise it was caused by

209. *     an eviction or a {@link #remove}.

210. */

211. protected void entryRemoved(boolean evicted, K key, V oldValue, V newValue) {}

212. /**

213. * Called after a cache miss to compute a value for the corresponding key.

214. * Returns the computed value or null if no value can be computed. The

215. * default implementation returns null.

216. * 当某Item丢失时会调用到，返回计算的相应的value或者null

217. * 

     The method is called without synchronization: other threads may

218. * access the cache while this method is executing.

219. *

220. * 

     If a value for {@code key} exists in the cache when this method

221. * returns, the created value will be released with {@link #entryRemoved}

222. * and discarded. This can occur when multiple threads request the same key

223. * at the same time (causing multiple values to be created), or when one

224. * thread calls {@link #put} while another is creating a value for the same

225. * key.

226. */

227. protected V create(K key) {

228. return null;

229. }

230. private int safeSizeOf(K key, V value) {

231. int result = sizeOf(key, value);

232. if (result < 0) {

233. throw new IllegalStateException("Negative size: " + key + “=” + value);

234. }

235. return result;

236. }

237. /**

238. * Returns the size of the entry for {@code key} and {@code value} in

239. * user-defined units.  The default implementation returns 1 so that size

240. * is the number of entries and max size is the maximum number of entries.

241. * 返回用户定义的item的大小，默认返回1代表item的数量，最大size就是最大item值

242. * 

     An entry’s size must not change while it is in the cache.

243. */

244. protected int sizeOf(K key, V value) {

245. return 1;

246. }

247. /**

248. * Clear the cache, calling {@link #entryRemoved} on each removed entry.

最后

小编这些年深知大多数初中级Android工程师，想要提升自己，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此我收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人

都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

资料⬅专栏获取
0.      */

271. protected int sizeOf(K key, V value) {

272. return 1;

273. }

274. /**

275. * Clear the cache, calling {@link #entryRemoved} on each removed entry.

最后

小编这些年深知大多数初中级Android工程师，想要提升自己，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此我收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

[外链图片转存中…(img-7R2o989d-1718991877996)]

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人

都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

资料⬅专栏获取