Polish example linked-list exercise

Apply generics to the internals of Element to remove
needless casting.

Tighten Element scoping and move into Deque for succintness (sp).

Add the execise into the grade test suite.

linked-list/src/example/java/Deque.java

 public final class Deque<T> {
-    private Element head;
+    private Element<T> head;
 
     public void push(T value) {
         if (head == null) {
-            head = new Element(value, null, null);
-            head.setNext(head);
-            head.setPrev(head);
+            head = new Element<>(value, null, null);
+            head.next = head;
+            head.prev = head;
             return;
         }
 
-        Element oldTail = head.getPrev();
-        Element tail = new Element(value, oldTail, head);
-        oldTail.setNext(tail);
-        head.setPrev(tail);
+        Element<T> oldTail = head.prev;
+        Element<T> tail = new Element<>(value, oldTail, head);
+        oldTail.next = tail;
+        head.prev = tail;
     }
 
     public T pop() {
-        head = head.getPrev();
+        head = head.prev;
         return shift();
     }
 
     public void unshift(T value) {
         push(value);
-        head = head.getPrev();
+        head = head.prev;
     }
 
     public T shift() {
-        Object value = head.getValue();
+        T value = head.value;
 
-        Element newHead = head.getNext();
-        Element newTail = head.getPrev();
+        Element<T> newHead = head.next;
+        Element<T> newTail = head.prev;
 
         if (newHead == head) {
             head = null;
         }
         else {
-            newHead.setPrev(newTail);
-            newTail.setNext(newHead);
+            newHead.prev = newTail;
+            newTail.next = newHead;
             head = newHead;
         }
 
-        return (T) value;
+        return value;
+    }
+
+    private static final class Element<T> {
+        private final T value;
+        private Element<T> prev;
+        private Element<T> next;
+
+        public Element(T value, Element<T> prev, Element<T> next) {
+            this.value = value;
+            this.prev = prev;
+            this.next = next;
+        }
     }
 }

linked-list/src/example/java/Element.java

-public final class Element {
-    private final Object value;
-    private Element prev;
-    private Element next;
-
-    public Element(Object value, Element prev, Element next) {
-        this.value = value;
-        this.prev = prev;
-        this.next = next;
-    }
-
-    public Element getPrev() {
-        return prev;
-    }
-
-    public void setPrev(Element prev) {
-        this.prev = prev;
-    }
-
-    public Element getNext() {
-        return next;
-    }
-
-    public void setNext(Element next) {
-        this.next = next;
-    }
-
-    public Object getValue() {
-        return value;
-    }
-
-    @Override
-    public boolean equals(Object o) {
-        if (this == o) return true;
-        if (o == null || getClass() != o.getClass()) return false;
-
-        Element element = (Element) o;
-
-        if (value != null ? !value.equals(element.value) : element.value != null) return false;
-        if (prev != null ? !prev.equals(element.prev) : element.prev != null) return false;
-        return next != null ? next.equals(element.next) : element.next == null;
-
-    }
-
-    @Override
-    public int hashCode() {
-        int result = value != null ? value.hashCode() : 0;
-        result = 31 * result + (prev != null ? prev.hashCode() : 0);
-        result = 31 * result + (next != null ? next.hashCode() : 0);
-        return result;
-    }
-}

settings.gradle

 include 'hamming'
 include 'hexadecimal'
 include 'hello-world'
+include 'linked-list'
 include 'luhn'
 include 'meetup'
 include 'nucleotide-count'