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();
     }
 }

 synchronized (cache) {
   if (cache.get(key) == null) {
       cache.put(key, value);
   }
 }

 private Bitmap bitmap;
 private String STRING_KEY = "data_string";
 private LruCache<String, Bitmap> lruCache;
 private static final int CACHE_SIZE = 10 * 1024 * 1024;//10M
 lruCache = new LruCache<String, Bitmap>(CACHE_SIZE) {
    @Override
    protected void entryRemoved(boolean evicted, String key, Bitmap oldValue, Bitmap newValue) {
       super.entryRemoved(evicted, key, oldValue, newValue);
    }
    @Override
    protected int sizeOf(String key, Bitmap value) {
        //這里返回的大小用單位kb來表示的
        return value.getByteCount() / 1024;
    }
};

  if (lruCache!=null){
     lruCache.put(STRING_KEY, bitmap);
   }

 if (lruCache != null) {
     bitmap = lruCache.get(STRING_KEY);
  }

    //LruCache.java
    private final LinkedHashMap<K, V> map;//使用LinkedHashMap來存儲操作數(shù)據(jù)
    /** Size of this cache in units. Not necessarily the number of elements. */
    private int size;//緩存數(shù)據(jù)大小，不一定等于元素的個數(shù)
    private int maxSize;//最大緩存大小
    private int putCount;// 成功添加數(shù)據(jù)的次數(shù)
    private int createCount;//手動創(chuàng)建緩存數(shù)據(jù)的次數(shù)
    private int evictionCount;//成功回收數(shù)據(jù)的次數(shù)
    private int hitCount;//查找數(shù)據(jù)時命中次數(shù)
    private int missCount;//查找數(shù)據(jù)時未命中次數(shù)
    /**
     * @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);
    }

/**
 * Sets the size of the cache.
 *
 * @param maxSize The new maximum size.
 */
public void resize(int maxSize) {
    if (maxSize <= 0) {
        throw new IllegalArgumentException("maxSize <= 0");
    }
    synchronized (this) {
        this.maxSize = maxSize;
    }
    trimToSize(maxSize);
}

/**
 * Remove the eldest entries until the total of remaining entries is at or
 * below the requested size.
 *
 * @param maxSize the maximum size of the cache before returning. May be -1
 *            to evict even 0-sized elements.
 */
public 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!");
            }
            //如果已經(jīng)小于最大緩存，則無需接著往下執(zhí)行了
            if (size <= maxSize) {
                break;
            }
            //拿到最近最少使用的那條數(shù)據(jù)
            Map.Entry<K, V> toEvict = map.eldest();
            if (toEvict == null) {
                break;
            }
            key = toEvict.getKey();
            value = toEvict.getValue();
            //從LinkedHashMap移除這條最少使用的數(shù)據(jù)
            map.remove(key);
            //緩存大小size減去移除數(shù)據(jù)的大小，如果沒有覆寫sizeOf，則減去的值是1
            size -= safeSizeOf(key, value);
            evictionCount++;
        }
        entryRemoved(true, key, value, 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.
 *
 * <p>An entry's size must not change while it is in the cache.
 */
 protected int sizeOf(K key, V value) {
     return 1;
 }
protected void entryRemoved(boolean evicted, K key, V oldValue, V newValue) {}

 @Override
  protected int sizeOf(String key, BitmapDrawable value) {
      return value.getBitmap().getByteCount() / 1024;
  }

/**
 * 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) {
    //key或value為空直接拋異常
    if (key == null || value == null) {
        throw new NullPointerException("key == null || value == null");
    }
    V previous;
    synchronized (this) {
        //添加數(shù)據(jù)次數(shù)+1
        putCount++;
         //緩存數(shù)據(jù)的大小增加
        size += safeSizeOf(key, value);
         //添加緩存數(shù)據(jù)，添加之前如果key值對應(yīng)的value不為空，則newValue會覆蓋oldValue，并返回oldValue;
         //如果key值對應(yīng)的value為空，則返回Null
        previous = map.put(key, value);
        if (previous != null) {
           //之前的oldValue不為空，則在緩存size中減去oldValue
            size -= safeSizeOf(key, previous);
        }
    }
    if (previous != null) {
        entryRemoved(false, key, previous, value);
    }
    //重新檢查緩存大小
    trimToSize(maxSize);
    return previous;
}

 /**
  * 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.
  */
 public final V get(K key) {
     if (key == null) {
         throw new NullPointerException("key == null");
     }
     V mapValue;
     synchronized (this) {
         //通過key取數(shù)據(jù)
         mapValue = map.get(key);
         if (mapValue != null) {
             //如果取到了數(shù)據(jù)，命中次數(shù)+1
             hitCount++;
             return mapValue;
         }
         //沒有取到數(shù)據(jù)，未命中此時+1
         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.
      */
     //如果沒有覆寫create()，默認(rèn)create()方法返回的null
     V createdValue = create(key);    
     if (createdValue == null) {
         return null;
     }
     //如果覆寫了create()，即根據(jù)key值手動創(chuàng)造了value，則繼續(xù)往下執(zhí)行
     synchronized (this) {
          //創(chuàng)造數(shù)據(jù)次數(shù)+1
         createCount++;
         //嘗試將數(shù)據(jù)添加到緩存中
         mapValue = map.put(key, createdValue);
         if (mapValue != null) {
             // There was a conflict so undo that last put
             //mapValue不為空，說明之前的key對應(yīng)的是有數(shù)據(jù)的，那么就跟我們手動創(chuàng)建的數(shù)據(jù)沖突了，
             //所以執(zhí)行撤消操作，重新把mapValue添加到緩存中，用mapValue去覆蓋createdValue
             map.put(key, mapValue);
         } else {
             //如果mapValue為空，說明之前的key值對應(yīng)的value確實為空，我們手動添加createdValue后，
             //需要重新計算緩存size的大小
             size += safeSizeOf(key, createdValue);
         }
     }
     if (mapValue != null) {
         entryRemoved(false, key, createdValue, mapValue);
         return mapValue;
     } else {
         trimToSize(maxSize);
         return createdValue;
     }
 }
 protected V create(K key) {
      return null;
  }

 /**
  * Removes the entry for {@code key} if it exists.
  *
  * @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;
 }

      //清空緩存
     public final void evictAll() {
          trimToSize(-1); // -1 will evict 0-sized elements
      }
     public synchronized final int size() {
         return size;
     }
     public synchronized final int maxSize() {
          return maxSize;
     }
     public synchronized final int hitCount() {
         return hitCount;
     }
     public synchronized final int missCount() {
         return missCount;
     }
    public synchronized final int createCount() {
         return createCount;
     }
     public synchronized final int putCount() {
         return putCount;
     }
     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.
      */
      //復(fù)制一份緩存，順序從最近最少訪問到最多訪問排序
     public synchronized final Map<K, V> snapshot() {
         return new LinkedHashMap<K, V>(map);
     }