CONTINUACIÓN CÓDIGO COMPLETO
Código de la clase Evento.java
package actividadesYeventos;
public class Evento {
private String nombre;private String fecha;private String organizador;private String facultad;private String tema;//Salones de Actividades
private Actividad[] salones;public Evento() {nombre = ""; fecha = ""; organizador = ""; facultad = ""; tema = ""; salones = new Actividad[0]; //Contructor por defecto implica tener 0 salones.
}
public Evento(String nombreEven, String fechaEven, String organizaEven,
String facultadEven, String temaEven, int numSalones) {nombre = nombreEven; fecha = fechaEven; organizador = organizaEven; facultad = facultadEven; tema = temaEven; salones = new Actividad[numSalones]; //Al construir un evento, nos dirán cuantos salones tendrá
}
public String getNombre() {return nombre;}
public void setNombre(String nombreEven) {nombre = nombreEven;}
public String getFecha() {return fecha;}
public void setFecha(String fechaEven) {fecha = fechaEven;}
public String getOrganizador() {return organizador;}
public void setOrganizador(String organizaEven) {organizador = organizaEven;}
public String getFacultad() {return facultad;}
public void setFacultad(String facultadEven) {facultad = facultadEven;}
public String getTema() {return tema;}
public void setTema(String temaEven) {tema = temaEven;}
public void setNumSalones(int numSalones) {salones = new Actividad[numSalones];}
public void mostrarProgramacion() {//Es posible que no hayan salones asignados.
if (salones.length == 0)
System.out.println("\nEste EVENTO no tiene salones de ACTIVIDADES asignados"); else { /*
* Sí hay salones asignados, pero puede que aun no hayan actividades.
* Si TODAS las posiciones del array de Actividad tienen valor null,
* es que no hay actividades programadas.
*/
boolean hayActividades = false;//Si encontramos al menos 1 actividad, pasará a true
for (int i = 0; i < salones.length; i++) { if (salones[i] != null) { hayActividades = true; //Sí que hay actividades programadas
System.out.println("\nNº de Salón: " + i); System.out.println(salones[i]);//Mostramos datos de la Actividad
}
}
/*
* Terminado el bucle FOR, si la variable hayActividades
* conserva valor FALSE, es que no hay actividades
* programadas en este Evento y lo indicamos en pantalla.
*/
if (!hayActividades)
System.out.println("\nAún no se han programado ACTIVIDADES para este EVENTO");
}
}
/*
* Construye un String con los indices del arreglo
* que están libres y pueden recibir una Actividad.
* Si no hay ninguno libre, el String retornado estará vacío.
*/
public String getSalonesDisponibles() {String disponibles = ""; /*
* Recorremos los "salones", aquellos con valor null
* significa que están libres, así que recogemos su número
* para mostrarselo al usuario
*/
for (int i = 0; i < salones.length; i++)
if (salones[i] == null)
disponibles += "[" + i + "] ";
return disponibles;}
/*
* Recibe una Actividad y un número de salón donde programarla.
* Si en esta posición del arreglo (el salón) ya existe una Actividad
* o no existe dicha posición, se informará en pantalla.
*/
public void programarActividad(Actividad act, int salon) {try { if (salones[salon] == null) { //Salón disponible
salones[salon] = act; System.out.println("\nLa ACTIVIDAD ha sido programada."); }
else //Salon no tiene valor null, ya está ocupado por otro actividad
System.out.println("\nEl salón seleccionado ya tiene una ACTIVIDAD programada."); } catch(IndexOutOfBoundsException ex) { //Nos han dado un número de salón que no existe
System.out.println("\nNo existe el salón: " + salon); }
}
/*
* Busca la Actividad programada con más participantes y la retorna.
* Si no hubieran Actividades en este Evento, se retornará valor null.
*/
public Actividad getActividadMasParticipantes() {/*
* Buscaremos Actividades en los "salones" y guardaremos su cantidad de participantes
* para poder comparar con las siguientes y determinar cuál tiene
* MAYOR número de participantes.
*
* Para ello, iniciamos una variable con el valor int más BAJO posible
* y tener un valor inicial con el que poder comparar, buscando valores MAYORES
*/
int maxParticipantes = Integer.MIN_VALUE; //Para este caso, en realidad habría bastado con iniciar a 0
//Aquí guardaremos la actividad de MAYOR participacion
Actividad mayor = null;
for (Actividad activ: salones) { if (activ != null) //Solo consultamos salones que tengan Actividad programada
if (activ.getParticipantes() > maxParticipantes) { //Esta Actividad tiene MAS participantes que la anterior consultada
maxParticipantes = activ.getParticipantes(); //Actualizamos cantidad mayor de participantes
mayor = activ; //Guardamos la Actividad que, por ahora, tiene record de participantes
}
}
return mayor; //Retornamos la Actividad con más participantes
}
/*
* Busca la Actividad programada con menos participantes y la retorna.
* Si no hubieran Actividades en este Evento, se retornará valor null.
*/
public Actividad getActividadMenosParticipantes() {/*
* Buscaremos Actividades en los "salones" y guardaremos su cantidad de participantes
* para poder comparar con las siguientes y determinar cuál tiene
* MENOR número de participantes.
*
* Para ello, iniciamos una variable con el valor int más ALTO posible
* y tener un valor inicial con el que poder comparar, buscando valores MENORES
*/
int minParticipantes = Integer.MAX_VALUE;
//Aquí guardaremos la actividad de MENOR participacion
Actividad menor = null;
for (Actividad activ: salones) { if (activ != null) //Solo consultamos salones que tengan Actividad programada
if (activ.getParticipantes() < minParticipantes) { //Esta Actividad tiene MENOS participantes que la anterior consultada
minParticipantes = activ.getParticipantes(); menor = activ; }
}
return menor; //Retornamos la Actividad con más participantes
}
/*
* Retorna la suma total de participantes
* de todas las Actividades de este Evento.
*/
public int totalParticipantes() {int sumaParticipantes = 0;
//Recorremos arreglo de Actividades, y sumamos sus participantes
for (Actividad activ: salones)
if (activ != null)
sumaParticipantes += activ.getParticipantes();
return sumaParticipantes;}
/*
* Retorna el array de Actividades al completo.
*/
public Actividad[] getSalones() {return salones;}
/*
* Retorna una lista de las Actividades que expone
* el expositor especificado por parámetros.
*/
public String actividadesExpositor(String expositor) {String actividades = "";
for (Actividad activ: salones)
if (activ != null) //Si el salon tiene una Actividad...
if (activ.getExpositor().equals(expositor))//Y su Expositor coincide con el que consultan..
actividades += "- " + activ.getNombre() + "\n"; //Listamos el nombre de la Actividad
return actividades;}
}
Código de la clase MenuEventos.java
package actividadesYeventos;
import java.util.ArrayList;
import java.util.Scanner;
public class MenuEventos {
//Aquí se almacenarán los Eventos
private static ArrayList<Evento> eventos = new ArrayList<Evento>();//Objeto Scanner para leer datos por teclado
private static Scanner teclado = new Scanner(System.in);
public static void main(String[] args) {crearEventosPorDefecto(); //Invocamos método que nos proporciona dos eventos.
String opcion = "";//Variable para recoger opcion del usuario
do { System.out.println("\n\t\tMENU EVENTOS"); System.out.println("\t\t---- -------\n"); System.out.println("[1] - Crear nuevo EVENTO"); System.out.println("[2] - Crear nueva ACTIVIDAD"); System.out.println("[3] - Mostrar ACTIVIDAD con mayor número de participantes"); System.out.println("[4] - Mostrar ACTIVIDAD con menor número de participantes"); System.out.println("[5] - Mostrar total participantes de un EVENTO"); System.out.println("[6] - Mostrar ACTIVIDADES ordenadas de mayor a menor número de participantes"); System.out.println("[7] - Consultar ACTIVIDADES de un expositor"); System.out.println("[8] - Mostrar programación de un EVENTO"); System.out.println("\n[0] - SALIR del programa"); System.out.print("\nEscoja opción: "); opcion = teclado.nextLine(); //Evaluamos opcion escogida
switch(opcion) { case "0":
System.out.println("\n\t\t--FIN DE PROGRAMA--"); break; case "1":
crearEvento(); break; case "2":
crearActividad(); break; case "3":
mostrarActividadMayor(); break; case "4":
mostrarActividadMenor(); break; case "5":
mostrarTotalParticipantesEvento(); break; case "6":
mostrarActividadesMayorMenor(); break; case "7":
consultarActividadesExpositor(); break; case "8":
mostrarActividadesEvento(); break; default:
System.out.println("\nOpción no válida..."); }
pausa(); } while(!opcion.equals("0"));}
/*
* Sencillo método que pausa la ejecución del programa
* hasta que el usuario pulse ENTER/INTRO
*/
private static void pausa() {System.out.println("\nPulse ENTER para seguir...\n"); teclado.nextLine();}
/*
* Crearemos dos eventos via código para que el
* programa comience con algunos datos con los
* que trabajar
*/
private static void crearEventosPorDefecto() {/*
* Recordamos que un evento tiene los atributos:
* nombre, fecha, organizador, facultad que organiza,
* temática y salones disponibles para actividades
*/
Evento tecnotic = new Evento("Tecnotic", "03/02/2021", "Ismael Clemente",
"MIT Club of Spain", "IA aplicada en operaciones bursátiles", 5); Evento softhard = new Evento("Softhard", "14/03/2021", "ParqueSoft",
"Universidad Antonio Jose Camacho", "Software Libre en Seguridad Informática", 3); //Además, les vamos a proporcionar algunas Actividades
tecnotic.programarActividad(new Actividad("Computación neuronal", "Kenzo Hirai", "09:30", 45), 0); tecnotic.programarActividad(new Actividad("CPU cuántica", "Santiago Gutierrez", "12:00", 32), 3); softhard.programarActividad(new Actividad("Kernel UNIX", "Michael John", "13:15", 25), 1); softhard.programarActividad(new Actividad("Heurística por hardware", "Teresa Almeida", "12:00", 32), 2); //Eventos creados, los agregamos al ArrayList que los almacena
eventos.add(tecnotic); eventos.add(softhard);}
/*
* Muestra al usuario los Eventos disponibles para que
* elija uno y saldrá en pantalla sus Actividades programadas,
* si es que las tiene.
*/
private static void mostrarActividadesEvento() {System.out.println("\nEVENTOS disponibles:"); for (int i = 0; i < eventos.size(); i++) { System.out.println(i + " - " + eventos.get(i).getNombre()); }
System.out.print("\nSeleccione nº de EVENTO: "); int num = Integer.parseInt(teclado.nextLine());
/*
* Con try catch, podemos capturar la posible
* excepción que podría ocurrir si el usuario
* nos da una posición que no existe en el ArrayList
* y así obraremos en consecuencia.
*/
try { eventos.get(num).mostrarProgramacion(); } catch(IndexOutOfBoundsException ex) { System.out.println("Selección equivocada..."); }
}
/*
* Pide los datos necesarios para crear
* un Evento y lo agrega al ArrayList
*/
private static void crearEvento() {//Pedimos datos del evento
System.out.println("\nNombre del EVENTO: "); String nombre = teclado.nextLine(); System.out.println("Fecha: "); String fecha = teclado.nextLine(); System.out.println("Organizador: "); String organizador = teclado.nextLine(); System.out.println("Facultad que organiza: "); String facultad = teclado.nextLine(); System.out.println("Temática: "); String tema = teclado.nextLine(); System.out.println("Cantidad salones asignados: "); int salones = Integer.parseInt(teclado.nextLine()); //Creamos un evento nuevo y añadimos al ArrayList
eventos.add(new Evento(nombre, fecha, organizador, facultad, tema, salones));}
/*
* Permite al usuario crear una Actividad y escoger
* un Evento y salón disponible para programarla.
*/
private static void crearActividad() {//Pedimos datos de la actividad
System.out.println("Nombre de la ACTIVIDAD: "); String nombre = teclado.nextLine(); System.out.println("Expositor: "); String expositor = teclado.nextLine(); System.out.println("Hora: "); String hora = teclado.nextLine(); System.out.println("Cantidad de Participantes: "); int participantes = Integer.parseInt(teclado.nextLine());
//Creamos la Actividad
Actividad nuevaActiv = new Actividad(nombre, expositor, hora, participantes);
//Tenemos Actividad, preguntamos en que Evento lo vamos a programar
System.out.println("\nEVENTOS disponibles:"); for (int i = 0; i < eventos.size(); i++) { System.out.println(i + " - " + eventos.get(i).getNombre()); }
System.out.print("\nSeleccione nº de EVENTO: "); int num = Integer.parseInt(teclado.nextLine());
try { Evento evento = eventos.get(num); String salones = evento.getSalonesDisponibles(); if (salones.isEmpty())//Evento ha retornado un String vacío, no hay salones libres
System.out.println("Este EVENTO está completo. No hay salones disponibles."); else { System.out.println("Salones disponibles: " + salones); System.out.print("Elija salón donde programar la ACTIVIDAD: "); int salon = Integer.parseInt(teclado.nextLine()); evento.programarActividad(nuevaActiv, salon);//Pasamos actividad y salon, Evento se encarga del resto
}
} catch(IndexOutOfBoundsException ex) {//Ha elegido un evento que no existe
System.out.println("Selección equivocada..."); }
}
private static void mostrarActividadMayor() {/*
* Recorreremos los Eventos, pidiéndole a cada uno
* que nos devuelva su Actividad con más participantes
* y de todas estas nos quedaremos con la mayor de todas.
*/
Actividad mayor = null; int maxParticipantes = Integer.MIN_VALUE; String eventoMayor = ""; //También guardaremos el nombre del Evento con Actividad mayor.
for (Evento event: eventos) { if (event.getActividadMasParticipantes() != null)
if (event.getActividadMasParticipantes().getParticipantes() > maxParticipantes) { mayor = event.getActividadMasParticipantes(); maxParticipantes = mayor.getParticipantes(); eventoMayor = event.getNombre(); }
}
/*
* Comprobamos si tenemos alguna Actividad como resultado
* y mostramos datos.
* Podríamos no tener ningún resultado, debido a que quizás
* aún no se han programado Actividades.
*/
if (mayor == null)
System.out.println("No hay ACTIVIDADES programadas en ningún EVENTO"); else { System.out.println("\nACTIVIDAD con más participantes"); System.out.println("- Nombre: " + mayor.getNombre()); System.out.println("- Participantes: " + maxParticipantes); System.out.println("- Evento: " + eventoMayor); }
}
private static void mostrarActividadMenor() {Actividad menor = null; int minParticipantes = Integer.MAX_VALUE; String eventoMenor = "";
for (Evento event: eventos) { if (event.getActividadMenosParticipantes() != null)
if (event.getActividadMenosParticipantes().getParticipantes() < minParticipantes) { menor = event.getActividadMenosParticipantes(); minParticipantes = menor.getParticipantes(); eventoMenor = event.getNombre(); }
}
if (menor == null)
System.out.println("No hay ACTIVIDADES programadas en ningún EVENTO"); else { System.out.println("\nACTIVIDAD con menos participantes"); System.out.println("- Nombre: " + menor.getNombre()); System.out.println("- Participantes: " + minParticipantes); System.out.println("- Evento: " + eventoMenor); }
}
private static void mostrarTotalParticipantesEvento() {System.out.println("\nEVENTOS disponibles:"); for (int i = 0; i < eventos.size(); i++) { System.out.println(i + " - " + eventos.get(i).getNombre()); }
System.out.print("\nSeleccione nº de EVENTO: "); int num = Integer.parseInt(teclado.nextLine());
try { System.out.println("Evento seleccionado: " + eventos.get(num).getNombre()); System.out.println("Total participantes: " + eventos.get(num).totalParticipantes()); } catch(IndexOutOfBoundsException ex) { System.out.println("Selección equivocada..."); }
}
private static void mostrarActividadesMayorMenor() {//Recopilaremos TODAS las Actividades programas en un único ArrayList
ArrayList<Actividad> actividades = new ArrayList<Actividad>();
/*
* Recorremos todos los Eventos y les pediremos sus Salones.
* De estos Salones, cogeremos las Actividades programadas
*/
for (Evento event: eventos) { Actividad[] salones = event.getSalones(); for (Actividad activ: salones)
if (activ != null) //Buscamos Salones que si tengan Actividades
actividades.add(activ); }
/*
* Ya hemos recorrido todos los Eventos y tenemos sus Actividades.
* Ahora hay que ordenar de mayor a menor.
* Pero ojo, puede que no hayamos encontrado Actividades,
* o que solo haya una y por tanto no hay nada que ordenar
*/
if (actividades.isEmpty())
System.out.println("No hay Actividades programadas en ningún Evento"); else if (actividades.size() == 1) { System.out.println("\nActividades disponibles: 1"); System.out.println(actividades.get(0)); }
else { System.out.println("\nActividades disponibles: " + actividades.size()); //Método Burbuja
for (int i = 0; i < actividades.size() - 1; i++) {
for (int j = 0; j < actividades.size() - i - 1; j++) {
//Si la actividad siguiente en el array, es MAYOR que la actual...
if (actividades.get(j + 1).compareTo(actividades.get(j)) == 1) {
//...entonces hay que intercambiar sus posiciones para ordenarlas
Actividad aux = actividades.get(j + 1); actividades.set(j + 1, actividades.get(j)); actividades.set(j, aux); }
}
}
//ArrayList ordenado de mayor a menor. Mostramos las Actividades en pantalla
for (Actividad activ: actividades)
System.out.println(activ); }
}
private static void consultarActividadesExpositor() {//Pedimos nombre del expositor
System.out.print("Nombre del Expositor: "); String expositor = teclado.nextLine();
boolean actividadesEncontradas = false; //Para controlar si se encontró alguna Actividad
//Consultamos los Eventos
for (Evento event: eventos) { String actividades = event.actividadesExpositor(expositor); if (!actividades.isEmpty()) { //El String retornado NO está vacío, se han encontrado Actividades
actividadesEncontradas = true; System.out.println("\nEVENTO: " + event.getNombre()); System.out.println("ACTIVIDADES donde expone:"); System.out.println(actividades); }
}
//Tras recorrer todos los eventos, si NO se han encontrado Actividades, informamos
if (!actividadesEncontradas)
System.out.println("\nNo se han encontrado ACTIVIDADES para el Expositor: " + expositor);}
}
Saludos
Tema: java programa gestión eventos actividad ejercicio resuelto paso a paso ArrayList (Leído 7019 veces)
RSS -
WAP2