实现lru 缓存

    public class LRUCache {  
        static class Node {  
            int key;  
            int value;  
      
      
            @Override  
            public String toString() {  
                return "Node{" +  
                        "key=" + key +  
                        ",value=" + value +  
                        '}';  
            }  
        }  
      
      
        static private LinkedList<Node> cache;  
        static private int cap;  
        static private Node indexMap[];  
      
        public LRUCache(int capacity) {  
            cache = new LinkedList<Node>();  
            indexMap = new Node[100000];  
            cap = capacity;  
        }  
      
        static public boolean isFull() {  
            return cache.size() == cap;  
        }  
      
        static public Node find(int key) {  
            if (cache.isEmpty())  
                return null;  
            Node tar = null;  
      
            if ((tar = indexMap[key]) == null)  
                return null;  
      
            cache.remove(tar);  
            cache.addFirst(tar);  
            return tar;  
      
        }  
      
         public int get(int key) {  
            Node node = find(key);  
            if (node == null) {  
                return -1;  
            }  
            return node.value;  
        }  
      
         public void set(int key,int value) {  
            Node node = null;  
            if ((node = find(key)) != null) {  
                node.value = value;  
                return;  
            }  
      
            //not find the element  
      
            if (isFull()) {  
                indexMap[cache.getLast().key] = null;  
                cache.removeLast();  
            }  
      
      
            Node newNode = new Node();  
            newNode.key = key;  
            newNode.value = value;  
            cache.addFirst(newNode);  
            indexMap[key] = newNode;  
      
        }  
    }