Java - Ayuda examen Java

 
Vista:
Imágen de perfil de Cristina
Val: 12
Ha aumentado su posición en 355 puestos en Java (en relación al último mes)
Gráfica de Java

Ayuda examen Java

Publicado por Cristina (5 intervenciones) el 16/06/2021 12:51:20
Hola a todos,
La semana pasada tuve examen de Java y me pusieron este ejercicio, junto con otros que realicé.
La verdad me pareció muy complicado y no supe como hacerlo, tengo la recuperación el día 25 y quiero saber hacerlo por si los ejercicios son parecidos.
Estoy bastante agobiada, si alguien me pudiera ayudar un poco.
Mil gracias
P:D He añadido el ejercicio en adjunto
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Kabuto
Val: 3.428
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Ayuda examen Java

Publicado por Kabuto (981 intervenciones) el 17/06/2021 01:36:02
Hola Cristina.
Vayamos por partes.

Esta podría ser la solución al primer punto del examen, la creación de la clase Persona.
Cumple todo lo que se pide:
- Constructor con tres parámetros que lanza una excepción si no cumple lo exigido
- Getters
- Método toString con el formato que ha de mostrarse en pantalla
- Método equals() para determinar que dos Personas son "iguales" si coincide su código
- Método compareTo() (mediante interface Comparable) para determinar como han de compararse las Personas y ordenarse según el valor del código.

Repasa el código, asegúrate de que lo entiendes todo. Pregunta lo que no entiendas, comenta lo que creas erróneo o consideres que falte, lo que sea...
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
public class Persona implements Comparable<Persona>{
 
	private String nombre;
	private int codigo;
	private int habitacion;
 
	public Persona(String nombre, int codigo, int habitacion) throws ManchaException {
		if (codigo <= 0)
			throw new ManchaException("El valor de CODIGO ha de ser mayor que 0.");
		else if (habitacion < 0)
			throw new ManchaException("El valor de HABITACION no puede ser un valor negativo");
		else {
			this.nombre = nombre;
			this.codigo = codigo;
			this.habitacion = habitacion;
		}
	}
 
	public String getNombre() {
		return nombre;
	}
 
	public void setCodigo(int codigo) {
		this.codigo = codigo;
	}
 
	public int getHabitacion() {
		return habitacion;
	}
 
	@Override
	public String toString() {
		return String.format("%s:%05d:%d", nombre, codigo, habitacion);
	}
 
	@Override
	public boolean equals(Object objeto) {
		if (objeto instanceof Persona) {
			Persona otraPersona = (Persona)objeto;
			return codigo == otraPersona.codigo;
		}
		else //El objeto con que se compara, no es clase Persona
			return false;
	}
 
	@Override
	public int compareTo(Persona otraPersona) {
 
		return Integer.compare(codigo, otraPersona.codigo);
	}
 
}


La excepción que lanza ha de ser una clase creada por nosotros llamada ManchaException.
Esta clase es tan sencillo como esto (lo escribimos en su propio archivo .java):
1
2
3
4
5
public class ManchaException extends Exception{
	public ManchaException(String mensaje) {
		super(mensaje);
	}
}

Esta primera parte se puede poner a prueba con un sencillo main.

Aquí por ejemplo incumplo el valor apropiado del atributo código para poner a prueba la excepción ManchaException:
1
2
3
4
5
6
7
8
9
10
11
12
13
public class Prueba {
 
	public static void main(String[] args) {
		try {
			Persona p = new Persona("Andres", -345, 320);
			System.out.println(p);
		} catch (ManchaException e) {
			System.out.println("ERROR: " + e.getMessage());
		}
 
	}
 
}
En pantalla vemos que funciona:
1
ERROR: El valor de CODIGO ha de ser mayor que 0.

Si paso los parámetros adecuados, no hay excepción y vemos que el método toString cumple su cometido:
1
2
3
4
5
6
7
8
9
10
11
12
13
public class Prueba {
 
