Android提供的LruCache类简介，阿里三面

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

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

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

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

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

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

57. /**

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

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

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

61. */

62. public LruCache(int maxSize) {

63. if (maxSize <= 0) {

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

65. }

66. this.maxSize = maxSize;

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

68. }

69. /**

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

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

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

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

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

75. */

76. public final V get(K key) {

77. if (key == null) {

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

79. }

80. V mapValue;

81. synchronized (this) {

82. mapValue = map.get(key);

83. if (mapValue != null) {

84. hitCount++;  //命中

85. return mapValue;

86. }

87. missCount++;  //丢失

88. }

89. /*

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

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

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

93. * the map and release the created value.

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

95. */

96. V createdValue = create(key);

97. if (createdValue == null) {

98. return null;

99. }

100. synchronized (this) {

101. createCount++;//创建++

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

103. if (mapValue != null) {

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

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

106. map.put(key, mapValue);

107. } else {

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

109. }

110. }

111. if (mapValue != null) {

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

113. return mapValue;

114. } else {

115. trimToSize(maxSize);

116. return createdValue;

117. }

118. }

119. /**

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

121. * the queue.

122. *

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

124. */

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

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

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

128. }

129. V previous;

130. synchronized (this) {

131. putCount++;

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

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

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

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

136. }

137. }

138. if (previous != null) {

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

140. }

141. trimToSize(maxSize);

142. return previous;

143. }

144. /**

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

146. *     to evict even 0-sized elements.

147. *  清空cache空间

148. */

149. private void trimToSize(int maxSize) {

150. while (true) {

151. K key;

152. V value;

153. synchronized (this) {

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

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

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

157. }

158. if (size <= maxSize) {

159. break;

160. }

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

162. if (toEvict == null) {

163. break;

164. }

165. key = toEvict.getKey();

166. value = toEvict.getValue();

167. map.remove(key);

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

169. evictionCount++;

170. }

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

172. }

173. }

174. /**

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

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

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

178. */

179. public final V remove(K key) {

180. if (key == null) {

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

182. }

183. V previous;

184. synchronized (this) {

185. previous = map.remove(key);

186. if (previous != null) {

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

188. }

189. }

190. if (previous != null) {

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

192. }

193. return previous;

194. }

195. /**

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

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

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

199. * implementation does nothing.

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

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

202. * 

     The method is called without synchronization: other threads may

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级安卓工程师，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

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

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频
如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注Android）

总结

其实要轻松掌握很简单，要点就两个：

1. 找到一套好的视频资料，紧跟大牛梳理好的知识框架进行学习。
2. 多练。 （视频优势是互动感强，容易集中注意力）

你不需要是天才，也不需要具备强悍的天赋，只要做到这两点，短期内成功的概率是非常高的。

对于很多初中级Android工程师而言，想要提升技能，往往是自己摸索成长，不成体系的学习效果低效漫长且无助。下面资料部分截图是我花费几个月时间整理的，诚意满满：特别适合有3-5年开发经验的Android程序员们学习。

• 自行下载直达领取链接：【点击我即可获得！】
• 以上进阶BATJ大厂学习资料可以免费分享给大家，需要完整版的朋友，【点这里可以看到全部内容】。

你不需要是天才，也不需要具备强悍的天赋，只要做到这两点，短期内成功的概率是非常高的。

对于很多初中级Android工程师而言，想要提升技能，往往是自己摸索成长，不成体系的学习效果低效漫长且无助。下面资料部分截图是我花费几个月时间整理的，诚意满满：特别适合有3-5年开发经验的Android程序员们学习。

• 自行下载直达领取链接：【点击我即可获得！】
• 以上进阶BATJ大厂学习资料可以免费分享给大家，需要完整版的朋友，【点这里可以看到全部内容】。

[外链图片转存中…(img-b1oU62nS-1710568646109)]