List.java [iterable e iterator]

import java.util.Iterator;

/*
 * Iterable<E>
 * Es una interface que permite utilizar la estructura de control
 * de ejecución de código "for-each"
 *
 *     for (tipo_de_dato variable : colección) {
 *         ...
 *     }
 *
 * La clase se compromete a implementar el método iterator() que
 * devuelve un objeto del tipo Iterator<?>
 *
 *      @Override
 *      public Iterator<E> iterator() {
 *          return new MyIterator();
 *      }
 *
 * Generalmente se implementa mediante otra clase, la mayoría de las
 * veces privada cuya característica es que debe implementar la
 * interface Iterator<E>
 *
 * Esta interface logra que los objetos de una clase respondan a dos
 * mensajes o métodos particulares; hasNext() y next()
 *
 * El primero de ellos es hasNext(), que devuelve verdadero cuando
 * hay un elemento disponible, y
 *  *
 *      @Override
 *      public boolean hasNext() {
 *          return ???; // si existe al menos un elemento sino false
 *      }
 *
 *El segundo de ellos es next(), que devuelve el elemento actual y
 *se prepara para acceder al siguiente elemento
 *
 *      @Override
 *      public E next() {
 *          if (!this.hasNext()) {
 *              throw new RuntimeException("La lista está vacía...");
 *          }
 *          E elemento = ???;
 *          se prepara para acceder al siguiente;
 *          return elemento;
 *      }
 *
 * La forma en que se utilizan estos métodos es la siguiente:
 *
 *      Iterator<E> iter = coleccion.iterator();
 *      while (iter.hasNext()) {
 *          hacer algo con iter.next()
 *      }
 *
 *
 * La JCF - Java Collection Framework tambien cuenta con una interface
 * conocida como Enumeration<E> de manera que los objetos que implementan
 * esta interfaz responden a los mensajes o métodos hasMoreElements() y
 * nextElement() que tienen la misma funcionalidad explicada para hasNext()
 * y next() de la interface Iterator<E> que además permite implementar el
 * metodo remove() que extrae o remueve el elemento de la colección
 *
 * */

public class List<E> implements Iterable<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 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 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 del Tipo de Dato Abstracto tiene Orden 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();
        }
    }















    @Override
    public Iterator<E> iterator() {
        return new MyIterator(this.head);
    }

    /**
     * Implementación de un iterador para la clase List
     *
     */
    private class MyIterator implements Iterator<E> {
        private Node actual;

        public MyIterator(Node inicio) {
            this.actual = inicio;
        }

        @Override
        public boolean hasNext() {
            return this.actual != null;
        }

        @Override
        public E next() {
            if (!this.hasNext()) {
                throw new RuntimeException("La lista está vacía...");
            }
            E item = this.actual.item;
            this.actual = this.actual.next;
            return item;
        }

    }


}