[Leetcode] LRU cache

Problem:

Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations: get and set.

get(key) - Get the value (will always be positive) of the key if the key exists in the cache, otherwise return -1.
set(key, value) - Set or insert the value if the key is not already present. When the cache reached its capacity, it should invalidate the least recently used item before inserting a new item.

Thought:

Use a HashMap along with a doubly linked list to achieve the O(1) running time for both get and set.

package leetcode_Java;

import java.util.Comparator;
import java.util.HashMap;
import java.util.PriorityQueue;


public class LRUCache {

	HashMap <Integer, ListEntry> map = new HashMap<Integer, ListEntry>();
	DoublyLinkedList list;
	
	public LRUCache(int capacity) {
		list = new DoublyLinkedList(capacity, map);
	}

	public int get(int key) {
		ListEntry entry = map.get(key);
		if(entry == null){
			return -1;
		}else{
			list.MoveToHead(entry);
			return entry.value;
		}
	}

	public void set(int key, int value) {
		ListEntry entry = map.get(key);
		if(entry == null){
			ListEntry newEntry = new ListEntry(null, null, value, key);
			map.put(key, newEntry);
			list.Add(newEntry);
		}else{
			entry.value = value;
			list.MoveToHead(entry);
		}
	}
	
	
}

class DoublyLinkedList{
	ListEntry head;
	ListEntry tail;
	int capacity;
	int currentSize;
	
	HashMap <Integer, ListEntry> map;
	
	public DoublyLinkedList(int capacity, HashMap <Integer, ListEntry> map){
		this.capacity = capacity;
		this.currentSize = 0;
		this.map = map;
	}
	
	public void Add(ListEntry entry){
		if(currentSize < capacity){
			if(head == null){
				head = entry;
				tail = entry;
			}else{
				head.prev = entry;
				entry.next = head;
				head = entry;
			}
			currentSize++;
			
		}else{
			head.prev = entry;
			entry.next = head;
			head = entry;
			
			//remove tail
			map.remove(tail.key);
			tail = tail.prev;
			tail.next = null;
		}
	}
	
	//Assume that entry has already existed somewhere in the doubly linked list
	public void MoveToHead(ListEntry entry){
		
		if(entry == head){
			return;
			
		}else if(entry == tail){
			tail = entry.prev;
			entry.prev.next = null;
			
		}else{ // in the middle
			entry.prev.next = entry.next;
			entry.next.prev = entry.prev;
		}
		
		head.prev = entry;
		entry.next = head;
		entry.prev = null;
		head = entry;
	}
}


// Node type of a doubly linked list
class ListEntry{
	ListEntry prev;
	ListEntry next;
	int value;
	int key;
	
	public ListEntry(ListEntry prev, ListEntry next, int value, int key) {
		super();
		this.prev = prev;
		this.next = next;
		this.value = value;
		this.key = key;
	}
	
}