8.16 lru 캐 시 자바 버 전

lru 상세 소개 및 간단 한 코드 구현:http://blog.csdn.net/beiyetengqing/article/details/7855933
다음은 본인 의 강 화 된 lru 캐 시 클래스 입 니 다. 단일 가 져 오기, 캐 시 시간 초과 메커니즘 을 추가 하고 clear () 버그 를 복원 합 니 다.

package com.george.xblog.utils;

import java.util.Hashtable;
import java.util.Map;

/** * Created by george.yang on 15/8/15. */
public class LruCache {

    private static final class Entry {
        public String key;//  
        public Object value;//  
        public Entry prev;//     
        public Entry next;//     
        public long validTime;//       
    }

    private static LruCache instance;
    public static synchronized LruCache getInstance() {
        if (instance==null) {
            instance = new LruCache(100);
        }
        return instance;
    }





    private int cacheSize;
    private Map<String, Entry> nodes;//     
    private Entry first;//    
    private Entry last;//    


    public LruCache(int i) {
        cacheSize = i;
        nodes = new Hashtable<String, Entry>(i);//    
    }


    /** *        ,         */
    public <T> T get(String key) {
        Entry node = nodes.get(key);
        if (node != null) {
            if (System.currentTimeMillis()>node.validTime) {
                //      
                remove(node);
                // hashtable   
                nodes.remove(key);
            } else {
                moveToHead(node);
                return (T)node.value;
            }
        }
        return null;
    }

    /** *      *    entry hashtable,   entry * @param key * @param timeout     ，   * @param value */
    public void put(String key,long timeout, Object value) {
        //   hashtable     entry,     ，     value
        Entry node = nodes.get(key);

        if (node == null) {
            //            .
            if (nodes.size() >= cacheSize) {
                nodes.remove(last.key);
                removeLast();
            }
            node = new Entry();
        }
        node.validTime = System.currentTimeMillis() + timeout;
        node.value = value;
        //             ，       .
        moveToHead(node);
        nodes.put(key, node);
    }


    /** *  entry  ,   ：       cache        */
    public void remove(String key) {
        Entry node = nodes.get(key);
        //      
        remove(node);
        // hashtable   
        nodes.remove(key);
    }


    private void remove(Entry node) {
        if (node != null) {
            if (node.prev != null) {
                node.prev.next = node.next;
            }
            if (node.next != null) {
                node.next.prev = node.prev;
            }
            if (last == node)
                last = node.prev;
            if (first == node)
                first = node.next;
        }
    }

    /** *         ，         entry */
    private void removeLast() {
        //      ,       null.      （           ）
        if (last != null) {
            if (last.prev != null)
                last.prev.next = null;
            else
                first = null;
            last = last.prev;
        }
    }

    /** *       ，              */
    private void moveToHead(Entry node) {
        if (node == first)
            return;
        if (node.prev != null)
            node.prev.next = node.next;
        if (node.next != null)
            node.next.prev = node.prev;
        if (last == node)
            last = node.prev;
        if (first != null) {
            node.next = first;
            first.prev = node;
        }
        first = node;
        node.prev = null;
        if (last == null)
            last = first;
    }

    /* *      */
    public void clear() {
        first = null;
        last = null;
        nodes = new Hashtable<String, Entry>(cacheSize);
    }
}