DoublyLinked

package com.telerikacademy.dsa;

import java.util.Iterator;

public class LinkedList<T> implements List<T> {
    private Node head;
    private Node tail;
    private int size = 0;

    public LinkedList() {
//        size = 0;

    }

    public LinkedList(Iterable<T> iterable) {
        iterable.forEach(this::addLast);
    }

    @Override
    public void addFirst(T value) {
        Node newNode = new Node(value);
        if (size > 0) {
            head.prev = newNode;
            newNode.next = head;
        } else {
            newNode.next = null;
            tail = newNode;
        }
        newNode.prev = null;
        head = newNode;
        size++;
    }

    @Override
    public void addLast(T value) {
        Node newNode = new Node(value);
        if (size > 0) {
            tail.next = newNode;
            newNode.prev = tail;
        } else {
            head = newNode;
        }
        tail = newNode;
        size++;
    }

    @Override
    public void add(int index, T value) {
        throw new UnsupportedOperationException();
    }

    @Override
    public T getFirst() {
        return head.value;
    }

    @Override
    public T getLast() {
        return tail.value;
    }

    @Override
    public T get(int index) {
        throw new UnsupportedOperationException();
    }

    @Override
    public int indexOf(T value) {
        throw new UnsupportedOperationException();
    }

    @Override
    public T removeFirst() {
        throw new UnsupportedOperationException();
    }

    @Override
    public T removeLast() {
        throw new UnsupportedOperationException();
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public Iterator<T> iterator() {
        throw new UnsupportedOperationException();
    }

    private boolean isEmpty() {
        return size == 0;
    }

    private class Node {
        T value;
        Node prev;
        Node next;

        Node(T value) {
            this.value = value;
        }
    }
}