Saltar navegación

20260210 EjerColecciones_2_Comparable - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 10 de febrero de 2026 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Vamos a hacer el método de mostrar un listado alfabético. 00:00:01
Vamos a entender primero la aplicación. 00:00:07
La aplicación tiene la clase alumno, por ahora esto lo vamos a quitar, 00:00:10
porque como tu lucidez no ha dado para completarlo, pues lo quitamos. 00:00:13
Tenemos nuestro alumno con NIF nombre y nota, constructores, get y set, 00:00:18
Hasco de Equals 00:00:23
Por 00:00:25
Por NIF 00:00:25
Y este que lo vamos a quitar 00:00:28
Porque 00:00:31
No vale para nada 00:00:31
Vale, la clase alumno 00:00:34
Te la aprobamos 00:00:37
Vale 00:00:38
Me gustaría en tu stream 00:00:39
De Yasmín 00:00:43
Vale, la clase alumno ya está, te la aprobamos 00:00:44
Venga, clase profesor 00:00:47
Clase profesor tiene una lista de alumnos 00:00:48
Vale 00:00:52
yo aquí 00:00:52
a menos que vayas a usar 00:00:55
los métodos específicos de linked list 00:00:58
el push, el pull 00:01:00
yo aquí no pondría linked list 00:01:02
pondría list directamente 00:01:04
hace el código un poquito más legible 00:01:06
¿vale? 00:01:09
constructor 00:01:11
get set 00:01:12
aquí por tanto 00:01:14
get set 00:01:15
y luego has puesto algunos métodos del tipo 00:01:20
Vamos a ver todos los alumnos de la lista 00:01:23
Has recorrido la lista 00:01:25
Más cómodo 00:01:27
De escribir 00:01:33
En este momento 00:01:34
Que solamente vas a recorrer para mostrar 00:01:35
Más cómodo que lo hagas con un for each 00:01:37
Directamente 00:01:40
Que no con un for de índice 00:01:40
Y si alumno tiene tu string 00:01:42
Que lo tiene 00:01:47
Si alumno tiene tu string 00:01:48
Puedes 00:01:50
Tirar 00:01:52
Si es solamente para verlos 00:01:54
puedes tirar del 00:01:55
toString de list 00:01:57
y hacer directamente system.out.println 00:01:58
alumnos. 00:02:02
Porque el toString de list ya te 00:02:03
hace un mostrado bastante apañado de los 00:02:05
elementos de una lista. Llamando a 00:02:07
los toString de alumnos. 00:02:09
Pero vamos, que esto está bien igualmente. 00:02:11
Vale, en profesor vamos 00:02:14
a buscar un alumno 00:02:15
dado su NIF. Pues 00:02:17
recorres y lo devuelves. 00:02:20
Vale, 00:02:24
Dos retun, dos puntos de salida 00:02:25
No pasa nada 00:02:27
Feo, pero no pasa nada 00:02:29
Al final acabamos programando un poco así 00:02:31
¿Vale? 00:02:34
¿Esto es lluvia? 00:02:35
Porcentaje de aprobados 00:02:38
Yo aquí añadiría 00:02:39
Si alumnos es 00:02:43
Igual a nul 00:02:48
Mucho mejor 00:02:53
porque a ver, tú sabes 00:02:55
en principio que esta colección 00:02:59
la has inicializado 00:03:01
pero en realidad no sabes en qué momento vas a acabar 00:03:03
llamando a este método, igual llamas a este método 00:03:05
habiendo puesto alguien esa colección 00:03:07
a nul, habiendo tenido esa 00:03:09
buenísima idea 00:03:11
entonces esta verificación es mucho mejor 00:03:12
y más habitual 00:03:15
si alumnos es nul o 00:03:16
sin ser nul, su tamaño es cero 00:03:19
no hay porcentaje de aprobados 00:03:21
y si su tamaño no es cero 00:03:23
pues ya sumas 00:03:27
los aprobados y los divides entre el total 00:03:28
y lo conviertes a 00:03:31
double, la división 00:03:33
pero, a ver 00:03:35
conviertes 00:03:37
a double después 00:03:39
con lo cual esta división 00:03:41
es la división entera, porque se está haciendo 00:03:43
división entre dos enteros, esta convención a double 00:03:45
no te vale para nada, ¿vale? 00:03:47
si quieres con decimales tendrías que convertir a double 00:03:50
O bien aprobados 00:03:52
O bien alumnos.6 00:03:55
Uno de los dos 00:03:56
Entonces ya la división se convierte en división con decimales 00:03:56
Y ya no tendrías este casting 00:04:00
Es decir, estos paréntesis 00:04:01
Así 00:04:04
Por ejemplo, ya está 00:04:06
Simplemente eso 00:04:08
Porque entiendo yo que el operador va antes del casting 00:04:09
A lo mejor no, a lo mejor me estoy 00:04:15
Colando 00:04:16
Y primero hace el casting 00:04:17
Y luego ya hace la división 00:04:19
No lo sé 00:04:25
Pero yo creo que 00:04:27
En cualquier caso 00:04:28
Esto es más seguro 00:04:31
Pero bueno, se podría comprobar 00:04:34
Para ver exactamente qué hace 00:04:36
Si primero hace la división y luego el casting al revés 00:04:37
Vale 00:04:40
¿Tenemos un alumno con ese NIF? 00:04:41
Pues esto está bien 00:04:45
Porque no ha salido con un retún por medio 00:04:46
Está muy bien 00:04:48
¿Eh? 00:04:50
Vale 00:04:52
Punto string, eliminar alumno 00:04:53
¿Creas un alumno con el criterio de igualdad? 00:04:55
fuera, borrado 00:04:57
y ahora, ahora viene lo que nos interesa 00:04:58
y lo que nos gusta 00:05:02
vamos a hacer un listado 00:05:03
de alumnos alfabéticamente ordenados 00:05:05
pues esto sería tan bonito 00:05:07
como ordenar la lista 00:05:10
ordenar la lista 00:05:11
para eso hay ya algoritmos de ordenación 00:05:13
planteados, como el de la burbuja 00:05:16
el quizor, que no tenemos tiempo para ver 00:05:19
cómo funcionan por dentro 00:05:21
que ya están programados dentro de métodos 00:05:23
Entonces, mi objeto alumnos, por ser una lista, tiene un método sort, ¿vale?, que me ordena, ¿vale?, tiene un método sort que me ordena, alumnos, ¿vale? 00:05:26
Entonces, el método sort me está diciendo que le pase un criterio de comparación, pero yo puedo ignorarlo y decir, no, no te paso ningún criterio de comparación, 00:05:42
porque el criterio de comparación ya lo voy a guardar 00:05:59
en la clase alumna 00:06:02
¿Vale? Ese sería el plan A 00:06:03
El plan B sería no guardar el criterio 00:06:05
en la clase alumno y pasárselo por aquí 00:06:08
Vamos a hacer primero el plan A 00:06:10
Plana, quiero dar a los alumnos 00:06:11
Primera pregunta que me hago 00:06:14
¿Quiero que se queden ordenados de por vida? 00:06:16
¿O solo quiero mostrar el listado alfabético 00:06:18
pero quiero que los alumnos se queden 00:06:20
en el orden de inserción que estaban? 00:06:22
¿Vale? 00:06:25
Pues entonces, depende de lo que yo quiera 00:06:26
porque el método sort 00:06:28
¿qué es lo que hace? 00:06:30
la lista 00:06:32
¿vale? 00:06:33
te la deja ordenada 00:06:38
entonces si no queremos que la deje ordenada 00:06:39
si lo que queremos es solo para el listado 00:06:42
pues entonces podríamos copiar 00:06:44
alumnos en otra lista 00:06:46
y ordenar esa ¿vale? 00:06:48
pero bueno, vamos a ordenarla 00:06:50
sin más 00:06:52
vale, alumnos.sort 00:06:53
y ahora yo 00:06:57
ya la recorrería 00:06:58
mostraría 00:06:59
vale, entonces 00:07:02
ah, que me devuelve la lista ordenada 00:07:12
vale, retun alumnos 00:07:14
bueno, no 00:07:16
que la devuelva, y luego la 00:07:18
es que lo mejor es devolverla y no hacer aquí el siso 00:07:19
eso es lo mejor realmente 00:07:22
retun 00:07:23
alumnos 00:07:26
vale, pues entonces 00:07:27
tú tienes en tu 00:07:32
main unas pruebas 00:07:34
hechas o algo, un menú 00:07:36
y cuáles 00:07:37
todas las funciones del menú te funcionan 00:07:39
¿no? insertar profesor 00:07:42
alargar nuevo alumno, poner nota, mostrar 00:07:44
alumno enfáticamente, las 6 es 00:07:46
¿vale? entonces vamos a suponer que 00:07:48
vamos a ejecutar esto 00:07:50
insertamos 00:07:52
profesor, nif 00:08:01
y nombre, ahí te falta 00:08:03
el next line 00:08:06
vale, pues venga 00:08:08
vámonos a salir 00:08:10
¿con qué se sale? 00:08:11
Vale, pues nos falta 00:08:12
Next in 00:08:20
Y ahora nos queda aquí el next line 00:08:23
¿No? Vale, ejecutamos 00:08:25
Otra vez 00:08:35
Vamos a insertar un profesor 00:08:36
Nib del profesor, Pepe, nombre del profesor 00:08:39
Pepe, nombre 00:08:44
Ala, ya está 00:08:45
Vamos a agregarle un alumno, dos 00:08:48
Para que los ordene alfabéticamente 00:08:51
nif del alumno 00:08:52
1, 2, 3, 4 00:08:55
nombre del alumno 00:08:56
Pepito 00:08:57
nif del profesor a quien se lo quiero agregar 00:08:59
a este 00:09:06
no se ha encontrado el profesor 00:09:06
ya te hemos encontrado un pedazo de bug 00:09:10
no se ha encontrado 00:09:12
el profesor con ese nif 00:09:14
y yo le he pasado un profesor 00:09:15
cuyo nif es este 00:09:17
esto ha fallado en la opción 00:09:19
agregar nuevo alumno a un profesor 00:09:23
Vamos a ver, vamos a agregar nuevo alumno a un profesor, NIF del profesor, aquí lo lees, y ahora llamas a buscar profesor con ese nombre, buscar profesor, recorres la colección de profes, si su NIF, vale, aquí podrías ahorrarte todo esto y poner un equals, ¿no? 00:09:25
Ah, vale 00:09:55
Ah, bueno, vale 00:09:58
Pero podrías haberlo puesto 00:10:01
Entonces, ReptumProfes 00:10:02
Y voy a hacer 00:10:05
.size 00:10:06
Y ahora 00:10:07
Los datos, ¿dónde los tienes? 00:10:09
En el main 00:10:12
Los datos los tienes aquí en el main 00:10:13
¿No? En tus profes 00:10:17
Vale, y tú cuando agregas el profe 00:10:17
Lo has agregado de verdad 00:10:21
Vamos a ver 00:10:22
profes has agregado de verdad 00:10:23
entonces 00:10:27
main buscar profesor 00:10:29
es igual al if que me han dado 00:10:33
vale, y ahora 00:10:44
en tu main 00:10:46
cuando llamas aquí 00:10:48
aux 00:11:00
no es null 00:11:00
añades a los alumnos de aux 00:11:02
El alumno, y si no nos ha encontrado 00:11:05
Aquí está entrando en el else, es decir 00:11:07
Aux está siendo null 00:11:09
¿Por qué está siendo aux null? 00:11:11
¿Por qué está siendo null? 00:11:24
Estás recorriendo esta colección 00:11:25
¿Verdad? 00:11:27
Que está aquí arriba 00:11:29
A ver, vamos a volverlo a ejecutar 00:11:30
Nif, uno, dos, tres y cuatro 00:11:37
Nombre 00:11:41
Ya está 00:11:43
Agregar alumno 00:11:45
2, 2, 2, 2 00:11:47
Nombre del alumno 00:11:49
Nif del profesor 00:11:51
A quien se lo queremos agregar 00:11:53
1, 2, 3 y 4 00:11:54
No se ha encontrado el profesor 00:11:57
Bueno, es que en el print 00:12:00
Aquí en el caso 3 00:12:06
Este print sale solo 00:12:09
En el else de este aux 00:12:13
Con lo cual solo si aux es igual a null 00:12:15
Con lo cual 00:12:17
Este método te está devolviendo nulo 00:12:18
Entonces vamos a ponerle aquí 00:12:20
Esto no se hace 00:12:22
Se debuguea, ¿vale? 00:12:24
No se pone en System.Auth 00:12:26
Se hace el debug 00:12:28
Pero como nosotros 00:12:31
Estamos por encima de todo eso 00:12:32
¿Vale? 00:12:35
Vamos a ver el nif del profesor que le pasamos 00:12:38
Eso lo pasamos correctamente 00:12:40
Vamos a ver 00:12:42
Vamos a salir de aquí 00:12:43
Cerrando 00:12:48
Ejecutamos 00:12:52
1, 2, 3 y 4 00:12:53
2, agregar alumno 00:12:58
1, 1, 1, 1 00:13:03
Nombre de alumno, NIF del profesor 00:13:04
1, 2, 3 y 4 00:13:07
Lo coge correctamente 00:13:09
1, 2, 3 y 4 00:13:14
Y ahora cuando llama este método 00:13:16
O sea, esto está claro 00:13:18
Cuando llamamos 00:13:20
Este método 00:13:22
A ver si cuando instancias el profesor 00:13:23
Lo instancias con el nombre y el nif cambiado 00:13:46
Que no sería la primera vez que pasa 00:13:49
Le cambias el nif por nombre 00:13:50
A ver, primero nif y luego nombre 00:13:54
Dis.nif igual a nif 00:13:56
Pues vamos a ver cuando agregas profe 00:13:58
Cuando agregas profe 00:14:00
Míralo 00:14:04
Aquí está el error 00:14:06
Buen ejemplo de que los errores de una zona 00:14:08
suelen venir por cosas que están 00:14:11
completamente alejadas 00:14:13
e impensables 00:14:15
que cuando construía el profesor 00:14:16
le pasa el nombre donde tiene que ir el NIF 00:14:19
y el NIF donde tiene que ir el nombre 00:14:22
entonces uno efectivamente se está 20 años con esto 00:14:23
pero cuando ya le pasa una vez ya no le vuelve a pasar 00:14:30
¿vale? buena enseñanza 00:14:33
¡qué vergüenza! 00:14:35
¿ves? si ya sabías que te ibas a ir humillada 00:14:38
1, 2, 3 y 4 00:14:40
agregamos nuevo alumno, nid del alumno 00:14:47
1, 1, 1, 1 00:14:49
Juanito 00:14:51
1, 2, 3 y 4 00:14:52
a ver 00:14:54
que feo 00:14:57
alumno agregado correctamente 00:14:58
vale, pero salvo por alumno 00:15:01
agregado correctamente se supone que ya está 00:15:03
y ahora 00:15:05
vamos a agregarle otro 00:15:07
para ordenar alfabéticamente 00:15:09
que como sabemos que no va a funcionar 00:15:10
venga, vamos a agregar otro alumno 00:15:13
nivel alumno, 2, 2, 2, 2 00:15:14
vamos a llamarle a este 00:15:16
que vaya 00:15:19
antes para que los cambie 00:15:20
esta se llama Ana 00:15:22
nivel 00:15:25
1, 2, 3 y 4 00:15:27
agregado 00:15:28
ahora 00:15:30
si llamamos a la opción 00:15:34
la de mostrar a los alfabéticos no entordenados 00:15:37
que es la que llama al sort 00:15:40
Si llamamos a la función 6 00:15:41
¿Vale? 00:15:44
No ha hecho 00:15:46
Espérate, es que debería haber dado un error 00:15:47
En lugar de no hacer nada 00:15:49
Ah, es que la función 6 00:15:51
Vale, en la función 6 lo que nosotros querríamos hacer sería 00:15:53
Un siso de 00:15:56
Lo que nos devuelve el método 00:16:00
Que el método está en profesor, ¿verdad? 00:16:03
Entonces 00:16:06
¿Verdad? 00:16:07
de un profesor. Ah, bueno, habrá que pedir el profesor. 00:16:09
Nib del profe. 00:16:12
Control C. 00:16:17
Vale. 00:16:18
Entonces, caso 6. 00:16:21
Necesitamos, antes que nada, 00:16:24
pedir el nib del profesor 00:16:26
del que quiere sacar el listado. 00:16:27
Y ahora, 00:16:33
nib del profesor. 00:16:35
Vale. 00:16:37
Y ahora, 00:16:39
vamos a 00:16:40
sacar la posición en la que está 00:16:43
este profe para luego llamar 00:16:46
a sort, vamos a sacar la posición 00:16:48
en que está este profe 00:16:50
la posición en la que está este profe es 00:16:52
tan fácil como 00:16:54
profes 00:16:55
profes está aquí en mi main 00:16:57
puedo llamarlo directamente 00:16:59
no está aquí profes en mi main 00:17:01
vale 00:17:03
pues profes está aquí 00:17:05
entonces 00:17:10
profes.index 00:17:12
index of new profesor de nif, este de aquí, nombre, me da lo mismo. 00:17:15
Entonces, este me da la posición del profe con ese nif. 00:17:30
Y ahora, el profe con esa posición, get posición, le llamo al método listado alfabético. 00:17:33
Y ahora a este le paso 00:17:48
Sí, lo acabo de llamar 00:17:51
Y ahora ya llamo al SISO de este de aquí 00:17:52
¿Qué método? 00:17:54
Bueno, no es que se pueda eliminar 00:18:05
Es que le metes este código dentro 00:18:06
Le metes esto dentro y ya está 00:18:08
Pero sí que tendrías que sacarlo del main 00:18:10
Idealmente 00:18:13
Vale, pues entonces le ponemos el SISO aquí 00:18:14
Venga 00:18:17
y voy a bajar 00:18:20
esto del system out 00:18:38
aquí abajo 00:18:38
vale 00:18:39
pues lo 00:18:42
que hemos hecho aquí 00:18:43
en este código 00:18:44
lo entendemos 00:18:45
¿no? 00:18:47
nos dan el nif 00:18:48
de un profesor 00:18:49
sacamos 00:18:50
el profesor 00:18:52
con ese nif 00:18:54
no estamos ni validando 00:18:55
que exista o no exista 00:18:57
para hacer como 00:18:58
lo sacamos 00:18:58
entonces primero 00:18:59
he sacado la posición 00:19:00
de ese profe 00:19:01
con el método indexof 00:19:02
que me saca la primera 00:19:06
posición que encuentra 00:19:07
con un profesor 00:19:10
igual a este, y como la igualdad es por 00:19:12
nif, es el nombre, le puedo poner null, me da igual 00:19:14
saco la posición y ahora 00:19:16
este es el profe, es el profe que estoy buscando 00:19:18
y ahora 00:19:20
a este profe 00:19:21
le llamo al método 00:19:24
le llamo al método que me devuelve 00:19:25
la lista de alumnos alfabéticamente ordenados 00:19:27
y ahora ya la estoy 00:19:30
pasando por consola para que la orden 00:19:31
para que la muestre, perdón 00:19:33
vale 00:19:35
vale, claro, eso es lo que quiero hacer 00:19:35
para ver el error que sale, vale 00:19:42
vale, entonces esto, hombre 00:19:44
para ser un poquito más 00:19:47
guays, pues esto será 00:19:49
si lo contiene, verdad 00:19:51
profes 00:19:54
contains 00:19:55
a este 00:19:59
vale, si lo contiene 00:20:02
si contiene a un profe igual a este 00:20:12
entonces sí, hacemos todo esto de aquí 00:20:14
si lo contiene 00:20:16
si no lo contiene, pues decimos 00:20:18
oye, es que no existe ese profe 00:20:20
¿verdad? 00:20:22
no existe profe con ese nif 00:20:31
vale, pues la parte del main sería esta 00:20:33
sacamos el profe con ese nif 00:20:40
si es que está 00:20:43
en la lista, a través del contains 00:20:44
está, lo saco 00:20:46
que no está, digo que no existe profe 00:20:48
ahora, efectivamente, cuando ejecutemos 00:20:50
esto 00:20:52
pues 00:20:53
cuando ejecutemos esto 00:20:55
insertamos profesor 00:21:03
1, 2, 3, 4 00:21:06
nombre del profesor 00:21:07
agregar nuevo alumno 00:21:10
1, 1, 1, 1 00:21:12
alum 1 00:21:13
y se lo agrego a este, ahora 00:21:15
2, vamos a agregarle otro, 2, 2, 2, 2 00:21:20
a alum, para que vaya 00:21:25
después, para que vaya antes, perdón 00:21:28
alum 2, vale 00:21:31
nombre del alumno, a quien a este, agregados 00:21:35
lista alfabético, 6 00:21:40
Ah, nif del profesor 00:21:42
Vale 00:21:46
Quiero el listado alfabético del profesor 00:21:46
Un, dos, tres y cuatro 00:21:49
Vale 00:21:51
¿No existe profe con ese nif? 00:21:51
Porque en profesor no hemos hecho el contains 00:21:55
El equals, ¿verdad? 00:21:58
¿Sí está hecho? 00:22:00
Claro 00:22:01
Entonces, ¿por qué no ha encontrado profe con ese nif? 00:22:02
Porque el contains 00:22:06
Tira del equals 00:22:08
¿Vale? 00:22:10
Entonces, como yo no tengo el equals 00:22:10
No he encontrado un profesor igual a este otro 00:22:13
Porque este tiene una dirección de memoria 00:22:16
Y estos tienen otras 00:22:17
Entonces, para que funcione tanto el context 00:22:19
Como el index of 00:22:22
El profesor tiene que tener su equals 00:22:23
Que no lo tiene 00:22:24
Pues vamos a ponérselo 00:22:26
Venga, un equals por nif 00:22:32
Vale, a ver si ya avanzamos 00:22:34
Hasta donde queremos 00:22:39
Ala, volvemos a ejecutar 00:22:40
Uno 00:22:43
Insertar profesor, 1, 2, 3, 4 00:22:45
Vamos a poner solo un alumno 00:22:47
Si total no lo va a ser capaz de ordenar, nos da igual 00:22:48
Nib del alumno, 1, 1, 1 00:22:50
Nombre del alumno 00:22:53
Alum, 1, 2, 3 y 4 00:22:54
Nib del profesor, 1, 2, 3 y 4 00:23:00
Vale 00:23:03
¿Por qué no ha saltado el error? 00:23:04
A ver que hemos hecho bien 00:23:12
Si la idea 00:23:15
Vamos a ver 00:23:17
GetPost, alumnos alfabéticamente ordenados. 00:23:19
Vale. 00:23:22
Entonces. 00:23:24
Ya, pero el sort tira del comparable. 00:23:33
Entonces, ¿por qué no me ha salido aquí un? 00:23:36
Un. 00:23:39
Comparar, ¿por qué no me ha salido? 00:23:43
Vale, pues repito rápidamente. 00:23:45
Cuando la lista tiene un solo elemento, 00:23:47
aunque no haya criterio de ordenación, 00:23:50
En tiempo de ejecución no va a fallar porque no intenta ordenar nada. 00:23:51
Cuando tiene más de uno, ya sí que intenta comparar uno con otro. 00:23:55
Entonces, ahí es cuando nos sale este error, ¿vale? 00:23:59
De compararle. 00:24:01
Vale. 00:24:03
Método 1 para hacer ese criterio de ordenación. 00:24:04
Método 1. 00:24:08
Pues hacer lo que nos dice. 00:24:10
¿Qué es? 00:24:12
Bueno, pues voy a hacer que mi clase alumno sea comparable con otros alumnos. 00:24:13
Para eso implemento el rol o la interfaz de comparable 00:24:17
Ahora, como ya sabemos tipos genéricos 00:24:29
Podemos hacer esto un poco más bonito y más pulido 00:24:33
Veis que se pone en amarillo 00:24:35
Y si veis el aviso en amarillo 00:24:37
Dice, cuidado que comparable es una clase genérica 00:24:39
Si tú me pones el comparable sin más 00:24:42
te estás permitiendo comparar alumnos 00:24:45
con cualquier otra cosa 00:24:48
comparar un chorizo con una morcilla 00:24:49
pues no queremos eso en una aplicación 00:24:52
¿vale? entonces 00:24:54
para poder asegurarnos de que los 00:24:56
alumnos solo se pueden comparar 00:24:58
con otros alumnos 00:25:00
vamos a concretar el tipo 00:25:01
genérico de comparable así 00:25:04
¿vale? entonces 00:25:06
repito, comparable 00:25:11
es genérica, una clase genérica ya sabéis 00:25:13
que no hay que especificar 00:25:15
exactamente esa incógnita genérica 00:25:17
para la que trabaja, pero si no se especifica 00:25:20
se supone que trabaja con object 00:25:23
luego, si yo no la especifico, yo podría 00:25:25
comparar, permitiría en tiempo de escritura de código 00:25:29
y el compilador no me diría nada, podría comparar 00:25:32
dentro del compare tú, alumnos 00:25:35
con árboles, y el compilador no me daría ningún problema 00:25:38
a lo mejor estoy haciendo eso porque quiero 00:25:42
o a lo mejor estoy haciendo porque me he equivocado, lo normal es porque me he equivocado 00:25:44
porque una aplicación no quiere comparar 00:25:47
alumnos con árboles, quiere comparar 00:25:48
alumnos con alumnos, profesores con profesores 00:25:51
mesas con mesas, pues vamos a 00:25:53
fijar ya desde el tiempo de escritura 00:25:55
de código, desde el tiempo de compilación, vamos a 00:25:57
fijar ya esa restricción 00:25:59
pues para eso fijamos 00:26:01
el tipo genérico de la interfaz 00:26:03
comparable, lo fijamos 00:26:05
¿vale? y decimos, no, no, no 00:26:07
perdona, cada objeto alumno 00:26:09
solo está permitido 00:26:11
ya desde tiempo de código que se compare con 00:26:13
alumnos 00:26:15
¿Vale? Si abrimos esta comparable 00:26:15
Pues 00:26:19
Si se abriera 00:26:20
Alguna vez 00:26:25
Pues 00:26:26
Bueno, tendría que haberle 00:26:28
Comparable 00:26:31
¿Veis? 00:26:36
Vemos que efectivamente es genérica 00:26:38
Depende del tipo T 00:26:40
Yo lo puedo dejar abierto 00:26:42
Con lo cual sería object o la puedo concretar 00:26:44
Pues me interesa concretarla 00:26:46
Para hacer un código 00:26:48
más robusto, ahora ya 00:26:49
el alumno solo 00:26:51
se va a poder comparar con alumnos 00:26:53
bueno, pues como implementa comparable 00:26:55
ya sabemos que hay que implementar el método 00:26:57
de la interfaz 00:26:59
¿y ese método cuál es? 00:27:00
este 00:27:05
el compare tú 00:27:05
¿veis? 00:27:07
y el compare tú, que es el 00:27:10
método que obligatoriamente tengo que 00:27:11
implementar en alumnos 00:27:13
se implementa comparable 00:27:15
que es este, como veis 00:27:17
ya asume que yo solo puedo 00:27:19
pasar aquí un alumno, solo 00:27:21
si yo el comparar lo hubiera dejado abierto 00:27:22
este compare tú 00:27:25
sería con object 00:27:27
con lo cual yo aquí podría hacer lo que me da la gana 00:27:28
porque no es 00:27:31
obligatorio comparar con un alumno 00:27:33
a lo mejor quiero eso en algún momento 00:27:35
pero eso no responde a una lógica natural 00:27:36
¿vale? entonces me interesa 00:27:39
más concretar 00:27:41
bueno pues ahora ya 00:27:42
¿qué orden quiero yo entre alumnos? 00:27:43
el alfabético, el alfabético va por nombre 00:27:46
ya sabemos que el compare tú 00:27:49
lo que sí que le pasa 00:27:51
es que su criterio es 00:27:52
tiene que devolver negativo 00:27:55
normalmente ponemos menos uno 00:27:57
si el que llama el método 00:27:59
va antes que el parámetro 00:28:01
cero 00:28:03
si es la misma posición de orden 00:28:05
y positivo si el que 00:28:07
llama el método quiero que vaya 00:28:09
después del parámetro 00:28:11
si yo estuviera ordenando por edades 00:28:12
pues sería tan fácil como 00:28:15
devolver la edad del primero menos la edad del segundo 00:28:16
si yo estuviera comparando 00:28:19
por edades 00:28:21
es decir, si mi clase alumno 00:28:21
o por notas, los quiero ordenar por notas 00:28:24
los quiero ordenar por notas 00:28:27
pues podría hacer 00:28:29
esto 00:28:31
retun 00:28:31
dis.nota 00:28:33
menor que o.nota 00:28:36
y así 00:28:39
si el 00:28:41
si el primero 00:28:43
tiene menos nota que el segundo 00:28:45
esto me da negativo 00:28:47
luego efectivamente 00:28:49
el primero iría antes, porque esto me da 00:28:51
negativo, si los quiero ordenar por orden ascendente 00:28:53
claro, por orden ascendente de nota 00:28:55
si los dos tienen la misma nota, esto me daría cero 00:28:56
lo cual significaría misma posición 00:28:59
si el primero tiene más 00:29:00
nota, esto sería positivo 00:29:03
que efectivamente significa 00:29:05
que el primero va después 00:29:07
¿vale? este sería 00:29:08
por ejemplo, el orden 00:29:11
Ascendente de nota 00:29:13
¿Vale? 00:29:16
Que mi criterio de ordenación es 00:29:20
Orden descendente de nota 00:29:22
Pues lo contrario 00:29:24
Pues sería lo contrario 00:29:26
Vale, pero yo no quiero ese orden 00:29:32
Quiero el orden por nombre 00:29:44
Vale, los nombres son string 00:29:46
Ordenar alfabéticamente string 00:29:50
No es trivial, no lo hemos hecho 00:29:52
Menos mal 00:29:54
Que la clase string, por ser una clase 00:29:55
Tiene un montón de métodos ya hechos 00:29:58
entre ellos la clase string tiene un método compare tú 00:29:59
que te compara alfabéticamente un string con el que tú le pases 00:30:02
qué suerte que lo tiene 00:30:06
porque ahora yo lo puedo usar aquí 00:30:08
y si yo pongo dis.nombre 00:30:11
este método tiene un compare tú 00:30:16
que si yo le paso otro string 00:30:19
que en este caso sería o.nombre 00:30:22
pues el método compare tú de la clase string 00:30:25
ya se encarga de devolverme 00:30:30
menos 1 si este está alfabéticamente 00:30:33
antes que este 00:30:35
0 si alfabéticamente son idénticos 00:30:37
y más 1 si este está alfabéticamente después de este 00:30:40
o sea, el compareTo de string 00:30:44
ya me devuelve menos 1, 0, más 1 00:30:46
en función del criterio de orden alfabético 00:30:49
luego el orden alfabético ya está programado aquí 00:30:50
en la clase compareTo de string 00:30:53
pues yo tiro del método compareTo 00:30:56
para hacer mi propio compare tú de alumno. 00:30:58
Y ya está. 00:31:02
Le paso hasta el retún. 00:31:03
Y listo. 00:31:05
Luego ya tengo mi compare tú de alumno. 00:31:09
Que se apoya en el compare tú de la clase string. 00:31:15
Y así haría yo el criterio que me diera a mí la gana 00:31:24
programándolo como quisiera. 00:31:26
Pero eso te lo... 00:31:30
Te ha tomado un orden... 00:31:31
Alfabético. 00:31:33
El compare tú de string está pensado para el orden alfabético 00:31:35
según la tabla ASTI 00:31:38
pues 00:31:38
multiplicas por menos uno 00:31:41
ya está 00:31:46
entonces en orden alfabético inverso 00:31:47
multiplicas por menos uno 00:31:51
pues ahora ya sí que no nos va a dar 00:31:52
ese error 00:32:13
para cualquier situación 00:32:13
no, no, no 00:32:16
No, no, no 00:32:21
Porque el criterio 00:32:24
Yo ahí dejo mi null sin problema 00:32:25
Este null, ese es el plan B 00:32:26
Si yo no tengo el comparable 00:32:29
Entonces ya sí que lo tengo que meter ahí 00:32:30
Pero es el plan B 00:32:32
Si yo ya en comparable tengo el criterio 00:32:33
En ese sort puede ir un null 00:32:36
Porque ya no lo necesita 00:32:38
Null porque vacío no me lo admite 00:32:39
El sort necesita siempre algo 00:32:43
Si tú no quieres darle nada 00:32:46
Un null, que un null es un objeto válido 00:32:47
¿Vale? 00:32:49
Entonces, el método estaba aquí, ¿no? 00:32:51
¿Vale? 00:32:56
El método sort no admite ir sin parámetros. 00:32:57
Pero yo el objeto que necesita no lo va a usar porque ya tiene el del comparable. 00:33:00
Pues le paso el objeto null. 00:33:05
Entonces, ahora debería funcionar. 00:33:09
Insertar profe. 00:33:14
Un, dos, tres y cuatro. 00:33:15
Nombre del profesor. 00:33:16
Agregar alumno. 00:33:19
Vamos a agregar primero al alumno Zazo. 00:33:20
Ah, no, el NIF, 1, 1, 1, 1, y se llama Zazo, a 1, 2, 3, 4. 00:33:23
Y ahora le agregamos otro, desordenado alfabéticamente, Aka. 00:33:31
No, el NIF es 2, 2, 2, 2, y se llama Aka. 00:33:38
NIF del profesor, 1, 2, 3 y 4. 00:33:43
Vale, vamos a mostrar los alumnos alfabéticamente ordenados 00:33:46
¿De quién? De 1, de 2, de 3 y de 4 00:33:52
Vale, aquí los tenemos 00:33:56
Ordenados alfabéticamente 00:33:58
Primero el AK, aunque yo le puse después 00:34:01
Yo le puse después, pero al ordenar la lista 00:34:05
Pues ahí se ha quedado 00:34:08
Ahí está ordenadito 00:34:10
Bueno, pues paramos unos minutos 00:34:18
Y luego el plan B, para ordenar 00:34:27
Cuando yo no puedo hacer el comparable 00:34:29
¿Qué puede ocurrir? 00:34:31
Venga, paramos unos minutos 00:34:33
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
1
Fecha:
10 de febrero de 2026 - 13:52
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
34′ 35″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
147.46 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid