6ª opcion.
Ordenar de mayor a menor.
La cosa consistiría en recorrer todas las Actividades, de todos los Eventos, y ordenarlas según su atributo número de participantes.
Para ordenarlas, previamente habría que juntarlas todas en una misma colección.
Se podría usar un arreglo normal, pero como no sabemos cuántas Actividades vamos a encontrar, pues no sabemos a que tamaño deberíamos inicializarlo.
Para resolver este inconveniente tenemos dos opciones:
- Añadir más código extra para primero sumar las Actividades existentes y así saber que tamaño necesitamos para el arreglo. Esto además supone más ciclos de computación.
- Usar un ArrayList, que como ya explicamos, no tiene tamaño fijo y podemos ir metiéndole Actividades según las vamos encontrando, sin tener que contar primero cuántas hay.
Yo prefiero la segunda opción.
Así, crearemos un ArrayList con todas las Actividades, las ordenaremos, y las mostraremos en pantalla.
¿Y como ordenamos de mayor a menor?
Habrá que pedirle a cada actividad que nos indique sus participantes, comparar las participantes de una con las demás e intercambiar las posiciones entre ellas hasta conseguir que primero estén las de mayor participación y al final las de menos.
Ya puestos, podemos aprovechar y aprender algo nuevo usando la
interfaz ComparablePodemos pedirle a la clase
Actividad que implemente esta interfaz, y esto nos añadirá un método que vamos a sobreescribir para que "enseñarle" como una Actividad ha de compararse con otra para decidir cuál es mayor y cuál menor.
Para ello, nos vamos a la clase
Actividad y le pedimos que implemente esta interfaz:
package actividadesYeventos;
public class Actividad implements Comparable<Actividad>{
private String nombre;
private String expositor;//Persona que expone
private String hora;
private int participantes;
Con esa línea en negrita le estamos diciendo que implemente la interfaz Comparable, y que solo ha de aceptar objetos que pertenezcan a la clase Actividad para poder hacer la comparación.
No tiene sentido que acepte compararse con un String, o con un Integer, o con un Evento... ni con absolutamente nada que no sea una Actividad.
Al pedirle que implemente esa interfaz, el compilador/IDE nos va a EXIGIR que a esta clase le añadamos un método llamado
compareTo().
Es dentro de este método donde vamos a poner el código para decidir cómo se han de comparar los objetos Actividad para decidir quien es mayor o menor.
Nosotros decidimos como hacerlo, podríamos decirle que se ordenara según el tamaño de su nombre, o por orden alfabético, o según la hora en la que la Actividad esta programada...
En este caso, nos interesa que se ordenen según la cantidad de participantes
/*
* Este método recibe "otra" Actividad por parámetro para compararse
* con "esta" Actividad.
* La comparación es para determinar una relación ordinal, es decir,
* quien es "menor" y quien es "mayor".
* La Actividad con MENOS participantes se considerará menor que otra
* con MÁS participantes.
*
* Si el objeto recibido tiene valor null, se producirá una excepción.
*/
@Override
public int compareTo(Actividad otraActividad) {
//Comparamos sus participantes, para ver quien es menor o mayor, o si son iguales
if (participantes == otraActividad.getParticipantes())
return 0; //Mismo número de participantes, son iguales
else if (participantes < otraActividad.getParticipantes())
return -1; //Esta Actividad es "menor" que la Actividad recibida por parámetro.
else
return 1; //Esta Actividad es "mayor".
}Este método decide la comparación retornando un int.
Si el int es 0, es que los objetos son "iguales", es decir ninguno es mayor o menor.
Si retorna un valor negativo, es que ESTE objeto,
es menor que el OTRO objeto que ha recibido por parámetros para compararse.
Si ESTE objeto es mayor, entonces retorna un valor positivo.
Java usa esta forma de compararse con la intención de que sea igual para todas las clases. Así luego podemos pedirle a las colecciones de datos que se ordenen ellas solas.
Es decir, el ArrayList de Actividades que vamos a construir después, si queremos ya podemos decirle con la instrucción
sort() que el solito ordene sus elementos. Porque sus elementos ya tienen el método
compareTo() y ya saben compararse ellos mismos para indicar quien es menor y quien es mayor.
Sin embargo, para este ejercicio cuyo propósito es aprender cosas nuevas, no vamos a ser tan cómodos de usar el
sort() y usaremos un algoritmo de ordenación para hacer nosotros la tarea de ordenar.
Para esto, nos vamos a la clase
MenuEventos para crear el método que mostrarás las Actividades ordenadas.
Este método, va a realizar estos pasos:
- Crear un ArrayList para objetos de la clase Actividad
- Recorrer cada Evento, y de cada Evento, recorrer sus "salones" buscando Actividades programadas que añadiremos a ese ArrayList.
- Ordenar el ArrayList de mayor a menor.
- Mostrar las Actividades en pantalla.
Aquí tenemos un problemita, para recorrer los "salones" de un Evento, necesitamos que el Evento nos de acceso directo a ellos. Y ahora mismo nuestra clase Evento no tiene ningún método que nos de ese acceso.
Así que primero, a la clase
Evento vamos a darle este método para que nos retorne su arreglo de Actividades (sus "salones") y así tener libre acceso a ellos:
/*
* Retorna el array de Actividades al completo.
*/
public Actividad[] getSalones() {
return salones;
}Con esto solucionamos el problemita para cumplir el segundo paso.
Ya sí podemos añadir este método a la clase
MenuEventos 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);
}
}Para ordenar estamos usando el
algoritmo de la Burbuja, un sistema muy usado en programación, de los primeros que se enseñan. No es el más óptimo pero si sencillo de usar y entender. Aunque puede que al principio tengas que ver más ejemplos para entender como funciona.
Y con esto, ya solo queda llamar a este método dentro del SWITCH
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":
System.out.println("\nEn construccion...");
break;
Y ya podemos ver todas las Actividades ordenadas de mayor a menor.
Fíjate que si quisiéramos cambiar el orden y mostrarlas de menor a mayor, nos bastaría con pedirle al algoritmo de la burbuja que haga el cambio cuando
compareTo() devuelva -1
//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 MENOR 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);
}
}
}
Tema: java programa gestión eventos actividad ejercicio resuelto paso a paso ArrayList (Leído 8078 veces)
RSS -
WAP2