基于Java LinkedList,實現Android大數據緩存策略

    import java.util.HashMap;

    import java.util.LinkedList;


/* 
 * 基于Java LinkedList,實現Android大數據緩存策略 
 * 作者：Zhang Phil 
 * 原文出處：http://blog.csdn.net/zhangphil 
 *  
 * 實現原理：原理的模型認為：在LinkedList的頭部元素是最舊的緩存數據，在LinkedList的尾部是最新的緩存數據。 
 * 在一個LinkedList（類型C的鏈表）維護一個存儲堆棧，添加元素時候順序、依次添加。 
 * 
 *  原理實現的具體方案：只要調用緩存的get()方法后，立即將此元素從原先在LinkedList的位置更新到LinkedList最后的位置。 
 *  比如，原先是：1,2,3,4,5。當get了2后，現在的順序是：1,3,4,5,2。 
 * 
 *  緩存空間滿的情況下，則刪除最舊的元素（在最頭部），以騰出空間。  
 * 比如，緩存空間是5，原先緩存已經緩存了5個元素：a,b,c,d,e， 
 * 當再次添加元素 f 時候，因為緩存空間是5容不下6個元素，所以刪除最頭部的元素a，把f追加到最尾部變成： b,c,d,e,f 
 *  
 * 具體使用：類似于Android的LruCache，對外公開兩個通用（通用,意味著可以存Bitmap或者類似的數據）方法供存儲和讀取使用： 
 *  public void put(String key, Object obj); 
 *  public Object get(String key); 
 *  即通用的<key,value>存儲和讀取模型。注意：使用者應保證存儲時的key唯一。 
 * */  

public class CacheBasedOnLinkedList {  

    // Capacity默認的緩存容量  
    private static int CAPACITY = 30;  

    private LinkedList<HashMap<String, Object>> mLinkedList;  
    private final String KEY = "key", VALUE = "value";  

    public CacheBasedOnLinkedList() {  
        init();  
    }  

    public CacheBasedOnLinkedList(int capacity) {  
        CAPACITY = capacity;  
        init();  
    }  

    private void init() {  
        mLinkedList = new LinkedList<HashMap<String, Object>>();  
    }  

    // 動態調整緩存空間大小。  
    // 注意！該方法極可能線程不安全。  
    public void ensureCapacity(int capacity) {  
        if (capacity >= CAPACITY) {  
            // 若比原先大，直接賦值即可  
            // Capacity = capacity;  
        } else {  
            // 若新調整的容量比原先還要小，那么一個一個的刪掉頭部元素直到相等  
            while (mLinkedList.size() > capacity) {  
                HashMap<String, Object> map = mLinkedList.removeFirst();  
                System.out.println("\n刪除-> " + map.get(KEY) + ":"  
                        + map.get(VALUE));  
            }  
        }  

        CAPACITY = capacity;  
        System.out.println("\n重新調整緩存容量為:" + CAPACITY);  
    }  

    // 把需要緩存的數據以<key,value>鍵值對的形式存入緩存。  
    // 存之前，要檢查緩存是否滿，滿了的話就刪除LinkedList第一個元素。  
    public void put(String key, Object obj) {  
        if (mLinkedList.size() < CAPACITY) {  

        } else {  
            HashMap<String, Object> map = mLinkedList.removeFirst();  
            System.out.println("\n緩存空間已滿!刪除-> " + map.get(KEY) + ":"  
                    + map.get(VALUE));  
        }  

        HashMap<String, Object> map = new HashMap<String, Object>();  
        map.put(KEY, key);  
        map.put(VALUE, obj);  
        mLinkedList.addLast(map);  
        System.out.println("\n緩存-> " + map.get(KEY) + ":" + map.get(VALUE));  
    }  

    // 根據key讀出緩存數據  
    // 原理：從頭到尾遍歷整個鏈表LinkedList，只要檢查到元素中的key和給定的key相同，立即返回。  
    // 同時更新該元素在LinkedList中位置:從原先的位置放到最后一個位置。  
    public Object get(String key) {  
        Object obj = null;  
        for (HashMap<String, Object> map : mLinkedList) {  
            if (map.get(KEY).equals(key)) {  
                System.out.println("讀取->" + key + ":" + map.get(VALUE));  
                mLinkedList.remove(map);  
                mLinkedList.addLast(map);  
                return map.get(VALUE);  
            }  
        }  

        return obj;  
    }  

//  // 僅僅是打印輸出現在最新的緩存數據情況。  
//  private void out() {  
//      System.out.print("最新緩存情況:");  
//      for (HashMap<String, Object> map : mLinkedList) {  
//          System.out.print(map.get(KEY) + ":" + map.get(VALUE) + ",");  
//      }  
//  }  


//  // 測試  
//  public static void main(String[] args) {  
//      CacheBasedOnLinkedList cache = new CacheBasedOnLinkedList(2);  
//  
//      Random rand = new Random();  
//  
//      for (int i = 0; i < 100; i++) {  
//          cache.ensureCapacity(rand.nextInt(100) + 1);  
//          cache.put(i + "", i);  
//          cache.get(rand.nextInt(100) + "");  
//          cache.out();  
//      }  
//  }  
}  </pre>