Update LRU.java

Meet Gradle requirements

Author: Suf42

src/main/java/dataStructures/lruCache/LRU.java

@@ -2,28 +2,46 @@
 
 import java.util.HashMap;
 
-public class LRU { // doublyLinkedList
-    int key;
-    int val;
-    LRU next;
-    LRU prev;
-}
+/**
+ * Implementation of Least Recently Used (LRU) Cache
+ *
+ *            Constructor:
+ *            LRU(int capacity)
+ *            Client methods:
+ *            get(K key)
+ *            put(K key, V value)
+ *            Both methods above run in O(1) average time complexity
+ */
+class LRU {
+    /**
+     * Helper node class that implements doubly linked list
+     */
+    private class doublyLinkedList {
+        private int key;
+        private int val;
+        private doublyLinkedList next;
+        private doublyLinkedList prev;
+    }
 
-class LRUCache {
-    LRU dllHead;
-    LRU dllTail;
-    HashMap<Integer, LRU> keyToNode = new HashMap();
-    int capacity;
-    int lengthOfList = 0;
+    private doublyLinkedList dllHead;
+    private doublyLinkedList dllTail;
+    private HashMap<Integer, doublyLinkedList> keyToNode = new HashMap();
+    private int capacity;
+    private int lengthOfList = 0;
 
-    public LRUCache(int capacity) {
+    /**
+     * Constructs an instance of Least Recently Used Cache
+     *
+     * @param capacity the maximum capacity of the cache
+     */
+    public LRU(int capacity) {
         this.capacity = capacity;
 
-        dllHead = new LRU();
+        dllHead = new doublyLinkedList();
         dllHead.key = -1;
         dllHead.val = -1;
 
-        dllTail = new LRU();
+        dllTail = new doublyLinkedList();
         dllTail.key = -1;
         dllTail.val = -1;
 
@@ -33,10 +51,17 @@ public LRUCache(int capacity) {
         dllTail.next = null;
     }
 
+    /**
+     * Return the value of the key if it exists or return null
+     *
+     * @param key key of the value to be obtained from LRU cache
+     */
     public int get(int key) {
-        if(!keyToNode.containsKey(key)) return -1;
-
-        LRU temp = keyToNode.get(key);
+        if(!keyToNode.containsKey(key)) {
+            return -1;
+        }
+        
+        doublyLinkedList temp = keyToNode.get(key);
         temp.prev.next = temp.next;
         temp.next.prev = temp.prev;
 
@@ -48,13 +73,19 @@ public int get(int key) {
         return keyToNode.get(key).val;
     }
 
+    /**
+     * Insert key-value pair to LRU cache
+     *
+     * @param key key of the value to be inserted to LRU cache
+     * @param value value to be inserted to LRU cache
+     */
     public void put(int key, int value) {
         boolean addingNewNode = true;
 
-        LRU newlyCached;
+        doublyLinkedList newlyCached;
 
         if(!keyToNode.containsKey(key)) {
-            newlyCached = new LRU();
+            newlyCached = new doublyLinkedList();
             newlyCached.key = key;
             newlyCached.val = value;
             keyToNode.put(key, newlyCached);