	public static void main(String[] args) {
		try {
			Persona p = new Persona("Andres", 345, 320);
			System.out.println(p);
		} catch (ManchaException e) {
			System.out.println("ERROR: " + e.getMessage());
		}
 
	}
 
}
1
Andres:00345:320

O si creamos dos objetos Persona, con distinto nombre pero el mismo código, vemos que al compararlos son considerados como IGUALES, lo cuál es correcto.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class Prueba {
 
	public static void main(String[] args) {
		try {
			Persona p1 = new Persona("Andres", 345, 320);
			System.out.println("Persona 1 -> " + p1);
 
			Persona p2 = new Persona("Sara", 345, 389);
			System.out.println("Persona 2 -> " + p2);
 
			if (p1.equals(p2))
				System.out.println("\nLas personas son iguales");
			else
				System.out.println("\nLas personas son diferentes");
 
		} catch (ManchaException e) {
			System.out.println("ERROR: " + e.getMessage());
		}
 
	}
 
}

1
2
3
4
Persona 1 -> Andres:00345:320
Persona 2 -> Sara:00345:389
 
Las personas son iguales


Lo dicho, asegúrate de entender bien esta primera parte.
En cuánto pueda, pasamos al siguiente punto del examen.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Kabuto
Val: 3.428
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Ayuda examen Java

Publicado por Kabuto (981 intervenciones) el 17/06/2021 02:07:15
El siguiente punto me ha parecido un poco raro, pero bueno, haremos lo que el enunciado ordene.

Crear la clase OrdenNomCod, que hereda de Persona, y altera la forma en que han de compararse las Personas.
En esta ocasión, si el nombre es distinto, se ordenarán comparando nombres.
Si son iguales, se ordenarán comparando códigos, que es lo ya establecido en la superclase Persona.

Pues sería esto:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class OrdenNomCod extends Persona {
 
	public OrdenNomCod(String nombre, int codigo, int habitacion) throws ManchaException {
		super(nombre, codigo, habitacion);
	}
 
	@Override
	public int compareTo(Persona otraPersona) {
		//Si nombres son iguales, se ordenan por código, que es el orden ya establecido en superclase
		if (super.getNombre().equals(otraPersona.getNombre())) {
			return super.compareTo(otraPersona);
		}
		else  {//Si nombres son distintos, se ordenan por nombre
			return super.getNombre().compareTo(otraPersona.getNombre());
			//Los nombres son Strings, ya saben como han de compararse entre ellos.
		}
	}
}


Podemos ponerlo a prueba en este main.
En él, creamos tres Persona en un ArrayList, los ordenamos y los mostramos en pantalla.
Vemos que se ordenan según valor del atributo código.

A continuación creamos otro ArrayList con tres objetos de la clase OrdenNomCod, con los mismos atributos que las anteriores Persona.
Ordenamos y mostramos.
Y vemos que ahora primero se ordenan según el nombre, y si el nombre coincide, entonces según código.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
public class Prueba {
 
	public static void main(String[] args) {
		try {
 
			ArrayList<Persona> personas = new ArrayList<Persona>();
			personas.add(new Persona("Zacarias", 200, 320));
			personas.add(new Persona("Sara", 345, 389));
			personas.add(new Persona("Zacarias", 100, 389));
 
			//Ordenamos
			personas.sort(null);
 
			//Mostramos
			System.out.println("Clase Persona");
			for (Persona per: personas)
				System.out.println("--> " + per);
 
			//Creamos ArrayList con personas que se ordenan de forma alternativa
			ArrayList<OrdenNomCod> alternativa = new ArrayList<OrdenNomCod>();
			//Creamos objetos de esta clase, con los mismos atributos que antes
			alternativa.add(new OrdenNomCod("Zacarias", 200, 320));
			alternativa.add(new OrdenNomCod("Sara", 345, 389));
			alternativa.add(new OrdenNomCod("Zacarias", 100, 389));
 
			//Ordenamos
			alternativa.sort(null);
 
			//Mostramos
			System.out.println("\nClase OrdenNomCod");
			for (OrdenNomCod ord: alternativa)
				System.out.println("--> " + ord);
 
 
 
		} catch (ManchaException e) {
			System.out.println("ERROR: " + e.getMessage());
		}
 
	}
 
}

