public class DoubleLinkedList<E> {

    class Node<E> {

        E element;
        Node prev;
        Node next;

        public Node(E element) {
            //constructor with args
this.element = element;
        }

        public Node() {
            //constructor without args
}

        @Override
public String toString() {
            return this.element.toString();
        }
    }

    private Node first = null;
    private Node last = null;

    /**
     * 連結結點到連結串列首部
     * @param node
*/
private void linkFirst(Node node) {
        if (first == null || last == null) {
            first = last = node;
        }
        node.next 

= first;
        first.prev = node;
        first = node;
    }

    /**
     * 連結結點到連結串列尾部
     * @param node
*/
private void linkLast(Node node) {
        last.next = node;
        node.prev = last;
        last = node;
    }

    /**
     * 連結一個結點到連結串列中間
     * @param node1 要連結的結點
     * @param node2 連結點位置的結點
     * example:
     *    [插入前]node -> node2 -> node3
     *    [插入後]node -> node1 -> node2 -> node3
     */
private void link(Node node1, Node node2) {
        Node node = node2.prev;
        node.next = node1;
        node1.prev = node;
        node1.next = node2;
        node2.prev = node1;

    }

    /**
     * 移除某個節點
     * @param node
*/
public void unlink(Node node) {
        Node prevNode = node.prev;
        Node nextNode = node.next;
        prevNode.next = nextNode;
        nextNode.prev = prevNode;
    }

    /**
     * 移除首結點
     */
private void unlinkFirst() {
        first = first.next;
        first.prev = null;
    }

    /**
     * 移除尾結點
     */
private void unlinkLast() {
        last = last.prev;
        last.next = null;
    }

    /**
     * 根據索引獲取結點
     * @param index
* @return
*/
private Node getNode(int index) {
        Node node = first;
        Node currentNode = new Node();
        if (index == 0) {
            currentNode = first;
        }

        if (index >= size()) {
            throw new IndexOutOfBoundsException(errMessage(index));
        }
        else {
            int i = 0;
            while (i <= index) {
                if (node != null) {
                    currentNode = node;
                    node = node.next;
                }
                i++;
            }
        }
        return currentNode;

    }

    /**
     * 統計連結串列裡面所有元素的個數
     * @return 總的元素的個數
     */
public int size() {
        Node node = first;
        int count = 0;
        while (node != null) {
            count++;
            node = node.next;
        }
        return count;
    }

    /**
     * 錯誤訊息顯示
     * @param index
* @return
*/
private String errMessage(int index) {
        return "Size: "+ size() + ", index: "+ index;
    }

    /**
     * 插入元素到連結串列中
     * @param index
* @param element
*/
public void insert(int index, E element) {
        Node node = new Node<E>(element);
        if (index == 0) {
            linkFirst(node);
        }
        if (index < 0 || index >= size()) {
            throw new IndexOutOfBoundsException(errMessage(index));
        }
        if (index == size() -1) {
            linkLast(node);
        }
        else {
            Node node1 = getNode(index);
            link(node, node1);
        }

    }

    /**
     * 新增元素到連結串列
     * @param element
*/
public void add(E element) {
        Node node = new Node<E>(element);
        linkFirst(node);
    }

    /**
     * 新增元素到連結串列首部
     * @param element
*/
public void addFirst(E element) {
        Node node = new Node<E>(element);
        linkFirst(node);
    }

    /**
     * 新增元素到連結串列尾部
     * @param element
*/
public void addLast(E element) {
        Node node = new Node<E>(element);
        linkLast(node);
    }

    /**
     * 移除指定索引下得元素
     * @param index
*/
public void remove(int index) {
        if (index == 0) {
            unlinkFirst();
        }
        else if (index == size() -1 ){
            unlinkLast();
        }
        else if (index < 0 || index >= size()) {
            throw new IndexOutOfBoundsException(errMessage(index));
        }
        else {
            Node node = getNode(index);
            unlink(node);
        }
    }

    /**
     * 移除最後一個元素
     */
public void removeLast() {
        unlinkLast();
    }

    /**
     * 移除第一個元素
     */
public void removeFirst() {
        unlinkFirst();
    }

    /**
     * 清空連結串列
     */
public void clear() {
        first = null;
    }

    /**
     * 判斷連結串列是否為空
     * @return
*/
public boolean isEmpty() {
        return first == null;
    }

    /**
     * 過載toString方法
     * @return
*/
@Override
public String toString() {
        Node node = first;
        StringBuilder stringBuilder = new StringBuilder();
        if (node == null) {
            return "{}";
        }
        else {
            stringBuilder.append("{ ");
            while (node != null) {
                stringBuilder.append("["+ node.toString() +"],");
                node = node.next;
            }
        }
        String result = stringBuilder.toString();
        int index = result.lastIndexOf(",");
        return result.substring(0, index) + " }";
    }

    /**
     * 判斷某個元素是否在連結串列中
     * @param element
* @return
*/
public boolean contains(E element) {
        return getIndexOf(element) != -1;
    }

    /**
     * 獲取一個元素
     * @param index
* @return
*/
public E get(int index) {
        return (E) getNode(index).element;
    }

    /**
     * 獲取最後一個元素
     * @return
*/
public E getLast() {
        return (E) last.element;
    }

    /**
     * 獲取第一個元素
     * @return
*/
public E getFirst() {
        return (E) first.element;
    }

    /**
     * 替換特定索引的元素
     * @param index
* @param element
*/
public void replace(int index, E element) {
        getNode(index).element = element;
    }

    /**
     * 獲取某個元素的索引,這裡通常是第一次出現的索引
     * @param element
* @return
*/
public int getIndexOf(E element) {
        int index = 0;
        if (element == null) {
            for (Node<E> node = first; node != null; node = node.next) {
                if (node.element == null) {
                    return index;
                }
                index++;
            }
        }
        else {
            for (Node<E> node = first; node != null; node = node.next) {
                if (node.element.equals(element)) {
                    return index;
                }
                index++;
            }
        }
        return -1;
    }

    /**
     * 獲取某個元素最後一次出現的索引
     * @param element
* @return
*/
public int getLastIndexOf(E element) {
        int index = size();
        if (element == null) {
            for (Node<E> node = last; node != null; node = node.prev) {
                index--;
                if (node.element == null) {
                    return index;
                }
            }
        }
        else {
            for (Node<E> node = last; node != null; node = node.prev) {
                index--;
                if (node.element.equals(element)) {
                    return index;
                }
            }
        }
        return -1;
    }

    /**
     * 移除某個元素第一次出現的位置
     * @param element
*/
public void removeFirstOccurrence(E element) {
        if (element == null) {
            return;
        }
        int index = getIndexOf(element);
        remove(index);

    }

    /**
     * 移除某個元素最後一次出現的位置
     * @param element
*/
public void removeLastOccurrence(E element) {
        if (element == null) {
            return;
        }
        int index = getLastIndexOf(element);
        remove(index);
    }