La primera prueba tendría dos partes:
- Creación de Eventos
- Listar Eventos creados
Centrémonos en la primera parte.
Hay que pedir datos al usuario para crear eventos, los cuáles podemos añadirlos a un ArrayList para luego poder mostrar un listado.
Por cada evento, hay que crear además un expositor y uno o más asistentes.
Este proceso podemos separarlo en tres métodos:
- para crear y retornar un Expositor
- para crear y retornar un Asistente
- para crear y retornar un Evento, donde invocaremos a los métodos que crean Expositores y Asistentes
Combinando esos tres métodos, podemos hacer un bucle while donde vayamos creando y añadiendo
Eventos al ArrayList, hasta que el usuario decida terminar.
package pruebas;
import java.util.ArrayList;
import java.util.Scanner;
import entidades.*;
public class Prueba01 {
private static ArrayList<Evento> eventos = new ArrayList<Evento>();
private static Scanner teclado = new Scanner(System.in);
public static void main(String[] args) {
//Creacion de Eventos
char terminar = 'N';
while (terminar != 'S') {
eventos.add(crearEvento());
System.out.println("\nEvento añadido. ¿Desea TERMINAR?(S/N): ");
terminar = teclado.nextLine().toUpperCase().charAt(0);
}
}
private static Expositor crearExpositor() {
System.out.println("\n\tDATOS DEL EXPOSITOR");
System.out.print("Codigo: ");
String codigo = teclado.nextLine();
System.out.print("Nombre: ");
String nombre = teclado.nextLine();
System.out.print("Apellidos: ");
String apellidos = teclado.nextLine();
System.out.print("Sueldo: ");
double sueldo = Double.parseDouble(teclado.nextLine());
System.out.print("Correo: ");
String correo = teclado.nextLine();
return new Expositor(codigo, nombre, apellidos, sueldo, correo);
}
private static Asistente crearAsistente() {
System.out.println("\n\tDATOS DEL ASISTENTE");
System.out.print("Codigo: ");
String codigo = teclado.nextLine();
System.out.print("Nombre: ");
String nombre = teclado.nextLine();
System.out.print("Apellidos: ");
String apellidos = teclado.nextLine();
System.out.print("Correo: ");
String correo = teclado.nextLine();
System.out.print("Telefono: ");
String telef = teclado.nextLine();
System.out.print("Direccion: ");
String direcc = teclado.nextLine();
return new Asistente(codigo, nombre, apellidos, correo, telef, direcc);
}
private static Evento crearEvento() {
System.out.println("\n\tDATOS DEL EVENTO");
System.out.print("Titulo: ");
String titulo = teclado.nextLine();
System.out.print("Duracion(en minutos): ");
int duracion = Integer.parseInt(teclado.nextLine());
System.out.print("Hora ingreso: ");
String ingreso = teclado.nextLine();
System.out.print("Hora salida: ");
String salida = teclado.nextLine();
System.out.print("Temporada Alta?(S/N): ");
boolean temporadaAlta = teclado.nextLine().toUpperCase().charAt(0) == 'S';
System.out.println("Indique codigo ubicacion");
System.out.println("[P] -> Platinum / [G] -> Gold / [V] -> VIP");
System.out.print("Codigo: ");
char ubicacion = teclado.nextLine().toUpperCase().charAt(0);
//Necesitamos un Expositor
Expositor expo = crearExpositor();
//Podemos crear el Evento
Evento evento = new Evento(titulo, duracion, expo, ingreso, salida, temporadaAlta, ubicacion);
//Ahora hay que añadir Asistentes al Evento
char terminar = 'N';
while (terminar != 'S') {
Asistente nuevo = crearAsistente();
evento.addAsistente(nuevo);
System.out.println("\nAsistente añadido. ¿Desea TERMINAR?(S/N): ");
terminar = teclado.nextLine().toUpperCase().charAt(0);
}
return evento;
}
}
Con esto tendríamos la primera parte.
Ahora hay que ver cómo hacemos la segunda parte.
Nos piden un listado de los
Eventos, incluyendo su
Expositor(que es uno) y
Asistentes(que pueden ser muchos)
Y además el listado ha de estar ordenado
por título y de manera descendente, es decir, de Z a A.
Bien, para facilitar esto, primero deberíamos añadir un nuevo método a la clase
Evento que se encargue de mostrar detalladamente todos sus datos, incluyendo expositor y asistentes.
public void mostrarEvento() {
System.out.println("\n\t\t" + titulo.toUpperCase());
System.out.print("\t\t");
for (int i = 0; i < titulo.length(); i++)
System.out.print("-");
System.out.printf("\nExpositor: %s %s", expositor.getNombre(), expositor.getApellidos());
System.out.printf("\nDuracion: %d Ingreso: %s Salida: %s\n", duracion, horaIngreso, horaSalida);
System.out.println("Temporada: " + (esTemporadaAlta?"Alta":"Baja"));
System.out.print("Ubicacion: ");
switch(codigoUbicacion) {
case 'P':
System.out.println("Platinum");
break;
case 'G':
System.out.println("Gold");
break;
default:
System.out.println("VIP");
}
System.out.println("\n\t---Lista de Asistentes---\n");
for (Asistente asis: asistentes)
System.out.printf("-> %s %s\n", asis.getNombre(), asis.getApellidos());
}Con esto ya podemos volver a la clase Prueba01 y añadir código para mostrar un listado tras la creación de los eventos:
public static void main(String[] args) {
//Creacion de Eventos
char terminar = 'N';
while (terminar != 'S') {
eventos.add(crearEvento());
System.out.println("\nEvento añadido. ¿Desea TERMINAR?(S/N): ");
terminar = teclado.nextLine().toUpperCase().charAt(0);
}
//Listar los Eventos
System.out.println("\n\t\tLISTADO DE EVENTOS");
System.out.println("\t\t------- -- -------\n");
for (Evento even: eventos) {
System.out.println("\n\n\t\t*************************\n");
even.mostrarEvento();
}
}
Bien, con esto listamos los eventos, pero aún no están ordenados como nos han solicitado.
Para poder ordenar a nuestro gusto los eventos contenidos en el ArrayList, podríamos implementarle la interfaz
Comparable a la clase
Evento y sobre escribir el método
compareTo() para indicarle cómo se han de ordenar.
Pero, viendo lo que están solicitando en las siguientes clases de "pruebas", parece que nos va a convenir poder ordenar los eventos al menos de dos formas distintas.
Así que en lugar de usar la interfaz
Comparable, podemos crear una serie de objetos
Comparator, donde cada uno establecerá distintas reglas de ordenamiento y así podremos llamarlos según lo que necesitemos.
Parecido a lo que habíamos hecho con la clase
MisConstantes, podemos hacer una clase
MisComparadores donde definir unos objetos
Comparator como unas constantes que puedan ser utilizadas en cualquier momento para decirle al ArrayList de
Eventos cómo ha de ordenarse.
De momento, escribimos un comparador que permita ordenar por "título descendente".
package util;
import java.util.Comparator;
import entidades.Evento;
public class MisComparadores {
public static final Comparator<Evento> TITULO_EVENTO_DESCENDENTE = new Comparator<Evento>() {
@Override
public int compare(Evento evento1, Evento evento2) {
/*
* Los titulos son cadenas String.
* La clase String ya sabe como ha de compararse ella misma,
* así que podemos retornar directamente el resultado de
* comparar los títulos de los eventos.
* Sin embargo, por defecto, la comparación de la clase String
* nos daría un orden ASCENDENTE (de A a Z) y nosotros queremos
* un orden DESCENDENTE (de Z a A).
* Podemos revertir ese orden simplemente multiplicando por -1
* el resultado que da la comparación de la clase String
*/
return (evento1.getTitulo().compareTo(evento2.getTitulo())) * -1;
}
};
}Con esto, en la clase
Prueba01 podemos ordenar el ArrayList antes de mostrar el listado en pantalla.
Para ello, llamamos al método sort() que posee el ArrayList y le pasamos entre paréntesis el comparador que acabamos de escribir:
public static void main(String[] args) {
//Creacion de Eventos
char terminar = 'N';
while (terminar != 'S') {
eventos.add(crearEvento());
System.out.println("\nEvento añadido. ¿Desea TERMINAR?(S/N): ");
terminar = teclado.nextLine().toUpperCase().charAt(0);
}
//Listar los Eventos
eventos.sort(MisComparadores.TITULO_EVENTO_DESCENDENTE);
System.out.println("\n\t\tLISTADO DE EVENTOS");
System.out.println("\t\t------- -- -------\n");
for (Evento even: eventos) {
System.out.println("\n\n\t\t*************************\n");
even.mostrarEvento();
}
}
Y con esto ya habríamos cumplido con lo que pide
Prueba01: creación de eventos y mostrar listado ordenado descendente por título.
Antes de terminar, vamos a añadir una cosa.
Es tedioso, más bien terrible...., tener que crear eventos por teclado para poder comprobar si el listado sale ordenado o no.
Con las siguientes clases "pruebas", va a ocurrir lo mismo. Nos piden una serie de operaciones que para poder comprobar si funcionan, primero necesitamos tener eventos.
En lugar de estar creando eventos por teclado cada vez que ejecutamos una prueba, lo ideal es crear mediante código una serie de datos ya predefinidos para poder iniciar las pruebas con datos ya disponibles, sin tener que depende de introducirlos por teclado.
Para esto, en la clase
Evento, podemos crear un
método estático que reciba un ArrayList y lo cargue con una serie de datos: Expositores, Asistentes y Eventos listos para ser utilizados en las pruebas.
/*
* El siguiente método estático es para facilitar el "entorno de pruebas".
* Añade al ArrayList recibido por argumentos unos cuántos Eventos, con sus
* Expositores y Asistentes, para que las clases de prueba puedan comenzar
* con una serie de datos cargados con los que poder trabajar sin tener
* que introducirlos a mano
*/
public static void cargarDatosPruebas(ArrayList<Evento> eventos) {
//Expositores
Expositor ex1 = new Expositor("EXPO001", "Pedro", "Baños Lopez", 15000, "pedro@balo.com");
Expositor ex2 = new Expositor("EXPO002", "Ines", "Felisa Sanchez", 17000, "ines@fesa.com");
Expositor ex3 = new Expositor("EXPO003", "Ramon", "Lobo Maturana", 12000, "ramon@loma.com");
Expositor ex4 = new Expositor("EXPO004", "Luis", "Salvat Cami", 11000, "luis@saca.com");
Expositor ex5 = new Expositor("EXPO005", "Carmen", "Robledo Velez", 20000, "carmen@rove.com");
Expositor ex6 = new Expositor("EXPO006", "Felipe", "Moreno Reina", 16000, "feli@more.com");
//Asistentes
Asistente as1 = new Asistente("ASI001", "Jorge", "Morales Garcia", "jor@moga.com", "646578090", "C/Peru");
Asistente as2 = new Asistente("ASI002", "Laura", "Juan Moragas", "lalaura@jumo.com", "634588190", "C/Lima");
Asistente as3 = new Asistente("ASI003", "Sara", "Pelaez Tuna", "sarita@petu.com", "646578090", "C/Madrid");
Asistente as4 = new Asistente("ASI004", "Guadalupe", "Flores Flores", "lupe@floflo.com", "646578090", "C/Avestruz");
Asistente as5 = new Asistente("ASI005", "Antonio", "Paz Garcia", "toni@paga.com", "646578090", "C/Pelicano");
Asistente as6 = new Asistente("ASI006", "Antonia", "Perez Castillo", "anto@peca.com", "646578090", "C/Nutria");
Asistente as7 = new Asistente("ASI007", "Alicia", "Aloy Sanchez", "ali@alsa.com", "646578090", "C/Ibice");
Asistente as8 = new Asistente("ASI008", "Javier", "Barbudo Lopez", "javi@balo.com", "646578090", "C/Muflon");
Asistente as9 = new Asistente("ASI009", "Carla", "Bella Zapata", "carla@beza.com", "646578090", "C/Alce");
Asistente as10 = new Asistente("ASI010", "Federico", "Martin Vela", "fredy@mave.com", "646578090", "C/Ecuador");
Asistente as11 = new Asistente("ASI011", "Eva", "Santamaria Lopez", "eva@salo.com", "646578090", "C/Quito");
Asistente as12 = new Asistente("ASI011", "Mario", "Moreno Cantinflas", "mario@moca.com", "646578090", "C/Mexico");
//Eventos
Evento ev1 = new Evento("Impacto Guerra Ucrania", 90, ex1, "10:00", "11:30", true, 'P');
ev1.addAsistente(as1); ev1.addAsistente(as2);
Evento ev2 = new Evento("Arte Textil Africano", 60, ex2, "12:00", "13:00", false, 'V');
ev2.addAsistente(as3); ev2.addAsistente(as4);
Evento ev3 = new Evento("Recuperacion Fauna Iberica", 90, ex3, "14:00", "15:30", true, 'G');
ev3.addAsistente(as5); ev3.addAsistente(as6);
Evento ev4 = new Evento("Nuevas Tecnicas Marketing", 45, ex4, "10:00", "10:45", false, 'V');
ev4.addAsistente(as7); ev4.addAsistente(as8);
Evento ev5 = new Evento("Presentacion Novela Historica", 60, ex5, "17:00", "18:", true, 'P');
ev5.addAsistente(as9); ev5.addAsistente(as10);
Evento ev6 = new Evento("Descifrando Codigo Ensamblador", 120, ex6, "18:00", "20:00", false, 'G');
ev6.addAsistente(as11); ev6.addAsistente(as12);
//Añadimos los eventos creados
eventos.add(ev1); eventos.add(ev2); eventos.add(ev3);
eventos.add(ev4); eventos.add(ev5); eventos.add(ev6);
}Así, en el main de nuestras pruebas, lo primero que haremos será invocar este método y pasarle nuestro ArrayList de eventos para que lo cargue con datos sin tener que hacerlo nosotros por teclado:
private static ArrayList<Evento> eventos = new ArrayList<Evento>();
private static Scanner teclado = new Scanner(System.in);
public static void main(String[] args) {
//Agregamos eventos para pruebas
Evento.cargarDatosPruebas(eventos);
//Creacion de Eventos
char terminar = 'N';
while (terminar != 'S') {
eventos.add(crearEvento());
System.out.println("\nEvento añadido. ¿Desea TERMINAR?(S/N): ");
terminar = teclado.nextLine().toUpperCase().charAt(0);
}
//Listar los Eventos
eventos.sort(MisComparadores.TITULO_EVENTO_DESCENDENTE);
System.out.println("\n\t\tLISTADO DE EVENTOS");
System.out.println("\t\t------- -- -------\n");
for (Evento even: eventos) {
System.out.println("\n\n\t\t*************************\n");
even.mostrarEvento();
}
}
Y con esto ya podemos seguir con el resto de pruebas
Intenta
Prueba02.
Recuerda que ya no tienes que introducir eventos por teclado, podemos cargar un ArrayList con eventos automáticamente llamando al método correspondiente.
Una vez cargado, haz un listado del arraylist mostrando:
- titulo del evento
- ubicación
- precio
Cuanto tengas el listado, ahora hay que ver como agrupar esos eventos por ubicación.
Para ello, intenta crear un nuevo comparador que se encargue de ordenar los eventos según la ubicación.
Una vez ordenados, ya podemos hacer una salida por pantalla en tres grupos
Inténtalo, llega hasta donde puedas, no importa si no lo consigues.
Atascarse en el intento es la mejor forma de aprender.Comparte aquí lo que logres hacer y lo completamos.
Saludos
Mostrar Mensajes
RSS