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