个人中心
文章发布
退出
作者热门文章
- ubuntu12.04环境下使用kvm ioctl接口实现最简单的虚拟机
- Ubuntu 通过无线网络安装Ubuntu Server启动系统后连接无线网络的方法
- 在Ubuntu上搭建网桥的方法
- ubuntu 虚拟机上网方式及相关配置详解
25
4
CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.
这篇CFSDN的博客文章Java资源缓存 之 LruCache由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.
例如对 网络加载图片进行缓存 :
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
// 得到 应用程序 被分配的最大的内存
int
maxMemory=(
int
) Runtime.getRuntime().maxMemory();
// 取处内存的 1/5 用来当 缓存 大小
int
cachSize=maxMemory/
5
;
// 实例化 LruCache
lruCache=
new
lruCache<String, Bitmap>(cachSize){
//内部方法sizeOf设置每一张图片的缓存大小
protected
int
sizeOf(String key, Bitmap value) {
//在每次存入缓存时调用，告诉系统这张缓存图片有多大
// 相当于 为每次 要缓存的 资源 分配 大小空间
return
value.getByteCount();
}
};
|
上面的 代码 一般 放在初始化的 方法 里面 。
其实 可以将 LurCache 类 理解 为 Map 类 map 有 put和 get 方法 。
接下去就调用put 和 get 方法 进行需要缓存资源的存取 。
LurCache 的 add :
|
1
2
3
4
5
6
7
8
9
10
|
public
void
putBitmapToCache(String url,Bitmap bitmap){
if
(getBitmapfromCache(url)==
null
) {
//判断当前缓存是否存在
lruCache.put(url, bitmap);
}
}
LurCache 的 get：
public
Bitmap getBitmapfromCache(String url){
return
lruCache.get(url);
//可将lruCache看成map
}
|
调用上面的 add 和 get 方法 就可以对资源进行缓存的 ，还是挺简单的， 。
但要注意一点 LruCache lruCache=new LruCache<String, Bitmap>(cachSize) 只能被new 一次 ，不然不同对象就不同的缓存了 。
附上Android的Lrucache类 。
|
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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
|
package
android.util;
import
java.util.LinkedHashMap;
import
java.util.Map;
/**
* A cache that holds strong references to a limited number of values. Each time
* a value is accessed, it is moved to the head of a queue. When a value is
* added to a full cache, the value at the end of that queue is evicted and may
* become eligible for garbage collection.
* Cache保存一个强引用来限制内容数量，每当Item被访问的时候，此Item就会移动到队列的头部。
* 当cache已满的时候加入新的item时，在队列尾部的item会被回收。
* <p>If your cached values hold resources that need to be explicitly released,
* override {@link #entryRemoved}.
* 如果你cache的某个值需要明确释放，重写entryRemoved()
* <p>If a cache miss should be computed on demand for the corresponding keys,
* override {@link #create}. This simplifies the calling code, allowing it to
* assume a value will always be returned, even when there's a cache miss.
* 如果key相对应的item丢掉啦，重写create().这简化了调用代码，即使丢失了也总会返回。
* <p>By default, the cache size is measured in the number of entries. Override
* {@link #sizeOf} to size the cache in different units. For example, this cache
* is limited to 4MiB of bitmaps: 默认cache大小是测量的item的数量，重写sizeof计算不同item的
* 大小。
* <pre> {@code
* int cacheSize = 4 * 1024 * 1024; // 4MiB
* LruCache<String, Bitmap> bitmapCache = new LruCache<String, Bitmap>(cacheSize) {
* protected int sizeOf(String key, Bitmap value) {
* return value.getByteCount();
* }
* }}</pre>
*
* <p>This class is thread-safe. Perform multiple cache operations atomically by
* synchronizing on the cache: <pre> {@code
* synchronized (cache) {
* if (cache.get(key) == null) {
* cache.put(key, value);
* }
* }}</pre>
*
* <p>This class does not allow null to be used as a key or value. A return
* value of null from {@link #get}, {@link #put} or {@link #remove} is
* unambiguous: the key was not in the cache.
* 不允许key或者value为null
* 当get（），put（），remove（）返回值为null时，key相应的项不在cache中
*/
public
class
LruCache<K, V> {
private
final
LinkedHashMap<K, V> map;
/** Size of this cache in units. Not necessarily the number of elements. */
private
int
size;
//已经存储的大小
private
int
maxSize;
//规定的最大存储空间
private
int
putCount;
//put的次数
private
int
createCount;
//create的次数
private
int
evictionCount;
//回收的次数
private
int
hitCount;
//命中的次数
private
int
missCount;
//丢失的次数
/**
* @param maxSize for caches that do not override {@link #sizeOf}, this is
* the maximum number of entries in the cache. For all other caches,
* this is the maximum sum of the sizes of the entries in this cache.
*/
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
);
}
/**
* Returns the value for {@code key} if it exists in the cache or can be
* created by {@code #create}. If a value was returned, it is moved to the
* head of the queue. This returns null if a value is not cached and cannot
* be created. 通过key返回相应的item，或者创建返回相应的item。相应的item会移动到队列的头部，
* 如果item的value没有被cache或者不能被创建，则返回null。
*/
public
final
V get(K key) {
if
(key ==
null
) {
throw
new
NullPointerException(
"key == null"
);
}
V mapValue;
synchronized
(
this
) {
mapValue = map.get(key);
if
(mapValue !=
null
) {
hitCount++;
//命中
return
mapValue;
}
missCount++;
//丢失
}
/*
* Attempt to create a value. This may take a long time, and the map
* may be different when create() returns. If a conflicting value was
* added to the map while create() was working, we leave that value in
* the map and release the created value.
* 如果丢失了就试图创建一个item
*/
V createdValue = create(key);
if (createdValue == null) {
return null;
}
synchronized (this) {
createCount++;//创建++
mapValue = map.put(key, createdValue);
if (mapValue != null) {
// There was a conflict so undo that last put
//如果前面存在oldValue，那么撤销put（）
map.put(key, mapValue);
} else {
size += safeSizeOf(key, createdValue);
}
}
if (mapValue != null) {
entryRemoved(false, key, createdValue, mapValue);
return mapValue;
} else {
trimToSize(maxSize);
return createdValue;
}
}
/**
* Caches {@code value} for {@code key}. The value is moved to the head of
* the queue.
*
* @return the previous value mapped by {@code key}.
*/
public final V put(K key, V value) {
if (key == null || value == null) {
throw new NullPointerException("key == null || value == null");
}
V previous;
synchronized (this) {
putCount++;
size += safeSizeOf(key, value);
previous = map.put(key, value);
if (previous != null) { //返回的先前的value值
size -= safeSizeOf(key, previous);
}
}
if (previous != null) {
entryRemoved(false, key, previous, value);
}
trimToSize(maxSize);
return previous;
}
/**
* @param maxSize the maximum size of the cache before returning. May be -1
* to evict even 0-sized elements.
* 清空cache空间
*/
private void trimToSize(int maxSize) {
while (true) {
K key;
V value;
synchronized (this) {
if (size < 0 || (map.isEmpty() && size != 0)) {
throw new IllegalStateException(getClass().getName()
+ ".sizeOf() is reporting inconsistent results!");
}
if (size <= maxSize) {
break;
}
Map.Entry<K, V> toEvict = map.eldest();
if (toEvict == null) {
break;
}
key = toEvict.getKey();
value = toEvict.getValue();
map.remove(key);
size -= safeSizeOf(key, value);
evictionCount++;
}
entryRemoved(true, key, value, null);
}
}
/**
* Removes the entry for {@code key} if it exists.
* 删除key相应的cache项，返回相应的value
* @return the previous value mapped by {@code key}.
*/
public final V remove(K key) {
if (key == null) {
throw new NullPointerException("key == null");
}
V previous;
synchronized (this) {
previous = map.remove(key);
if (previous != null) {
size -= safeSizeOf(key, previous);
}
}
if (previous != null) {
entryRemoved(false, key, previous, null);
}
return previous;
}
/**
* Called for entries that have been evicted or removed. This method is
* invoked when a value is evicted to make space, removed by a call to
* {@link #remove}, or replaced by a call to {@link #put}. The default
* implementation does nothing.
* 当item被回收或者删掉时调用。改方法当value被回收释放存储空间时被remove调用，
* 或者替换item值时put调用，默认实现什么都没做。
* <p>The method is called without synchronization: other threads may
* access the cache while this method is executing.
*
* @param evicted true if the entry is being removed to make space, false
* if the removal was caused by a {@link #put} or {@link #remove}.
* true---为释放空间被删除；false---put或remove导致
* @param newValue the new value for {@code key}, if it exists. If non-null,
* this removal was caused by a {@link #put}. Otherwise it was caused by
* an eviction or a {@link #remove}.
*/
protected void entryRemoved(boolean evicted, K key, V oldValue, V newValue) {}
/**
* Called after a cache miss to compute a value for the corresponding key.
* Returns the computed value or null if no value can be computed. The
* default implementation returns null.
* 当某Item丢失时会调用到，返回计算的相应的value或者null
* <p>The method is called without synchronization: other threads may
* access the cache while this method is executing.
*
* <p>If a value for {@code key} exists in the cache when this method
* returns, the created value will be released with {@link #entryRemoved}
* and discarded. This can occur when multiple threads request the same key
* at the same time (causing multiple values to be created), or when one
* thread calls {@link #put} while another is creating a value for the same
* key.
*/
protected V create(K key) {
return null;
}
private int safeSizeOf(K key, V value) {
int result = sizeOf(key, value);
if (result < 0) {
throw new IllegalStateException("Negative size: " + key + "=" + value);
}
return result;
}
/**
* Returns the size of the entry for {@code key} and {@code value} in
* user-defined units. The default implementation returns 1 so that size
* is the number of entries and max size is the maximum number of entries.
* 返回用户定义的item的大小，默认返回1代表item的数量，最大size就是最大item值
* <p>An entry's size must not change while it is in the cache.
*/
protected int sizeOf(K key, V value) {
return 1;
}
/**
* Clear the cache, calling {@link #entryRemoved} on each removed entry.
* 清空cacke
*/
public final void evictAll() {
trimToSize(-1); // -1 will evict 0-sized elements
}
/**
* For caches that do not override {@link #sizeOf}, this returns the number
* of entries in the cache. For all other caches, this returns the sum of
* the sizes of the entries in this cache.
*/
public synchronized final int size() {
return size;
}
/**
* For caches that do not override {@link #sizeOf}, this returns the maximum
* number of entries in the cache. For all other caches, this returns the
* maximum sum of the sizes of the entries in this cache.
*/
public synchronized final int maxSize() {
return maxSize;
}
/**
* Returns the number of times {@link #get} returned a value that was
* already present in the cache.
*/
public synchronized final int hitCount() {
return hitCount;
}
/**
* Returns the number of times {@link #get} returned null or required a new
* value to be created.
*/
public synchronized final int missCount() {
return missCount;
}
/**
* Returns the number of times {@link #create(Object)} returned a value.
*/
public synchronized final int createCount() {
return createCount;
}
/**
* Returns the number of times {@link #put} was called.
*/
public synchronized final int putCount() {
return putCount;
}
/**
* Returns the number of values that have been evicted.
* 返回被回收的数量
*/
public synchronized final int evictionCount() {
return evictionCount;
}
/**
* Returns a copy of the current contents of the cache, ordered from least
* recently accessed to most recently accessed. 返回当前cache的副本，从最近最少访问到最多访问
*/
public
synchronized
final
Map<K, V> snapshot() {
return
new
LinkedHashMap<K, V>(map);
}
@Override
public
synchronized
final
String toString() {
int
accesses = hitCount + missCount;
int
hitPercent = accesses !=
0
? (
100
* hitCount / accesses) :
0
;
return
String.format(
"LruCache[maxSize=%d,hits=%d,misses=%d,hitRate=%d%%]"
,
maxSize, hitCount, missCount, hitPercent);
}
}
|
最后此篇关于Java资源缓存 之 LruCache的文章就讲到这里了,如果你想了解更多关于Java资源缓存 之 LruCache的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。
25
4
0
我的应用程序中的多个 Activity 在 ListView 中显示图像，其中 ListView 的每一行都包含一个 ImageView. 这方面的一个示例是用户搜索、获取结果并显示每个结果的图片的搜
一 点睛 强引用（Strong Reference）是我们使用最多的一种对象引用，当一个对象被关键字 new 实例化出来的时候， JVM 会在堆（heap）内存中开辟一个内存区域，用于存放与该实例对应
我使用了代码 android lrucache example (Memory Cache)缓存下载的图像(总共将近 120 KB)并且它可以工作，但是当我从 Activity (或应用程序)中退出时
我正在阅读这篇文章来了解 Java 中的 LRUCache - Java LRU cache using LinkedList 这篇文章中有一个解决方案: public class LRUCache
我正在考虑为 Android 实现离线模式，但为了实现这一目标，我需要实现一个缓存系统。我读到人们建议 LruCache 并在这里看到了图像的示例 LruCache Example 。现在我不缓存图像
我正在尝试遵循有关 LruCache 使用的 2 年历史的 android 教程，到目前为止我在 Google 上搜索的一些示例具有相同的方法，即传递一个转换为 KiB 的值(int)。 final
我不能完全理解 LruCache 的内存管理组件。 从某种意义上说，我希望它能充当 iOS 平台上的 NSCache(最近刚刚从该操作系统中学到了一些知识)。 如果应用程序内存不足，LruCache
以下示例表明，在 LRUCache 之外分配新空间时，使用有限大小的 LRUCache 会导致 OutOfMemory 错误。 属性:64MB 进程大小； 10MB LRUCache 大小；我循环放入
我正在使用 LruCache 来缓存我的应用程序中使用的大量小 BitmapDrawables。问题是尺寸因我使用图像的不同位置而异。 我在从缓存中检索可绘制对象时设置边界，然后再将其设置为 Imag
我是 android 中 LruCache 的新手，我想在此缓存上放置和获取位图图像 (JPEG) 以防止内存错误和内存异常，所以我不明白为什么我的代码不起作用。这是我的代码: ImageView i
我已经在 Android 中实现了一个存储对象的标准 LRUCache。每个键都是与存储的对象关联的唯一 ObjectId。我的问题是从缓存中检索对象的唯一方法是通过 ObjectId(无迭代器)。实
final int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024); final int cacheSize = max
例如对 网络加载图片进行缓存 ： ? 1
我尝试解决 LeetCode 中的问题，要求实现一个LRUCache。当我提交代码时，系统告诉我结果是错误答案。 由于测试用例太长，我在代码中找不到问题。当我选择“运行代码”来提交我的代码时，它是正确
我可以在 Cachetools 的 LRUCache 实现中使用多个/组合键吗？我想像下面这样使用它 def fun(a,b): pass x = LRUCache(maxsize=100,missi
我有一个 LRUCache，用于缓存缩略图和其他类似的小位图。目前，我在我的主要 Activity 中使用它，但是，我也想在我的其他 Activity 中使用它。这让我想知道将这个 LRUCache
我从 developer.android.com 上读到了关于使用 LruCache 的信息，我从一个 Activity 中创建了一个模糊的 Bitmap 并将其放入缓存中，现在我想访问来自另一个 A
我一直在尝试在我的应用程序中实现 LruCache，但我在连接点和在不同组件之间传递位图时遇到困难。 我想知道如何在我的应用程序中集成 LruCache。我也想了解实现 LruCache 的过程，所以
我正在尝试在 android 中使用 LruCache 来缓存一些图像，但它没有缓存 这是代码 int cacheSize1 = 4 * 1024 * 1024; // 4MiB bit
我有以下代码来缓存位图，当我尝试使用它们的键检索它们时。他们总是返回 null 。请帮我 。谢谢你 final int memClass = ((ActivityManager) mcontext.
我是一名优秀的程序员,十分优秀！