android实现缓存图片等数据

采用linkedHashMap自带的LRU 算法缓存数据， 可检测对象是否已被虚拟机回收，并且重新计算当前缓存大小，清除缓存中无用的键值对象(即已经被虚拟机回收但未从缓存清除的数据)；
 * 默认内存缓存大小为: 4 * 1024 * 1024 可通过通过setMaxCacheSize重新设置缓存大小，可手动清空内存缓存
 *
支持内存缓存和磁盘缓存方式， 通过 {@link cc.util.cache.NetByteWrapper} 支持HTTP缓存 （注：详细参考cc.util.http包）； 注：使用JDK7

package cc.util.cache;
 
import java.io.Serializable;
import java.util.Objects;
 

public class NetByteWrapper implements Serializable {
 
  private final static long serialVersionUID = 1L;
 
  
  private byte[] data;
  
  int contentLength;
  
  private long lastModified;
  
  private String ETag;
 
  public NetByteWrapper(byte[] data, long lastModified, String Etag) {
    this.data = data;
    this.lastModified = lastModified;
    this.ETag = Etag;
  }
   
  public byte[] getData() {
    return data;
  }
  public void setData(byte[] data) {
    this.data = data;
  }
 
  public long getLastModified() {
    return lastModified;
  }
  public void setLastModified(long lastModified) {
    this.lastModified = lastModified;
  }
 
  public String getETag() {
    return ETag;
  }
   
  public void setETag(String eTag) {
    this.ETag = eTag;
  }
   
  public int getContentLength() {
    return Objects.isNull(data) ? 0 : data.length;
  }
}
 
 
package cc.util.cache;
 
import java.lang.ref.ReferenceQueue;
import java.lang.ref.SoftReference;
 

public class NetByteSoftReference extends SoftReference {
   
  private String key = "";
  private long length = 0;
 
  public NetByteSoftReference(String key, NetByteWrapper arg0) {
    this(key, arg0, null);
  }
 
  public NetByteSoftReference(String key, NetByteWrapper arg0,
      ReferenceQueue arg1) {
    super(arg0, arg1);
    // TODO Auto-generated constructor stub
    this.key = key;
    this.length = arg0.getContentLength();
  }
   
  public String getKey() {
    return key;
  }
   
  public long getLength() {
    return length;
  }
 
}
 
 
package cc.util.cache;
 
import java.lang.ref.ReferenceQueue;
import java.lang.ref.SoftReference;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.Iterator;
import java.util.linkedHashMap;
import java.util.Objects;
 

public class NetCacheManager {
 
  
  private long MAX_CACHE_SIZE = 4 * 1024 * 1024;
  private long cacheSize = 0; 
 
  private static NetCacheManager instance = null;
   
  private final ReferenceQueue referenceQueue;
  private final linkedHashMap cacheMap;
   
