Add linked-list exercise

The tests assume that the Deque class is implemented with generics.

The example implementation keeps track of a circular head Element.

Completes one task in https://github.com/exercism/xjava/issues/3.

config.json

@@ -37,6 +37,7 @@
     "octal",
     "luhn",
     "pig-latin",
+    "linked-list",
     "pascals-triangle"
   ],
   "deprecated": [

linked-list/build.gradle

@@ -0,0 +1,12 @@
+apply plugin: "java"
+apply plugin: "eclipse"
+apply plugin: "idea"
+
+repositories {
+  mavenCentral()
+}
+
+dependencies {
+  testCompile "junit:junit:4.10"
+  testCompile "org.assertj:assertj-core:3.2.0"
+}

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

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

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

@@ -0,0 +1,52 @@
+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;
+    }
+}

linked-list/src/test/java/DequeTest.java

@@ -0,0 +1,61 @@
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class DequeTest {
+    private Deque<Integer> subject;
+
+    @Before
+    public void setUp() {
+        subject = new Deque<>();
+    }
+
+    @Test
+    public void testPushPop() {
+        subject.push(10);
+        subject.push(20);
+        assertThat(subject.pop()).isEqualTo(20);
+        assertThat(subject.pop()).isEqualTo(10);
+    }
+
+    @Test
+    public void testPushShift() {
+        subject.push(10);
+        subject.push(20);
+        assertThat(subject.shift()).isEqualTo(10);
+        assertThat(subject.shift()).isEqualTo(20);
+    }
+
+    @Test
+    public void testUnshiftShift() {
+        subject.unshift(10);
+        subject.unshift(20);
+        assertThat(subject.shift()).isEqualTo(20);
+        assertThat(subject.shift()).isEqualTo(10);
+    }
+
+    @Test
+    public void testUnshiftPop() {
+        subject.unshift(10);
+        subject.unshift(20);
+        assertThat(subject.pop()).isEqualTo(10);
+        assertThat(subject.pop()).isEqualTo(20);
+    }
+
+    @Test
+    public void testExample() {
+        subject.push(10);
+        subject.push(20);
+        assertThat(subject.pop()).isEqualTo(20);
+
+        subject.push(30);
+        assertThat(subject.shift()).isEqualTo(10);
+
+        subject.unshift(40);
+        subject.push(50);
+        assertThat(subject.shift()).isEqualTo(40);
+        assertThat(subject.pop()).isEqualTo(50);
+        assertThat(subject.shift()).isEqualTo(30);
+    }
+}