Practica 6 Linked L

package es.ubu.inf.edat.pr06;

import java.util.AbstractList;
import java.util.Iterator;
import java.util.ListIterator;

/**
 * Esta clase sirve para realizar inserciones en una lista enlazada.
 *
 * @author <A HREF="mailto:[email protected]">Alberto Barriuso Gallo</A>
 * @author <A HREF="mailto:[email protected]">David Cuesta Arnáiz</A>
 * @version 1.0
 * @date 15/04/2013
 *
 * */

public class ListaEnlazada<E> extends AbstractList<E> {
    private int contador;
    private Nodo ultimo;
    private Nodo primero;

    /**
     * Constructor de la clase.
     */
    public ListaEnlazada() {
        primero = null;
        ultimo = null;
        contador = 0; // Variable para saber cuantas elementos hay en la lista.
    }

    /**
     * Método que devuelve el elemento solicitado.
     */
    @Override
    public E get(int arg0) {
        Nodo aux = primero;
        int contadorGet = 0;
        while (aux != null && contadorGet < arg0) {
            aux = aux.getSiguiente();
            contadorGet++;
        }
        return aux.getDato();
    }

    /**
     * Método que devuelve el tamaño de la lista.
     */
    @Override
    public int size() {
        return contador;
    }

    /**
     * Método para añadir un objeto a la lista.
     */
    public boolean add(E objeto) {
        Nodo nuevo = new Nodo(objeto);
        if (size() == 0) {
            primero = nuevo;
            ultimo = nuevo;
        } else {
            ultimo.setSiguiente(nuevo);
            nuevo.setSiguiente(null);
            ultimo = nuevo;
        }

        contador++;
        return true;
    }

    /**
     * Método que añade un elemento en la posicion pasada. Método no soportada.
     */
    public void add(int i, E e) {
        throw new UnsupportedOperationException();
    }

    /**
     * Método que elimina un objeto en una posicion determinada.
     */
    public E remove(int posicion) {
        E aux = ultimo.getDato();
        Nodo aux1 = null; // Nodos auxiliares.
        Nodo aux2 = null;

        if (size() == 0) {
            throw new UnsupportedOperationException("Lista vacia");
        } else if (contador == 1) {
            primero = null;
            ultimo = null;
            if (posicion < 0 || posicion >= size())
                throw new IndexOutOfBoundsException();
        } else {
            aux1 = primero;

            for (int i = 0; i < posicion; i++) {
                aux2 = aux1;
                aux1 = aux1.getSiguiente();
                if (i == posicion - 1) {
                    aux2.setSiguiente(aux1.getSiguiente());
                    ultimo = aux2;
                }
            }
        }

        contador--;
        return aux;
    }

    /**
     * Metodo que remueve toda la coleccion.
     */
    public void clear() {
        primero = null;
        ultimo = null;
    }

    /**
     * Clase inner de Nodo , en el que se basa toda la lista. Formada por un
     * dato y la posicion del siguiente nodo.
     */
    private class Nodo {
        private E dato;
        private Nodo siguiente;

        /**
         * Constructor de la clase Nodo.
         *
         * @param dato
         *            dato que le pasas por referncia.
         */
        public Nodo(E dato) {
            this.dato = dato;
        }

        /**
         * Método que devuelve el dato del Nodo.
         *
         * @return dato
         */
        public E getDato() {
            return dato;
        }

        /**
         * Método para poner un dato.
         *
         * @param objeto
         *            objeto pasado
         */
        public void setDato(E objeto) {
            this.dato = objeto;
        }

        /**
         * Método para poner la direccion del siguiente elemento
         *
         * @return direccion del siguiente elemento.
         */
        public Nodo getSiguiente() {
            return siguiente;
        }

        /**
         * Método para poner la direccion del siguiente elemento.
         *
         * @param siguiente
         *            direccion del siguiente elemento.
         */
        public void setSiguiente(Nodo siguiente) {
            this.siguiente = siguiente;
        }

    }

    /**
     * Clase Iterador.
     */
    @Override
    public Iterator<E> iterator() {

        return new ListIterator<E>() {
            private int contador2 = 0; // Variable para saber la posicion
                                        // actual.
            private E aux = null;
            private Nodo actual = primero;

            /**
             * Método hasNext que nos dice si hay un elemento.
             */
            @Override
            public boolean hasNext() {
                if (actual == null)
                    return false;
                else
                    return true;
            }

            /**
             * Método que nos devuelve el siguiente objeto.
             */
            @Override
            public E next() {
                if (size() == 0) {
                    throw new UnsupportedOperationException("Lista vacia");

                } else {
                    if (actual != null) {
                        aux = actual.getDato();
                        actual = actual.getSiguiente();
                    }

                }

                contador2++;
                return aux;
            }

            /**
             * Método hasPrevious que nos dice si hay un elemento anterior.
             */
            @Override
            public boolean hasPrevious() {
                if (actual == primero)
                    return false;
                else
                    return true;
            }

            /**
             * Método que nos dice la posicion actual que esta recorriendo el iterador.
             */
            @Override
            public int nextIndex() {
                return contador2;
            }

            /**
             * Método que nos devuelve el dato anterior.
             */
            @Override
            public E previous() {
                Nodo anterior = primero;

                if (size() == 0) {
                    throw new UnsupportedOperationException("Lista vacia");
                } else if (primero == ultimo) {
                    aux = get(0);
                } else {
                    if (contador < size()) {
                        aux = actual.getDato();
                        while (anterior != actual) {
                            anterior.getSiguiente();
                        }
                        actual.setSiguiente(anterior);
                    }

                }

                contador2--;
                return aux;
            }

            /**
             * Método que nos devuelve el dato anterior.
             */
            @Override
            public int previousIndex() {
                return contador2;
            }


            // Métodos NO utilizados
            @Override
            public void set(E arg0) {
                throw new UnsupportedOperationException();

            }

            @Override
            public void remove() {
                throw new UnsupportedOperationException();
            }

            @Override
            public void add(E arg0) {
                throw new UnsupportedOperationException();
            }

        };
    }
}