En pantalla vemos los dos tipos de ordenamiento:
1
2
3
4
5
6
7
8
9
Clase Persona
--> Zacarias:00100:389
--> Zacarias:00200:320
--> Sara:00345:389
 
Clase OrdenNomCod
--> Sara:00345:389
--> Zacarias:00100:389
--> Zacarias:00200:320

De nuevo, comprueba que entiendes el código y lo que está pasando.

El siguiente punto es crear la clase ManchaException, que eso ya lo hice en el mensaje anterior.

Por hoy, no tengo tiempo para más.
En cuanto pueda continuamos. De mientras, pregunta lo que no entiendas, o bien, intenta continuar tú misma con los siguientes puntos para detectar donde te atascas, o en que te equivocas, y así poder darte respuestas concretas.

Un saludo.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Cris
Val: 12
Ha aumentado su posición en 355 puestos en Java (en relación al último mes)
Gráfica de Java

Ayuda examen Java

Publicado por Cris (5 intervenciones) el 17/06/2021 22:01:18
Muchísimas gracias por tu ayuda.
Lo estoy viendo poco a poco, y hay cosas que viendo como las haces lo estoy entendiendo.
Me es de gran ayuda.
Te voy diciendo si tengo dudas.
gracias de nuevo
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Kabuto
Val: 3.428
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Ayuda examen Java

Publicado por Kabuto (981 intervenciones) el 18/06/2021 01:33:49
Ya he completado la parte que quedaba, la creación de la clase NeoIngreso

He de decir que no me ha quedado perfecto, más que nada porque no se si se puede o no crear más clases de las que pide el enunciado.
No aclaran de que manera quiere que relacionemos los bebes con sus madres.
Primero pensé en hacer un TreeSet para guardar las madres y un TreeMap para guardar ArrayList de bebes (ya que una madre puede tener uno o varios bebes), usando como clave el atributo código de la madre asociada.
De esta manera creo que se podría haber mantenido un orden correcto aún trabajando con dos estructuras separadas.

Pero me asaltaron varias dudas, como que no estaba seguro de si estos tipos de colecciones entraban en tu temario y luego además el enunciado dice de guardar la estructura en un archivo, pero si yo uso dos estructuras, necesitaré crear dos archivos.

Así que para no complicar demasiado las cosas, intentar ajustarme al máximo lo que dice el enunciado y dar una solución lógica (los enunciados complejos rara vez marcan las pautas adecuadas para llegar a una solución de sentido común...) al final he optado por crear una clase Madre que hereda de OrdenNomCod para que se ordene según establecimos en esta clase.

Esta clase Madre, contiene un ArrayList de Persona,que son los bebes de cada madre.

Además el enunciado dice en el punto C que hay que redefinir el método toString() para mostrar los datos de la madre seguidos de sus bebes.
Pero, ¿el método toString() de cuál clase?
No serviría hacerlo ni con el de Persona ni con OrdenNomCod, porque esta clase solo tratan una persona individual, no hay forma de que su toString() sepa como relacionar madres con bebes.

Quizás se refiera a la clase NeoIngreso que se va a crear, pero esta clase tiene más pinta de clase autogestionada, con menu de funciones y tal.., no tiene sentido que tenga un toString()....

