1. }
  • 本地缓存优化

[java]  view plain copy

1. /**
2. *计算存储目录下的文件大小，当文件总大小大于规定的CACHE_SIZE或者sdcard剩余空间小于FREE_SD_SPACE_NEEDED_TO_CACHE的规定
3. * 那么删除40%最近没有被使用的文件
4. * @param dirPath
5. * @param filename
6. */
7. private void removeCache(String dirPath) {
8. File dir = new File(dirPath);
9. File[] files = dir.listFiles();
10. if (files == null) {
11. return;
12. }
13. int dirSize = 0;
14. for (int i = 0; i < files.length;i++) {
15. if(files[i].getName().contains(WHOLESALE_CONV)) {
16. dirSize += files[i].length();
17. }
18. }
19. if (dirSize > CACHE_SIZE * MB ||FREE_SD_SPACE_NEEDED_TO_CACHE > freeSpaceOnSd()) {
20. int removeFactor = (int) ((0.4 *files.length) + 1);
21. Arrays.sort(files, newFileLastModifSort());
22. Log.i(TAG, "Clear some expiredcache files ");
23. for (int i = 0; i <removeFactor; i++) {
24. if(files[i].getName().contains(WHOLESALE_CONV)) {
25. files[i].delete();
26. }
27. }
28. }
29. }
30. /**
31. * 删除过期文件
32. * @param dirPath
33. * @param filename
34. */
35. private void removeExpiredCache(StringdirPath, String filename) {
36. File file = new File(dirPath,filename);
37. if (System.currentTimeMillis() -file.lastModified() > mTimeDiff) {
38. Log.i(TAG, "Clear some expiredcache files ");
39. file.delete();
40. }
41. }
• 文件使用时间排序
[java]  view plain copy
1. /**
2. * TODO 根据文件的最后修改时间进行排序 *
3. */
4. classFileLastModifSort implements Comparator{
5. public int compare(File arg0, File arg1) {
6. if (arg0.lastModified() >arg1.lastModified()) {
7. return 1;
8. } else if (arg0.lastModified() ==arg1.lastModified()) {
9. return 0;
10. } else {
11. return -1;
12. }
13. }
14. }

内存保存：

在内存中保存的话，只能保存一定的量，而不能一直往里面放，需要设置数据的过期时间、LRU等算法。这里有一个方法是把常用的数据放到一个缓存中（A），不常用的放到另外一个缓存中（B）。当要获取数据时先从A中去获取，如果A中不存在那么再去B中获取。B中的数据主要是A中LRU出来的数据，这里的内存回收主要针对B内存，从而保持A中的数据可以有效的被命中。

  1. 先定义A缓存：

[java]  view plain copy

1. private final HashMap<String, Bitmap>mHardBitmapCache = new LinkedHashMap<String, Bitmap>(HARD_CACHE_CAPACITY/ 2, 0.75f, true) {
2. @Override
3. protected booleanremoveEldestEntry(LinkedHashMap.Entry<String, Bitmap> eldest) {
4. if (size() >HARD_CACHE_CAPACITY) {
5. //当map的size大于30时，把最近不常用的key放到mSoftBitmapCache中，从而保证mHardBitmapCache的效率
6. mSoftBitmapCache.put(eldest.getKey(), newSoftReference(eldest.getValue()));
7. return true;
8. } else
9. return false;
10. }
11. };
  1. 再定于B缓存：

[java]  view plain copy

1. /**
2. *当mHardBitmapCache的key大于30的时候，会根据LRU算法把最近没有被使用的key放入到这个缓存中。
3. *Bitmap使用了SoftReference，当内存空间不足时，此cache中的bitmap会被垃圾回收掉
4. */
5. private final staticConcurrentHashMap<String, SoftReference> mSoftBitmapCache =new ConcurrentHashMap<String,SoftReference>(HARD_CACHE_CAPACITY / 2);
6. 从缓存中获取数据：
[java]  view plain copy
1. /**
2. * 从缓存中获取图片
3. */
4. private Bitmap getBitmapFromCache(Stringurl) {
5. // 先从mHardBitmapCache缓存中获取
6. synchronized (mHardBitmapCache) {
7. final Bitmap bitmap =mHardBitmapCache.get(url);
8. if (bitmap != null) {
9. //如果找到的话，把元素移到linkedhashmap的最前面，从而保证在LRU算法中是最后被删除
10. mHardBitmapCache.remove(url);
11. mHardBitmapCache.put(url,bitmap);
12. return bitmap;
13. }
14. }
15. //如果mHardBitmapCache中找不到，到mSoftBitmapCache中找
16. SoftReferencebitmapReference = mSoftBitmapCache.get(url);
17. if (bitmapReference != null) {
18. final Bitmap bitmap =bitmapReference.get();
19. if (bitmap != null) {
20. return bitmap;
21. } else {
22. mSoftBitmapCache.remove(url);
23. }
24. }
25. return null;
26. }
27. 如果缓存中不存在，那么就只能去服务器端去下载：
[java]  view plain copy
1. /**
2. * 异步下载图片
3. */
4. class ImageDownloaderTask extendsAsyncTask<String, Void, Bitmap> {