  private NetCacheManager(){
    referenceQueue = new ReferenceQueue();
    cacheMap = new linkedHashMap(16, 0.75f, true) {
 
      private static final long serialVersionUID = -8378285623387632829L;
      @Override
      protected boolean removeEldestEntry(
   java.util.Map.Entry eldest) {
 // TODO Auto-generated method stub
 boolean shouldRemove = cacheSize > MAX_CACHE_SIZE;
 if (shouldRemove) {
   cacheSize -= eldest.getValue().getLength();
   System.gc();
 }
 return shouldRemove;
      }
    };
  }
   
  
  public static synchronized NetCacheManager newInstance(){
    if (Objects.isNull(instance)) {
      instance = new NetCacheManager();
    }
    return instance;
  }
   
  
  public void setMaxCacheSize(long cacheSize) {
    this.MAX_CACHE_SIZE = cacheSize;
  }
   
  
  public long getCacheSize() {
    return cacheSize;
  }
   
  
  public void cacheInMemory(String key, byte[] value) {
    this.cacheInMemory(key, value, 0, null);
  }
   
  
  public void cacheInMemory(String key, byte[] value, long lastModified) {
    this.cacheInMemory(key, value, lastModified, null);
  }
   
  
  public void cacheInMemory(String key, byte[] value, String Etags) {
    this.cacheInMemory(key, value, 0, Etags);
  }
   
  
  private void cacheInMemory(String key, byte[] value, long lastModified, String Etags) {
    Objects.requireNonNull(key, "key must not be null");
    clearRecycledObject();
    NetByteWrapper wrapper = new NetByteWrapper(value, lastModified, Etags);
    NetByteSoftReference byteRef = new NetByteSoftReference(key, wrapper, referenceQueue);
    cacheMap.put(key, byteRef);
    value = null;
    wrapper = null;
  }
   
  
  public void cacheInDisk(String key, byte[] value, String path) {
    cacheInDisk(key, value, path, false);
  }
   
  
  public void cacheInDisk(String key, byte[] value, String path, boolean cacheInMemory) {
    this.cacheInDisk(key, value, 0, null, path, cacheInMemory);
  }
   
  
  private void cacheInDisk(String key, byte[] value, long lastModified, String Etags, String path, boolean cacheInMemory) {
    if (cacheInMemory) cacheInMemory(key, value, lastModified, Etags);
    try (FileOutputStream fos = new FileOutputStream(path);
 ObjectOutputStream oos = new ObjectOutputStream(fos)) {
 NetByteWrapper wrapper = new NetByteWrapper(value, lastModified, Etags);
 oos.writeObject(wrapper);
    } catch (Exception e) {
 // TODO: handle exception
      e.printStackTrace();
    }
  }
   
  
  public NetByteWrapper getFromMemory(String key) {
    SoftReference softReference = cacheMap.get(key);
    return Objects.nonNull(softReference) ? softReference.get() : null;
  }
   
  
  public byte[] getByteFromMemory(String key) {
    NetByteWrapper wrapper = getFromMemory(key);
    return Objects.nonNull(wrapper) ? wrapper.getData() : null;
  }
   
  
  public NetByteWrapper getFromDisk(String path) {
    try (FileInputStream fis = new FileInputStream(path);
 ObjectInputStream ois = new ObjectInputStream(fis)) {
      NetByteWrapper wrapper = (NetByteWrapper) ois.readObject();
      return wrapper;
    } catch (Exception e) {
      // TODO: handle exception
      e.printStackTrace();
      return null;
    }
  }
   
  
  public NetByteWrapper getFromDiskByMapped(String path) {
    try (FileInputStream fis = new FileInputStream(path);
 FileChannel channel= fis.getChannel();
 ByteArrayOutputStream baos = new ByteArrayOutputStream()){
      MappedByteBuffer mbb = channel.map(FileChannel.MapMode.READ_ONLY, 0, channel.size());
      byte[] bts = new byte[1024]; 
      int len = (int) channel.size();
      for (int offset = 0; offset < len; offset += 1024) { 
 if (len - offset > 1024) mbb.get(bts);
 else mbb.get((bts = new byte[len - offset])); 
 baos.write(bts);
      } 
      ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
      ObjectInputStream ois = new ObjectInputStream(bais);
      NetByteWrapper wrapper = (NetByteWrapper) ois.readObject();
      bais.close();
      ois.close();
      return wrapper;
    } catch (Exception e) {
      // TODO: handle exception
      e.printStackTrace();
      return null;
    }
  }
   
  
  public byte[] getByteFromDisk(String path) {
    NetByteWrapper wrapper = getFromDisk(path);
    return Objects.isNull(wrapper) ? null : wrapper.getData();
  }
   
  
  public byte[] getByteFromDiskByMapped(String path) {
    NetByteWrapper wrapper = getFromDiskByMapped(path);
    return Objects.isNull(wrapper) ? null : wrapper.getData();
  }
   
  
  private void clearRecycledObject() {
    NetByteSoftReference ref = null;
    //检测对象是否被回收，如果被回收则从缓存中移除死项
    while (Objects.nonNull((ref = (NetByteSoftReference) referenceQueue.poll()))) {
      cacheMap.remove(ref.getKey());
    }
    cacheSize = 0;
    Iterator keys = cacheMap.keySet().iterator();
    while (keys.hasNext()) {
      cacheSize += cacheMap.get(keys.next()).getLength();
    }
  }
   
  
  public void clearCache() {
    clearRecycledObject();
    cacheMap.clear();
    System.gc();
    System.runFinalization();
  }
   
}

以上所述就是本文的全部内容了，希望大家能够喜欢。