Lista enlazada 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 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);
            // incrementa la cuenta de elemento
            ++this.count;
        }
        else {
            // se crea un nodo cone 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;
    }

    /**
     *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;
        }
        // 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 {
            // estas implementacion tiene Orden lineal O(n)
            // comienza con el primer nodo
            Node skip = this.head;
            // recorre la lista mientras haya dos nodos máa
            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 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) {
            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;
    }



    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
    public Node(E item) {
        this(item, null);
    }


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

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


}