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