La lógica, el sentido común, me ha llevado a crear una clase Madre, que tenga como atributo un ArrayList con sus bebes.
Y aquí sí, su método toString(), podrá mostrar datos de la madre seguidos de sus bebes.
Esta sería la clase Madre:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public class Madre extends OrdenNomCod{
 
	private ArrayList<Persona> bebes;
 
	public Madre(String nombre, int codigo, int habitacion) throws ManchaException {
		super(nombre, codigo, habitacion);
		bebes = new ArrayList<Persona>();
	}
 
	public ArrayList<Persona> getBebes() {
		return bebes;
	}
 
	public void setBebes(ArrayList<Persona> bebes) {
		this.bebes = bebes;
	}
 
	@Override
	public String toString() {
		//Construimos un String con datos de la madre y los de los bebes, si los hubiese
 
		StringBuilder datos = new StringBuilder(super.toString());//Iniciamos con datos de la madre
		//Recorremos listado de bebes y añadimos sus datos
		for (Persona bebe: bebes)
			datos.append("#" + bebe);
		//Retornamos el String construido
		return datos.toString();
	}
 
}


Con esto, ahora en la clase NeoIngreso, podemos crear como estructura de datos principal un ArrayList de clase Madre, donde cada objeto Madre contendrá su propio ArrayList de Persona, sus bebés.

Este ArrayList de Madre será la estructura que guardaremos en disco como un archivo .dat, y que a su vez recuperaremos cada vez que inicie el programa.

Esta sería la clase NeoIngreso:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
public class NeoIngreso {
 
	private ArrayList<Madre> madres;
	private Scanner teclado;
 
	public NeoIngreso() {
		teclado = new Scanner(System.in);
		madres = new ArrayList<Madre>();
		//Intentamos recuperar datos guardados en disco
		leerFichero("d:/ManchaCentro/neomancha.dat");
		//Arrancamos menu
		menu();
	}
 
	public void addMadreBebes(Madre nuevamadre, ArrayList<Persona> bebes) {
 
		//Aseguramos que los bebes están ordenados
		bebes.sort(null);
 
		/*
		 * Puede que la madre ya este registrada sin bebes asociados todavía.
		 * Comprobamos si madre ya existe en registro, en cuyo caso solo
		 * habrá que añadir los bebes asociados
		 */
		if (madres.contains(nuevamadre)) {
			/*
			 * Madre ya registrada, buscamos su posición
			 * para añadirle los bebés
			 */
			for (Madre md: madres)
				if (md.equals(nuevamadre))
					md.setBebes(bebes);
		}
		else {
			//Madre no registrada
			nuevamadre.setBebes(bebes);
			madres.add(nuevamadre);
		}
	}
 
	public void addPacientes() throws ManchaException {
 
		System.out.println("# Datos de la madre #");
		System.out.print("Nombre: ");
		String nombre = teclado.nextLine();
		System.out.print("Codigo: ");
		int codigo = Integer.parseInt(teclado.nextLine());
		System.out.print("Habitacion: ");
		int habitacion = Integer.parseInt(teclado.nextLine());
 
		Madre madre = new Madre(nombre, codigo, habitacion);
		ArrayList<Persona> bebes = new ArrayList<Persona>();
 
		char agregar = ' ';
		System.out.print("\n¿Desea agregar bebés ahora?[s/n]: ");
		agregar = teclado.nextLine().toLowerCase().charAt(0);
		while (agregar == 's') {
			System.out.println("\n# Datos del bebé #");
			System.out.print("Nombre: ");
			String nomBebe = teclado.nextLine();
			System.out.print("Codigo: ");
			int codBebe = Integer.parseInt(teclado.nextLine());
			System.out.print("Habitacion(100=incubadora): ");
			int habBebe = Integer.parseInt(teclado.nextLine());
			bebes.add(new Persona(nomBebe, codBebe, habBebe));
 
			System.out.print("\n¿Desea agregar otro bebé?[s/n]: ");
			agregar = teclado.nextLine().toLowerCase().charAt(0);
		}
 
		//Tenemos todos los datos para registrar
		addMadreBebes(madre, bebes);
	}
 
	public void listPacientes() {
		//Primero ordenamos
		madres.sort(null);
		//Y ahora mostramos
		System.out.println("\n# Listado de Pacientes #");
		for (Madre md: madres)
			System.out.println(md);
	}
 
	public void escribirFichero(String ruta) {
		try {
			File fichero = new File(ruta);
			if (!fichero.exists()) { //Si no existe
				File carpeta = new File(fichero.getParent()); //Creamos carpeta
				carpeta.mkdir();
				fichero.createNewFile(); //Creamos archivo
			}
 
			ObjectOutputStream escritor = new ObjectOutputStream(new FileOutputStream(ruta));
			escritor.writeObject(madres); //Guardamos arraylist madres
			escritor.close();
		} catch (Exception e) {
			System.out.println("No se pudo crear/guardar fichero: " + ruta);
		}
	}
 
	public void leerFichero(String ruta) {
		try {
			ObjectInputStream lector = new ObjectInputStream(new FileInputStream(ruta));
			madres = (ArrayList<Madre>) lector.readObject(); //Recuperamos ArrayList madres
			lector.close();
		} catch (IOException e) {
			System.out.println("No se pudo leer fichero: " + ruta);
		} catch (ClassNotFoundException e) {
			System.out.println("No se reconocen los datos del fichero: " + ruta);
		}
	}
 
	public double mediaBebes() {
		float contadorMadres = 0;
		float contadorBebes = 0;
 
		for (Madre md: madres)
			if (md.getBebes().size() != 0) {//Esta madre SÍ tiene bebes
				contadorMadres++;
				contadorBebes += md.getBebes().size();
			}
 
		return contadorBebes / contadorMadres;
	}
 
	public int encontrarMadre(int codigo) throws ManchaException {
 
		for (Madre md: madres)
			if (md.getCodigo() == codigo)
				return md.getHabitacion();
		//Si el bucle anterior no ha retornado nada, es que la madre no está registrada
		throw new ManchaException("No hay ninguna madre ingresada con CODIGO: " + codigo);
	}
 
	public void menu() {
		int opcion = 0;
		while (opcion != 5) {
			System.out.println("\n\t\tHospital Mancha Centro");
			System.out.println("\t\t-------- ------ ------\n");
			System.out.println("[1] --- Añadir Pacientes");
			System.out.println("[2] --- Listar Pacientes");
			System.out.println("[3] --- Obtener media de Bebes/Madres");
			System.out.println("[4] --- Encontrar Madre");
			System.out.println("[5] --- TERMINAR PROGRAMA");
			System.out.print("Opcion: ");
			opcion = Integer.parseInt(teclado.nextLine());
 
			switch(opcion) {
			case 1:
				try {
					addPacientes();
				} catch (ManchaException e) {
					System.out.println(e.getMessage());
				}
				break;
			case 2:
				listPacientes();
				break;
			case 3:
				System.out.printf("Media de bebes/madre: %.2f\n", mediaBebes());
				break;
			case 4:
				System.out.println("\n# Buscar Madre #");
				System.out.print("Codigo: ");
				int codigo = Integer.parseInt(teclado.nextLine());
				try {
					System.out.println("Habitacion: " + encontrarMadre(codigo));
				} catch (ManchaException e) {
					System.out.println(e.getMessage());
				}
				break;
			case 5:
				//Guardamos antes de cerrar
				escribirFichero("d:/ManchaCentro/neomancha.dat");
				System.out.println("\n\t\tFIN DE PROGRAMA");
				break;
			default:
				System.out.println("Opción equivocada");
			}
		}
	}
 
	public static void main(String[] args) {
		new NeoIngreso(); //Al invocar constructor, se cargan datos del disco y comienza el menu()
	}
}

Como he dicho, no es perfecta.
Por ejemplo, no se está garantizando que los atributos "codigo" de los bebes sean únicos.
Se podría hacer que al teclear el código de bebe, se haga una búsqueda de todas las madres y de todos sus bebes comprobando si es único o no.
Si no lo es, se rechaza y se vuelve a pedir.
Pero no he querido complicar más el código, al menos por ahora.

