设计可以变更的缓存结构

一、采用java库带的双向链表

import java.util.*;
//设计可以变更的缓存结构
public class CacheTest{
	
    public static class Cache<K,V>{

           private K key;
           private V value;
    	   
    	   public Cache(K k, V v)
    	   {
    	   	   this.key=k;
    	   	   this.value=v;
    	   }
    }
    public static class CacheManu<K,V>{
    	
    	 private int size;
    	
    	public CacheManu(int n)
    	{
    		 this.size=n;
    	}
    	//生成一个队列当做可变的缓存结构
    	 @SuppressWarnings("rawtypes")
		Queue<Cache>queue=new LinkedList<>();

    	  //设置set的功能
    	  @SuppressWarnings({ "rawtypes", "unchecked" })
		public  void set(K k,V v)
    	{
    	  	  if(queue.size()<size)
    	  	  {
    	  		 queue.offer(new Cache(k,v));
    	  	  }else{
    	  		 queue.poll();
    	  		 queue.offer(new Cache(k,v));
    	  	  }
    		  
    	}
    	  //设置get的功能
    	  @SuppressWarnings("unchecked")
		public  V get(K k)
    	 {
               V v=null;
                for(Cache<K, V> cache:queue)
                {
                  if(cache.key==k)
                  {
                    v=(V) cache.value;
                    queue.offer(cache);
                    queue.poll();
                    break;
                  }
               }
               
              return v;
    	}
//        //交换两个节点的值
//    	public  void swap(Cache<K, V> cache1,Cache<K, V> cache2)
//    	{
//    		 K k=null;
//    		 V v=null;
//    		 k=cache1.key;
//    		 v=cache1.value;
//    		 
//    		 cache1.key=cache2.key;
//    		 cache1.value=cache2.value;
//    		 
//    		 cache2.key=k;
//    		 cache2.value=v;	  
//    	}
    	 
    	//获得所有的值
    	public  void getAll()
    	{
    		  for(Cache<K, V> cache:queue)
              {
    			  System.out.println(cache.key+" "+cache.value);
              }
    		   
    	}

    }

	public static void main(String[]args)
	{
		int size=3; //设置缓存的大小
		CacheManu<String,Integer>cache=new CacheManu<>(size);
		cache.set("a", 1);
		cache.set("b", 2);
		cache.set("c",3);
		cache.getAll();
		System.out.println("原始缓存大小:");
		System.out.println(cache.get("a"));
		cache.getAll();
		cache.set("d", 4);
		System.out.println("超出缓存大小后:");
		cache.getAll();
		
	}
}

二、自己写一个双向链表

import java.util.HashMap;
 //最近最少使用算法
public class LeastRecentlyUsedCache {

	public static class Node<V> {
		public V value;
		public Node<V> last;
		public Node<V> next;

		public Node(V value) {
			this.value = value;
		}
	}
  
	 //手写的双向链表
	public static class NodeDoubleLinkedList<V> {
		private Node<V> head;
		private Node<V> tail;

		public NodeDoubleLinkedList() {
			this.head = null;
			this.tail = null;
		}

		public void addNode(Node<V> newNode) {
			if (newNode == null) {
				return;
			}
			if (this.head == null) {
				this.head = newNode;
				this.tail = newNode;
			} else {
				this.tail.next = newNode;
				newNode.last = this.tail;
				this.tail = newNode;
			}
		}

		public void moveNodeToTail(Node<V> node) {
			if (this.tail == node) {
				return;
			}
			if (this.head == node) {
				this.head = node.next;
				this.head.last = null;
			} else {
				node.last.next = node.next;
				node.next.last = node.last;
			}
			node.last = this.tail;
			node.next = null;
			this.tail.next = node;
			this.tail = node;
		}

		public Node<V> removeHead() {
			if (this.head == null) {
				return null;
			}
			Node<V> res = this.head;
			if (this.head == this.tail) {
				this.head = null;
				this.tail = null;
			} else {
				this.head = res.next;
				res.next = null;
				this.head.last = null;
			}
			return res;
		}

	}
    //缓存的具体实现
	public static class MyCache<K, V> {
		private HashMap<K, Node<V>> keyNodeMap;
		private HashMap<Node<V>, K> nodeKeyMap;
		private NodeDoubleLinkedList<V> nodeList;
		private int capacity;

		public MyCache(int capacity) {
			if (capacity < 1) {
				throw new RuntimeException("should be more than 0.");
			}
			this.keyNodeMap = new HashMap<K, Node<V>>();
			this.nodeKeyMap = new HashMap<Node<V>, K>();
			this.nodeList = new NodeDoubleLinkedList<V>();
			this.capacity = capacity;
		}

		public V get(K key) {
			if (this.keyNodeMap.containsKey(key)) {
				Node<V> res = this.keyNodeMap.get(key);
				this.nodeList.moveNodeToTail(res);
				return res.value;
			}
			return null;
		}

		public void set(K key, V value) {
			if (this.keyNodeMap.containsKey(key)) {
				Node<V> node = this.keyNodeMap.get(key);
				node.value = value;
				this.nodeList.moveNodeToTail(node);
			} else {
				Node<V> newNode = new Node<V>(value);
				this.keyNodeMap.put(key, newNode);
				this.nodeKeyMap.put(newNode, key);
				this.nodeList.addNode(newNode);
				if (this.keyNodeMap.size() == this.capacity + 1) {
					this.removeMostUnusedCache();
				}
			}
		}

		private void removeMostUnusedCache() {
			Node<V> removeNode = this.nodeList.removeHead();
			K removeKey = this.nodeKeyMap.get(removeNode);
			this.nodeKeyMap.remove(removeNode);
			this.keyNodeMap.remove(removeKey);
		}

	}

	public static void main(String[] args) {
		MyCache<String, Integer> testCache = new MyCache<String, Integer>(3);
		testCache.set("A", 1);
		testCache.set("B", 2);
		testCache.set("C", 3);
		System.out.println(testCache.get("B"));
		System.out.println(testCache.get("A"));
		testCache.set("D", 4);
		System.out.println(testCache.get("D"));
		System.out.println(testCache.get("C"));

	}

}