Lista enlazada doble

//Lista doblemente Enlazada
public class List<E> {
    /**
     * Campos en la estructura interna o privada de la clase
     */
    private Node head;
    private int count;
    private Node tail;

    /**
     * Getter para count
     *
     * @return cantidad de elementos en la linea
     */
    public int getCount() {
        return this.count;
    }

    /**
     * Constructor por defecto
     */
    public List() {
        this.head = null;
        this.count = 0;
        this.tail = null;
    }

    /**
     * Agrega al principio
     * Este codigo puede y debe mejorarse
     *
     * @param item elemento que se agrega a la lista
     */

    public void AddFirst(E item) {
        // si esta vacia
        if (this.count == 0) {
            // se crea un nodo con el elemento a agregar
            // el nuevo nodo es el primero y el ultimo
            this.head = this.tail = new Node(item, null, null);
            // incrementa la cuenta de elemento
            ++this.count;
        }
        else {
            // se crea un nodo cone el elemento a agregar
            Node temp = new Node(item, null, null);
            // el siguiente del nuevo nodo es el actual primero
            temp.next = this.head;
            // el anterior del actual primero es el nuevo nodo
            this.head.prev = temp;
            // el nuevo nodo se convierte en el primero
            this.head = temp;
            // incrementa la cuenta de elementos
            ++this.count;
        }
    }

    public void Better_AddFirst(E item) {
        Node temp = new Node(item, this.head, null);
        if (this.count == 0) {
            this.tail = temp;
        }
        else {
            this.head.prev = temp;
        }
        this.head = temp;
        ++this.count;
    }

    /**
     *Extrae y devuelve el primer elemento de la lista
     *
     * @return el elemento que se encuentra al principio de la lista
     * @exception Lista vacia
     */

    public E RemoveFirst() {
        if (this.count == 0) {
            throw new RuntimeException("La lista esta vaciá...");
        }

        // toma el elemento que esta en el primer nodo
        E item = this.head.item;
        // avanza el primer nodo al siguiente
        this.head = this.head.next;
        // si no hay mas nodos
        if (this.head == null) {
            // vaciar la lista
            this.tail = null;
        }
        else {
            // suprimir la referencia al anterior en el actual primero
            this.head.prev = null;
        }
        // decrementa la cuenta de elementos
        --this.count;
        // regresar el elemento
        return item;
    }

    /**
     *Extrae y devuelve el ultimo elemento de la lista
     *
     * @return el elemento que se encuentra al final de la lista
     * @exception Lista vacia
     */

    public E RemoveLast() {
        if (this.count == 0) {
            throw new RuntimeException("La lista esta vaciá...");
        }

        E item = this.tail.item;

        // si es el unico nodo
        if (this.head.next == null) {
            // vacia la lista
            this.head = this.tail = null;
        }
        else {
            // accede al penultimo nodo que ahora sera el ultimo
            this.tail = this.tail.prev;
            // anula la referencia al siguiente nodo
            this.tail.next = null;
        }
        // decrementa la cuenta de elementos
        --this.count;
        // regresa el elemento
        return item;
    }

    /**
     *  Muestra en la salida estándar todo los elementos de la lista
     *
     *  Para evitar código como este, se aconseja implementar interfaces
     *  que permitan recorrer la lista, como ser Iterable e Iterator
     *
     */

    public void Mostrar() {
        for (Node skip = this.head; skip != null; skip = skip.next) {
            System.out.printf("%s ", skip.toString());
        }
    }

    /**
     * Agrega al final
     * Este codigo puede y debe mejorarse
     *
     * @param item elemento que se agrega a la lista
     */

    public void AddLast(E item) {
        if (this.count == 0) {
            // se crea un nodo con el elemento a agregar
            // el nuevo nodo es el primero y el ultimo
            this.head = this.tail = new Node(item, null, null);
            // se incrementa la cuenta de elementos
            ++this.count;
        }
        else {
            // se crea un nodo con el elemento a agregar
            Node temp = new Node(item, null, null);
            // el anterior del nuevo nodo es el actual ultimo
            temp.prev = this.tail;
            // el siguiente del actual ultimo es el nuevo nodo
            this.tail.next = temp;
            // el nuevo es ahora el ultimo
            this.tail = temp;
            // se incrementa la cuenta de elementos
            ++this.count;
        }
    }

    public void Better_AddLast(E item) {
        Node temp = new Node(item, null, this.tail);
        if (this.count == 0) {
            this.head = temp;
        }
        else {
            this.tail.next = temp;
        }
        this.tail = temp;
        ++this.count;
    }



    private class Node {

    /**
     * Campos en la estructura interna o privada de la clase
     */
    public E item;
    public Node next;
    public Node prev;

    //Constructor por defecto
    public Node() {
        this(null, null, null);
    }

    //Constructor especializado
    public Node(E item) {
        this(item, null, null);
    }


    //Constructor especializado
    public Node(E item, Node next, Node prev) {
        this.item = item;
        this.next = next;
        this.prev = prev;
    }

    //Devuelve una cadena de texto que representa el contenido
    public String toString() {
        return this.item.toString();
    }
    }


}