Si pudiéramos alejarnos más del enunciado, se le podría haber dado otro enfoque donde los códigos de madre y bebe se autogeneren en base a unas reglas y así se garantizan de que son únicos. Pero bueno.


Por cierto, para poder guardar el ArrayList con los objetos Madre, hay que hacer una modificación en la superclase Persona.
Hay que implementarle la interface Serializable, para que permita poder guardarse en disco como un archivo de bytes.

Y hay que corregir un error que tuve en mi mensaje anterior.
En la clase Persona, para el atributo "codigo", puse un setter y no un getter.
El setter es innecesario, se puede dejar o quitar.
Pero el getter es imprescindible.

Así que a la clase Persona, hay que hacer los cambios que marco abajo en negrita:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
public class Persona implements Comparable<Persona>, Serializable{
 
	private String nombre;
	private int codigo;
	private int habitacion;
 
	public Persona(String nombre, int codigo, int habitacion) throws ManchaException {
		if (codigo <= 0)
			throw new ManchaException("El valor de CODIGO ha de ser mayor que 0.");
		else if (habitacion < 0)
			throw new ManchaException("El valor de HABITACION no puede ser un valor negativo");
		else {
			this.nombre = nombre;
			this.codigo = codigo;
			this.habitacion = habitacion;
		}
	}
 
	public String getNombre() {
		return nombre;
	}
 
	public int getCodigo() {
		return codigo;
	}
 
	public int getHabitacion() {
		return habitacion;
	}
 
	@Override
	public String toString() {
		return String.format("%s:%05d:%d", nombre, codigo, habitacion);
	}
 
	@Override
	public boolean equals(Object objeto) {
		if (objeto instanceof Persona) {
			Persona otraPersona = (Persona)objeto;
			return codigo == otraPersona.codigo;
		}
		else //El objeto con que se compara, no es clase Persona
			return false;
	}
 
	@Override
	public int compareTo(Persona otraPersona) {
 
		return Integer.compare(codigo, otraPersona.codigo);
	}
 
}

Y ya está.
Se que he soltado mucho código de golpe. Revísalo poco a poco y pregunta lo que quieras.

Un saludo Cristina.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Cris
Val: 12
Ha aumentado su posición en 355 puestos en Java (en relación al último mes)
Gráfica de Java

Ayuda examen Java

Publicado por Cris (5 intervenciones) el 20/06/2021 20:30:20
Muchísimas gracias, de verdad,
una duda que me ha surgido es porque cuando ordenas con sort pones null y no un atributo del objeto
gracias :)
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Kabuto
Val: 3.428
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Ayuda examen Java

Publicado por Kabuto (981 intervenciones) el 20/06/2021 23:28:49
1
una duda que me ha surgido es porque cuando ordenas con sort pones null y no un atributo del objeto

El método sort(), por paréntesis no recibe atributos, lo que espera recibir es un objeto de la clase Comparator.

Las clases Comparator sirven para indicar cómo han de compararse dos objetos de una determinada clase. Así, si al sort() le pasamos un objeto de este tipo, usará las reglas de comparación que contiene para ordenar el ArrayList.

Si en cambio le pasamos valor null al sort(), entonces el ArrayList lo que hace es ver si los elementos que contiene son capaces de comunicarle cómo se han de ordenar.
Como en nuestro código a las clases ya les hemos implementado la interfaz Comparable (muy parecido a Comparator pero distinto), por eso le pasamos valor null al sort(), porque los elementos ya saben como han de ordenarse.


Recapitulando.
- Al sort() no le podemos decir directamente que ordene por un atributo concreto. No funciona así.
- Podemos darle un Comparator y lo usará para saber como ha de ordenar sus elementos.
- Si no le damos nada, es decir, le damos null, entonces ordenará según indiquen los elementos del ArrayList, mediante la interfaz Comparable

La diferencia entre Comparator y Comparable es muy sutil.

