List.java [lista doble]

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 lista
     */
    public int getCount() {
        return this.count;
    }

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


    /**
     * Agrega al principio
     * Este código puede y debe mejorarse
     *
     * @param item elemento que se agrega a la lista
     */
    public void AddFirst(E item) {
        // si esta vacía
        if (this.count == 0) {
            // se crea un nodo con el elemento a agregar
            // el nuevo nodo es el primero y el último
            this.head = this.tail = new Node(item, null, null);
            // 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 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 BetterAddFirst(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;
    }


    /**
     * Agrega al final
     * Este código 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 último
            this.head = this.tail = new Node(item, null, null);
            // 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 último
            temp.prev = this.tail;
            // el siguiente del actual último es el nuevo nodo
            this.tail.next = temp;
            // el nuevo es ahora el último
            this.tail = temp;
            // incrementa la cuenta de elementos
            ++this.count;
        }
    }


    public void BetterAddLast(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;
    }



    /**
     * Extrae y devuelve el primer elemento de la lista
     *
     * @return el elemento que se encuentra al principio de la lista
     * @exception Lista vacía
     */
    public E RemoveFirst() {
        if (this.count == 0) {
            throw new RuntimeException("La lista está vacía...");
        }

        // toma el elemento que está 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 último elemento de la lista
     *
     * @return el elemento que se encuentra al final de la lista
     * @exception Lista vacía
     */
    public E RemoveLast() {
        if (this.count == 0) {
            throw new RuntimeException("La lista está vacía...");
        }

        E item = this.tail.item;

        // si es el único nodo
        if (this.head.next == null) {
            // vacía la lista
            this.head = this.tail = null;
        } else {
            // accede al penúltimo nodo que ahora será el último
            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 todos 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());
        }
    }

















    /**
     * Clase privada para los nodos de la lista
     */
    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
         *
         * @param item elemento a mantener en el nodo
         */
        public Node(E item) {
            this(item, null, null);
        }

        /**
         * Constructor especializado
         *
         * @param item elemento a mantener en el nodo
         * @param next referencia al siguiente nodo
         */
        public Node(E item, Node next) {
            this(item, next, null);
        }

        /**
         * Constructor especializado
         *
         * @param item elemento a mantener en el nodo
         * @param next referencia al siguiente nodo
         * @param prev referencia al nodo anterior
         */
        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
         * del elemento que está en el nodo
         *
         * Esto es un ejemplo de "delegación"
         */
        public String toString() {
            return this.item.toString();
        }
    }
}