Silvestri Modified MyLinklistCode

package chapter24v10;

public class MyLinkedList<E> implements MyList<E> {
    private static class Node<E> {
        E element;
        Node<E> next;

        public Node(E element) {
            this(element, null);
        }
        public Node(E element, Node<E> next) {
            this.element = element;
            this.next = next;
        }
    }

    private Node<E> head, tail;
    private int size = 0; // Number of elements in the list

    /** Create an empty list */
    public MyLinkedList() {
        this.head = null;
        this.tail = null;
    }

    /** Create a list from an array of objects */
    public MyLinkedList(E[] objects) {
        for (int i = 0; i < objects.length; i++)
            add(objects[i]);
    }

    /** Return the head element in the list */
    public E getFirst() {
        if (this.head == null)
            return null;
        return head.element;
    }

    /** Return the last element in the list */
    public E getLast() {
        if (this.tail == null) {
            return null;
        }
        return tail.element;
    }

    /** Add an element to the beginning of the list */
    public void addFirst(E e) {
        Node<E> newNode = new Node<>(e); // Create a new node
        newNode.next = head; // link the new node with the head
        head = newNode; // head points to the new node
        size++; // Increase list size

        if (tail == null) // the new node is the only node in list
            tail = head;
    }

    /** Add an element to the end of the list */
    public void addLast(E e) {
        Node<E> newNode = new Node<>(e); // Create a new for element e

        if (tail == null) {
            head = tail = newNode; // The new node is the only node in list
        } else {
            tail.next = newNode; // Link the new with the last node
            tail = newNode; // tail now points to the last node
        }

        size++; // Increase size
    }

    @Override /**
                 * Add a new element at the specified index in this list. The index of the head
                 * element is 0
                 */
    public void add(int index, E e) {
        if (index == 0) {
            addFirst(e);
        } else if (index >= size) {
            addLast(e);
        } else {
            Node<E> current = head;
            Node<E> prev = null;
            for (int i = 0; i < index; i++) {
                prev = current;
                current = current.next;
            }
            Node<E> temp = new Node<>(e, current);
            prev.next = temp;
            size++;
        }
    }

    /**
     * Remove the head node and return the object that is contained in the removed
     * node.
     */
    public E removeFirst() {
        if (head == null) {
            return null;
        }
        E temp = head.element;
        head = head.next;
        size--;
        if (head == null) {
            tail = null;
        }
        return temp;
    }

    /**
     * Remove the last node and return the object that is contained in the removed
     * node.
     */
    public E removeLast() {
        if (tail == null) {
            return null;
        }
        if (head == tail) {
            E temp = head.element;
            head = tail = null;
            size = 0;
            return temp;
        }
        Node<E> current = head;
        Node<E> prev = null;
        while (current != tail) {
            prev = current;
            current = current.next;
        }

        E temp = tail.element;
        tail = prev;;
        tail.next = null;
        size--;
        return temp;
    }

    @Override /**
                 * Remove the element at the specified position in this list. Return the element
                 * that was removed from the list.
                 */
    public E remove(int index) {
        if (index < 0 || index >= size)
            return null;
        if (index == 0)
            return removeFirst();
        if (index == size - 1)
            return removeLast();

        Node<E> current = head;
        Node<E> prev = null;
        for (int i = 0; i < index; i++) {
            prev = current;
            current = current.next;
        }

        E temp = current.element;
        prev.next = current.next;
        size--;
        return temp;
    }

    @Override /** Override toString() to return elements in the list */
    public String toString() {
        StringBuilder result = new StringBuilder("[");

        Node<E> current = head;
        for (int i = 0; i < size; i++) {
            result.append(current.element);
            current = current.next;
            if (current != null) {
                result.append(", "); // Separate two elements with a comma
            } else {
                result.append("]"); // Insert the closing ] in the string
            }
        }

        return result.toString();
    }

    @Override /** Clear the list */
    public void clear() {
        size = 0;
        head = tail = null;
    }

    @Override /** Return true if this list contains the element e */
    public boolean contains(Object e) {
        // Left as an exercise
        return true;
    }

    @Override /** Return the element at the specified index */
    public E get(int index) {
        // Left as an exercise
        return null;
    }

    @Override /**
                 * Return the index of the head matching element in this list. Return -1 if no
                 * match.
                 */
    public int indexOf(Object e) {
        // Left as an exercise
        return 0;
    }

    @Override /**
                 * Return the index of the last matching element in this list. Return -1 if no
                 * match.
                 */
    public int lastIndexOf(E e) {
        // Left as an exercise
        return 0;
    }

    @Override /**
                 * Replace the element at the specified position in this list with the specified
                 * element.
                 */
    public E set(int index, E e) {
        // Left as an exercise
        return null;
    }

    @Override /** Override iterator() defined in Iterable */
    public java.util.Iterator<E> iterator() {
        return new LinkedListIterator();
    }

    private class LinkedListIterator implements java.util.Iterator<E> {
        private Node<E> current = head; // Current index

        @Override
        public boolean hasNext() {
            return (current != null);
        }

        @Override
        public E next() {
            E e = current.element;
            current = current.next;
            return e;
        }

        @Override
        public void remove() {
        }
    }

    @Override /** Return the number of elements in this list */
    public int size() {
        return size;
    }

    @Override
    public void add(E e) {
        // TODO Auto-generated method stub

    }

    @Override
    public boolean isEmpty() {
        // TODO Auto-generated method stub
        return false;
    }

    @Override
    public boolean remove(E e) {
        // TODO Auto-generated method stub
        return false;
    }
}