LinkedList с тестами

Collections2/src/main/java/itis/homework/impl/linkedlist/LinkedList.java

@@ -0,0 +1,13 @@
+package itis.homework.impl.linkedlist;
+
+public interface LinkedList<T> {
+    T get(int index);
+
+    void add(T value);
+
+    void insert(int index, T value);
+
+    void remove(int index);
+
+    int size();
+}

Collections2/src/main/java/itis/homework/impl/linkedlist/LinkedListImpl.java

@@ -0,0 +1,72 @@
+package itis.homework.impl.linkedlist;
+
+public class LinkedListImpl<T> implements LinkedList<T> {
+
+    private LinkedListNodeImpl<T> firstNode;
+    private int size;
+
+    public T get(int index) {
+        return getNodeByIndex(index).getValue();
+    }
+
+    public void add(T value) {
+        if (size == 0)
+            firstNode = new LinkedListNodeImpl<T>(value);
+        else
+            getNodeByIndex(size - 1).setNext(new LinkedListNodeImpl<T>(value));
+
+        size++;
+    }
+
+    public void insert(int index, T value) {
+        LinkedListNodeImpl<T> linkedListNode = new LinkedListNodeImpl<T>(value);
+
+        if (index == 0) {
+            linkedListNode.setNext(firstNode);
+            firstNode = linkedListNode;
+        }
+        else if (index == size) {
+            add(value);
+            return;
+        }
+        else {
+            LinkedListNodeImpl<T> nodeLeft = getNodeByIndex(index - 1);
+            LinkedListNodeImpl<T> nodeRight = (LinkedListNodeImpl<T>) nodeLeft.getNext();
+
+            nodeLeft.setNext(linkedListNode);
+            linkedListNode.setNext(nodeRight);
+        }
+
+        size++;
+    }
+
+    public void remove(int index) {
+        LinkedListNodeImpl<T> nodeLeft = getNodeByIndex(index - 1);
+
+        if (index == size - 1) {
+            nodeLeft.setNext(null);
+        }
+        else {
+            LinkedListNodeImpl<T> nodeToRemove = (LinkedListNodeImpl<T>) nodeLeft.getNext();
+            LinkedListNodeImpl<T> nodeRight = (LinkedListNodeImpl<T>) nodeToRemove.getNext();
+
+            nodeLeft.setNext(nodeRight);
+        }
+
+        size--;
+    }
+
+    public int size() {
+        return size;
+    }
+
+    private LinkedListNodeImpl<T> getNodeByIndex(int index) {
+        LinkedListNodeImpl<T> currentNode = firstNode;
+
+        for (int i = 0; i < index; i++) {
+            currentNode = (LinkedListNodeImpl<T>) currentNode.getNext();
+        }
+
+        return currentNode;
+    }
+}

Collections2/src/main/java/itis/homework/impl/linkedlist/LinkedListNode.java

@@ -0,0 +1,12 @@
+package itis.homework.impl.linkedlist;
+
+public interface LinkedListNode<T> {
+
+    T getValue();
+
+    void setValue(T value);
+
+    LinkedListNode<T> getNext();
+
+    void setNext(LinkedListNode<T> node);
+}

Collections2/src/main/java/itis/homework/impl/linkedlist/LinkedListNodeImpl.java

@@ -0,0 +1,27 @@
+package itis.homework.impl.linkedlist;
+
+public class LinkedListNodeImpl<T> implements LinkedListNode<T> {
+
+    private T value;
+    private LinkedListNode<T> next;
+
+    public LinkedListNodeImpl(T value) {
+        this.value = value;
+    }
+
+    public T getValue() {
+        return value;
+    }
+
+    public void setValue(T value) {
+        this.value = value;
+    }
+
+    public LinkedListNode<T> getNext() {
+        return next;
+    }
+
+    public void setNext(LinkedListNode<T> next) {
+        this.next = next;
+    }
+}

Collections2/src/test/java/LinkedListTest.java

@@ -0,0 +1,64 @@
+import itis.homework.impl.linkedlist.LinkedListImpl;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class LinkedListTest {
+
+    @Test
+    public void testAdd() {
+        LinkedListImpl<Integer> testLinkedList = new LinkedListImpl<Integer>();
+
+        testLinkedList.add(1);
+        testLinkedList.add(2);
+        testLinkedList.add(3);
+        testLinkedList.add(4);
+        testLinkedList.add(5);
+
+        Assertions.assertEquals((Integer) 5, testLinkedList.get(4));
+    }
+
+    @Test
+    public void testInsert() {
+        LinkedListImpl<Integer> testLinkedList = new LinkedListImpl<Integer>();
+
+        testLinkedList.add(1);
+        testLinkedList.add(2);
+        testLinkedList.add(4);
+        testLinkedList.add(5);
+
+        testLinkedList.insert(2, 3);
+
+        Assertions.assertEquals((Integer) 3, testLinkedList.get(2));
+    }
+
+    @Test
+    public void testRemove() {
+        LinkedListImpl<Integer> testLinkedList = new LinkedListImpl<Integer>();
+
+        testLinkedList.add(1);
+        testLinkedList.add(2);
+        testLinkedList.add(3);
+        testLinkedList.add(4);
+        testLinkedList.add(5);
+
+        testLinkedList.remove(0);
+
+        Assertions.assertEquals((Integer) 2, testLinkedList.get(0));
+    }
+
+    @Test
+    public void testGetSize() {
+        LinkedListImpl<Integer> testLinkedList = new LinkedListImpl<Integer>();
+
+        testLinkedList.add(1);
+        testLinkedList.add(2);
+
+        Assertions.assertEquals(2, testLinkedList.size());
+
+        testLinkedList.add(3);
+        testLinkedList.add(4);
+        testLinkedList.add(5);
+
+        Assertions.assertEquals(5, testLinkedList.size());
+    }
+}