Linked List

package es.ubu.inf.edat.pr06;

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

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

    public ListaEnlazada() {
        primero = null;
        ultimo = null;
        lista = new LinkedList<E>();
        contador = 0; //Variable para saber cuantas elementos hay en la lista.
    }

    @Override
    public E get(int arg0) {
        return lista.get(arg0);
    }

    @Override
    public int size() {
        return contador;
    }

    public boolean add(E objeto) {
        Nodo nuevo = new Nodo(objeto);
        if (lista.size() == 0) {
            primero = nuevo;
            ultimo = nuevo;
        } else {
            ultimo.setSiguiente(nuevo);
            nuevo.setSiguiente(null);
            ultimo = nuevo;
        }

        contador++;
        System.out.println(contador);
        return true;
    }

    public void add(int i, E e) {
        throw new UnsupportedOperationException();
    }

    public E remove(int posicion) {
        E aux = ultimo.getDato();
        Nodo aux2 = null;

        if (lista.size() == 0) {
            throw new UnsupportedOperationException("Lista vacia");
        } else if (primero == ultimo) {
            primero = null;
            ultimo = null;
            if (posicion < 0 || posicion >= size())
                throw new IndexOutOfBoundsException();
        } else {
            aux2 = primero;
            for (int i = 0; i < posicion; i++) {
                aux2 = aux2.getSiguiente();
                if (i == posicion - 1) {
                    aux2.setSiguiente(primero);
                    ultimo = aux2;
                }
            }
        }

        contador--;
        return aux;
    }

    public void clear() {
        primero = null;
        ultimo = null;
    }

    private class Nodo {
        private E dato;
        private Nodo siguiente;

        public Nodo(E dato) {
            this.dato = dato;
        }

        public E getDato() {
            return dato;
        }

        public void setDato(E objeto) {
            this.dato = objeto;
        }

        public Nodo getSiguiente() {
            return siguiente;
        }

        public void setSiguiente(Nodo siguiente) {
            this.siguiente = siguiente;
        }

    }

    @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;

            @Override
            public boolean hasNext() {
                if (actual == null)
                    return false;
                else
                    return true;
            }

            @Override
            public E next() {
                if (contador == 0) {
                    throw new UnsupportedOperationException("Lista vacia");
                } else if (primero == ultimo) {
                    aux = lista.get(0);
                } else {
                    if (actual!=null) {
                        aux = actual.getDato();
                        actual.getSiguiente();
                    }

                }

                contador2++;
                return aux;
            }

            @Override
            public boolean hasPrevious() {
                if (actual == primero)
                    return false;
                else
                    return true;
            }

            @Override
            public int nextIndex() {
                return contador2;
            }

            @Override
            public E previous() {
                Nodo anterior = primero;

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

                }

                contador2--;
                return aux;
            }

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

        };
    }
}