List.java [lista simple]

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);
            // incrementa la cuenta de elementos
            ++this.count;
        }
        else {
            // se crea un nodo con el elemento a agregar
            Node temp = new Node(item, null);
            // el siguiente del nuevo nodo es el actual primero
            temp.next = this.head;
            // 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);
        if (this.count == 0) {
            this.tail = 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) {
            this.head = this.tail = new Node(item, null);
            ++this.count;
        }
        else {
            Node temp = new Node(item, null);
            this.tail.next = temp;
            this.tail = temp;
            ++this.count;
        }
    }


    public void Better_AddLast(E item) {
        Node temp = new Node(item, null);
        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;
        }
        // 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 {
            // esta implementación tiene Orden lineal O(n)
            // comienza con el primer nodo
            Node skip = this.head;
            // recorre la lista mientras haya dos nodos más
            for ( ; skip.next.next != null; skip = skip.next) { }
            // skip es el penúltimo nodo que ahora será el último
            this.tail = skip;
            // 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;

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

        /**
         * Constructor especializado
         *
         * @param item elemento a mantener en el nodo
         */
        public Node(E item) {
            this(item, 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 = item;
            this.next = next;
        }

        /**
         * 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();
        }
    }



}