Comparable lo usamos para que una clase, sepa como compararse con las de su especie. Se aplica directamente a la clase que queremos ordenar.

Comparator en cambio, se usa para que una clase, sepa indicar a sort() cómo ha de ordenar objetos de una clase de una especie distinta. No se aplica directamente a la clase que queremos ordenar.
Se usa para crear una clase separada, para indicarle a sort() como comparar los objetos del ArrayList.
Si estos objetos implementan Comparable, pero al sort() le pasamos un Comparator, el ArrayList no hará caso de lo que digan el Comparable de los objetos, dará preferencia a las reglas del Comparator


Te voy a poner un ejemplo.
Vamos a añadirle a nuestro proyecto una nueva clase, será un Comparator que impondrá la regla de que las Persona se han de ordenar según la habitación

1
2
3
4
5
6
7
8
9
10
import java.util.Comparator;
 
public class OrdenarPorHabitacion implements Comparator<Persona>{
 
	@Override
	public int compare(Persona per1, Persona per2) {
		return Integer.compare(per1.getHabitacion(), per2.getHabitacion());
	}
 
}

Fíjate que es una clase nueva, no se aplica directamente a la clase Persona ni a sus hijas. Es una clase totalmente ajena.


Ahora, en la clase NeoIngreso, en el método de listar pacientes vamos a imprimir el listado dos veces.
Uno, como hacíamos antes. A sort() le damos valor null y entonces se ordena según el Comparable que implementa Persona (y que sobreescribimos en OrdenNomCod)

En el segundo listado, al sort() le paramos un objeto Comparator de la nueva clase que hemos creado.
Aquí entonces el Comparable será ignorado y se aplicarán las reglas del Comparator

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public void listPacientes() {
    //Primero ordenamos
    madres.sort(null);
    //Y ahora mostramos
    System.out.println("\n# Listado de Pacientes #");
    for (Madre md: madres)
        System.out.println(md);
 
    /* *****AÑADIDO DE PRUEBA*****  */
    System.out.println("\n\nOrdenamiento alternativo por habitación");
    madres.sort(new OrdenarPorHabitacion());
    System.out.println("\n# Listado de Pacientes #");
    for (Madre md: madres)
        System.out.println(md);
}


Si ejecutamos, veremos como cambian los ordenamientos:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
Hospital Mancha Centro
		-------- ------ ------
 
[1] --- Añadir Pacientes
[2] --- Listar Pacientes
[3] --- Obtener media de Bebes/Madres
[4] --- Encontrar Madre
[5] --- TERMINAR PROGRAMA
Opcion: 2
 
# Listado de Pacientes #
Eva:00030:345#Lydia:00031:10#Pedro:00032:100#Xavi:00033:23
Laura:00020:234#PEdro:00021:234#Cristina:00022:234
Sara:00010:123#Koki:00011:100
Vicenta:00040:444#Julio:00045:455
 
 
Ordenamiento alternativo por habitación
 
# Listado de Pacientes #
Sara:00010:123#Koki:00011:100
Laura:00020:234#PEdro:00021:234#Cristina:00022:234
Eva:00030:345#Lydia:00031:10#Pedro:00032:100#Xavi:00033:23
Vicenta:00040:444#Julio:00045:455



Espero haber aclarado tus dudas.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Cris
Val: 12
Ha aumentado su posición en 355 puestos en Java (en relación al último mes)
Gráfica de Java

Ayuda examen Java

Publicado por Cris (5 intervenciones) el 28/06/2021 22:32:21
Gracias por tu ayuda, tuve el examen el día 25 y conseguí aprobar. El año que viene me quedan 4 asignaturas a ver que tal. Gracias
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Kabuto
Val: 3.428
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Ayuda examen Java

Publicado por Kabuto (981 intervenciones) el 29/06/2021 00:32:51
Me alegra que haya ido bien.
Y ánimo con las otras 4 asignaturas. Te deseo lo mejor.

Pero ahora, toca disfrutar del verano je je.
Ciaoo
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar