Contenedores II : Listas

Las listas son un tipo de colecciones, el otro es el set. Heredan de las colecciones sus métodos y ademas añaden sus própias funcionalidades. Las listas pueden ser ArrayList y LinkedList Los array list son de acceso aleatório más rápido pero lentas si se desea insertar o eliminar del medio de la lista. Aqui tienes varios ejemplos.

RellenarListas.java ejemplo de coleccion - ArrayList

import java.util.*;
public class RellenarListas{
	public static void main(String[] args){
		List lista = new ArrayList();
		for(int i=0; i<10;i++){
			lista.add(Integer.toString(i));
		}
		System.out.println(lista);
		for(int i=0; i<10;i++){
			System.out.println("lista :=" +lista.get(i));
		}
	}
} 

… Y como puedes ver… se imprimen bastante facil. Pero como decía la lista no tiene ni idea de que es lo que contiene. Mira este ejemplo:

Tenemos la clase Gato:

// Gato.java
// contenedores
public class Gato{
	private int nuGato;
	Gato(int i){	nuGato = i;	}
	void escribir(){
		System.out.println("gato #" + nuGato);
	}
}

Y la clase Perro:

// Perro.java
// contenedores
public class Perro{
	private int nuPerro;
	Perro(int i){	nuPerro = i;	}
	void escribir(){
		System.out.println("perro #" + nuPerro);
	}
}

Si ahora quisieramos manipular los gatos….

// GatosYPerros.java
import java.util.*;
public class GatosYPerros{
	public static void main(String[] args){
		int maxim=6;
		ArrayList GatoS = new ArrayList();
		if(args.length !=0  ){
			try{
				maxim = Integer.parseInt(args[0]);
			} catch (NumberFormatException nfe){
				System.out.println("no has pasado un numero");
				}
		}
		for(int i=0; i< maxim; i++){
			GatoS.add(new Gato(i));		
		}
		// En tiempo de compilación no se quejará al añadir un perro
 		GatoS.add(new Perro(1));
		System.out.println(GatoS);
		for(int i=0; i<GatoS.size(); i++){
		// pero en tiempo de ejecución si al intentar convertir un perro en un gato			
			((Gato)GatoS.get(i)).escribir();	
		}
	}
}

Si quisieramos hacer un arraylist consciente de lo que contiene lo tendríamos que hacerlo así:

Por un lado tendríamos la clase a almacenar:

// Raton.java
  public class Raton{
  	private int numRaton;
  	Raton(int i){	numRaton = i;	}
  	public String toString(){
  		return "Este raton es el raton numero # " + numRaton;
  	}
  	public int numero(){
  		return numRaton;
  	}
  }

Ahora viene el truco: una clase que gestiona la lista:

//listaRaton.java
// un arraylist conciente de los tipos
import java.util.*;
public class ListaRaton{
	private ArrayList listado = new ArrayList();
	public void meter(Raton r){
		listado.add(r);
	}
	public Raton sacar(int indice){
		return (Raton) listado.get(indice);
	}
	public int tamano(){
		return listado.size();
	}
}

como ves es una patraña. Es la clase la que controla que sea un raton, la lista se lo traga todo, pero el filtro lo hace la clase. Igualmente fijate que al sacar el raton de la lista lo vuelve a convertir en raton. ¡La lista almacena objetos, no ratones! Y aqui viene la utilización:

// PruebaListaRaton.java
public class PruebaListaRaton{
	public static void main(String args[]){
		int max=7;
		ListaRaton ratonES = new ListaRaton();
		if(args.length !=0  ){  // esto sirve par recoger el parametro de la cantidad de ratones
			try{
				max = Integer.parseInt(args[0]);
			} catch (NumberFormatException nfe){
					System.out.println("no has pasado un numero");
					}
		}
		for(int i=0; i<max; i++){
			ratonES.meter(new Raton(i));
		}
		for(int i=0; i<max;i++){
			System.out.println(ratonES.sacar(i));
		}
	}
}

Proporciona acceso secuencial optimo pero es lenta con accesos al azar. Proporciona los métodos:

• AddFirst(Objeto) Añade el objeto al principio de la lista. Util para pilas
• AddLast(Objeto) Añade el objeto al final de la lista Util para colas
• getFirst() Devuelve el primer objeto de la lista. Util para pilas
• getLast() Devuelve el último objeto al final de la lista Util para colas
• removeFirst(Objeto) Borra el objeto al principio de la lista. Util para pilas
• removeLast(Objeto) Borra el objeto al final de la lista Util para colas

Y aqui podemos ver una pila con una LinkedList:

// Pila.java
  import java.util.*;
  public class Pila{
  	private LinkedList lista = new LinkedList();
  	public void apilar(Object o){
  		lista.addFirst(o);
  	}
  	public Object cima(){
  		return lista.getFirst();	
  	}
  	public Object desapilar(){
  		return lista.removeFirst();
  	}
  	public static void main(String[] args){
  		Pila apilado = new Pila();
  		for(int i=0; i<10; i++){ apilado.apilar("hola"+i);}
  		System.out.println("la cima es: "+apilado.cima());
  		System.out.println("borrando : " + apilado.desapilar());
  		System.out.println("borrando : " + apilado.desapilar());
  		System.out.println("ahora la cima es :"+apilado.cima());
  	}
  }

Fijate en la salida:

la cima es: hola9
borrando : hola9
borrando : hola8
ahora la cima es :hola7

cuando borras (apilado.desapilar()) te devuelve el que hemos desapilado Y por fin una bonita cola:

// Cola.java
// haciendo una cola a partir de una likedlist
import java.util.*;
public class Cola{
	private LinkedList lista = new LinkedList();
	public void poner(Object o){	lista.addFirst(o);}
	public Object quitar(){	return lista.removeLast();}
	public boolean estaVacia(){	return lista.isEmpty();	}
	public static void main(String[] args){
		Cola cola = new Cola();
		for(int i= 0; i<10;i++){
			cola.poner(Integer.toString(i));
		}
		while(!cola.estaVacia()){
			System.out.println(cola.quitar());
		}
	}
}