LRU Cache Java Program

/*

Java Implementation of LRU Cache using DoublyLinkedList nodes and HashMap

*/

package DataStructures;

 

import java.util.HashMap;

 

class Node2 {

           

            int key;

            int value;

            Node2 pre;

            Node2 next;

           

            Node2(int key ,int value)

            {

                        this.key=key;

                        this.value=value;

            }

}

class  LRUCache {

 

            private HashMap<Integer,Node2> lrumap;

            private int capacity;

            private Node2 head,tail;

           

            LRUCache(int capacity)

            {

                        this.capacity=capacity;

                        lrumap=new HashMap<Integer,Node2>();

                        head=null;

                        tail=null;

                        }

           

            public void deleteNode(Node2 node)

            {

                       

                        if(node==head)

                        {

                                    head.next.pre=null;

                                    head=head.next;

                                    node=null;                              

                        }

                        else if(node==tail)

                        {

                                    tail.pre.next=null;

                                    tail=tail.pre;

                                    node=null;                              

                        }

                        else

                        {

                                    node.pre.next=node.next;

                                    node.next.pre=node.pre;

                                    node=null;

                        }

            }

           

            public void addToHead(Node2 node)

            {

                        if(head==null && tail==null)

                        {

                                    head=node;

                                    tail=node;

                        }

                        else

                        {

                        node.next=head;

                        head.pre=node;

                        head=node;

                        }

                       

            }

           

            public int get(int key)

            {

                        if(lrumap.containsKey(key))

                        {

                                    Node2 gnode=lrumap.get(key);

                                    int result=gnode.value;

                                    deleteNode(gnode);

                                    addToHead(gnode);

                                   

                                    return result;

                        }

                       

                        return -1;

            }

           

            public void set(int key,int value)

            {

                        if(lrumap.containsKey(key))

                        {

                                    Node2 snode=lrumap.get(key);

                                    snode.value=value;

                                    deleteNode(snode);

                                    addToHead(snode);

                        }

                        else

                        {

                                    Node2 node=new Node2(key,value);

                                 

                                    if(lrumap.size()>=capacity)

                                    {

                                    System.out.println("remove="+tail.key);

                                                lrumap.remove(tail.key);

                                                deleteNode(tail);

                                   

                                    }

                                    lrumap.put(key, node);

                                    addToHead(node);

                                   

                        }

            }

           

            public void show()

            {

                        Node2 node = head;

                       

                        while(node.next!=null)

                        {         

                        System.out.print("["+node.key+","+node.value+"]--");

                        node=node.next;

                        }

                        System.out.print("["+node.key+","+node.value+"]--");

                        System.out.println();

            }

           

           

}

 

 

public class  LRUCacheDS{

           

 

            public static void main(String[] args) {

                       

                        LRUCache lr= new LRUCache(4);

                        lr.set(4,8);

                        lr.set(2,28);

                        lr.set(6,38);

                        lr.show();

                        lr.set(14,48);

                        lr.show();

                        lr.set(84,58);

                        lr.show();

                        lr.set(84,34);

                        lr.show();

                        lr.get(6);

                        System.out.println("---------------------------------------------------------");

                        lr.show();

                       

            }

}