Volvemos otro lunes más con el curso de Java que estamos realizando en RedesZone.net.
En la anterior entrega, os dejamos un ejercicio propuesto para ver las diferencias entre una pila y una cola de datos a la hora de llevar acabo la implementación.
Hoy, por lo tanto os daremos la solución del ejercicio de forma detallada y además, os emplazaremos para la siguiente estructura de datos, que nos ocupará las próximas entregas del curso, los mapas.
Pero en primer lugar, vamos con la solución del ejercicio.
Si recordáis bien, os decíamos que había que hacer una pila para los árbitros y una cola para meter los equipos. Como bien sabéis, la pila de los árbitros deberá responder a la siguiente interfaz:
[java]
import java.util.*;
/**
* Interfaz que representa una pila abstracta
*/
public interface Pila<E>
{
void apila(E e);
E desapila() throws NoSuchElementException;
void hazNula();
E cima() throws NoSuchElementException;
boolean estaVacia();
int tamano();
}
[/java]
Por lo tanto, una posible implementación de la pila es la siguiente:
[java]
import java.util.*;
public class PilaArbitros<E> implements Pila<String>
{
LinkedList<String> pilaArbitros= new LinkedList<String>();
@Override
public void apila(String arbitro)
{
pilaArbitros.add(arbitro);
}
@Override
public String desapila() throws NoSuchElementException
{
String a= pilaArbitros.get(pilaArbitros.size()-1);
pilaArbitros.remove(pilaArbitros.size()-1);
return a;
}
@Override
public void hazNula()
{
pilaArbitros.clear();
}
@Override
public String cima() throws NoSuchElementException {
return pilaArbitros.get(pilaArbitros.size());
}
@Override
public boolean estaVacia()
{
return pilaArbitros.isEmpty();
}
@Override
public int tamano() {
return pilaArbitros.size();
}
}
[/java]
Respondiendo a la interfaz de las pilas, como bien se sabe, el último en ser insertado es el primero en extraerse. Por lo tanto debemos recurrir a size()-1 para acceder de forma directa al último elemento, ya que hemos empleado una LinkedList.
Ahora vamos a implementar la cola de los equipos. Al recurrir a la clase Queue, sólo tenemos que utilizar los métodos que nos proporciona Java:
[java]
import java.util.*;
public class ColaEquipos
{
private Queue<String> colaEquipos = new LinkedList<String>();
public void InsertaAlPrincipio(String equipo)
{
colaEquipos.add(equipo);
}
public String extraeElPrimero()
{
return colaEquipos.poll();
}
public void muestraEquiposEncolados()
{
for(String equipo: colaEquipos)
{
System.out.println("Equipo: "+equipo);
}
}
}
[/java]
Ya tenemos las dos clases principales, ahora vamos a hacer un ejemplo de programa de prueba sencillo:
[java]
public class ProgramaPrincipal
{
public static void main (String[]args)
{
PilaArbitros pila = new PilaArbitros();
ColaEquipos cola = new ColaEquipos();
//Vamos a insertar equipos
cola.InsertaAlPrincipio("Real Madrid");
cola.InsertaAlPrincipio("Barcelona");
cola.InsertaAlPrincipio("Murcia");
cola.InsertaAlPrincipio("Racing");
cola.InsertaAlPrincipio("Real Sociedad");
cola.InsertaAlPrincipio("Sevilla");
cola.InsertaAlPrincipio("Deportivo");
cola.InsertaAlPrincipio("Atlético de Madrid");
cola.InsertaAlPrincipio("Villareal");
//Insertamos arbitros
pila.apila("Iturralde");
pila.apila("Paradas Romero");
pila.apila("Menjuto González");
pila.apila("Álvarez Izquierda");
pila.apila("Fernández Borbalan");
String equipoA;
String equipoB;
String arbitro;
int i=0;
while(i<4)
{
equipoA=cola.extraeElPrimero();
equipoB=cola.extraeElPrimero();
arbitro=pila.desapila();
System.out.println("Enfrentamiento número "+(i+1)+"nn");
System.out.println(equipoA+" vs "+equipoB+", dirigido por "+arbitro+"nnn");
i++;
}
}
}
[/java]
Como podéis observar si lo ejecutáis, los equipos se extraen en el orden insertado. Sin embargo los árbitros se extraen por la cabeza, extrayéndose siempre, el que más tarde se ha insertado.
Ahora vamos a comenzar a introducirnos a los mapas de datos en Java.
Un mapa es una función de unos elementos de un tipo clave, en otros elementos de un tipo destino.
Es una generalización del array:
- El array es una tabla de valores en la que el índice es un entero.
- El mapa es una tabla de valores en la que el índice es de cualquier tipo (la clave).
El mapa no puede tener claves repetidas:
- Pero dos claves pueden referirse al mismo valor.
Las claves deben ser objetos inmutables (no pueden modificarse NUNCA a lo largo de la ejecución del programa).
De momento, vamos a dejarlo en este punto. Para la siguiente entrega, veremos los métodos que caracterizan los mapas en Java, y lo acompañaremos con un ejemplo para que os sirva de guía para los futuros ejercicios que os podamos proponer.
