Saltar navegación

20260211 Colecciones_TreeSet - 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 15 de febrero de 2026 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, muy breve, muy conciso. 00:00:00
Vale, recordad en qué estábamos. 00:00:04
De list sabemos todo lo que hay que saber, 00:00:09
es cuestión de practicar, ¿vale? 00:00:12
Y de set sabemos casi todo lo que hay que saber, ¿vale? 00:00:14
Set son colecciones de datos para guardar objetos a mogollón 00:00:18
en los cuales no necesito tener duplicados 00:00:25
y en los cuales el orden tampoco me importa especialmente. 00:00:29
van ahí a mogollón, yo luego 00:00:33
itero y van saliendo en orden que sea, ¿vale? 00:00:35
Luego siempre va a ser 00:00:38
más eficiente a priori, un set 00:00:39
que un list, porque 00:00:41
se evita toda esa gestión, ¿vale? 00:00:43
Implementaciones de set, 00:00:46
¡hala! 00:00:47
Implementaciones 00:00:50
de set, 00:00:51
de set, has set, 00:00:52
¿vale? 00:00:58
Vimos ayer cómo funcionaba, 00:00:59
cómo funciona, internamente 00:01:01
aunque eso 00:01:04
podemos obviarlo de cara a su uso 00:01:05
pero bueno, siempre está bien ser los mejores 00:01:08
vale, pues internamente 00:01:12
¿cómo guarda un hashet los datos? 00:01:14
pues se hace una tablita 00:01:18
para guardar códigos 00:01:20
y cada objeto 00:01:24
va asociado 00:01:26
a una de esas entradas de la tabla 00:01:29
cada objeto va asociado a una de esas entradas 00:01:32
¿Cómo se llega del objeto a la entrada que tiene asociada a ese objeto? 00:01:34
Pues a través de una función de hash 00:01:40
Que tiene que estar implementada 00:01:41
Que es esta, ¿vale? 00:01:44
Entonces esa función de hash 00:01:47
Pues bueno, tiene que seguir ciertas reglas 00:01:48
Para que sea más o menos eficiente 00:01:52
Luego a la hora de hacer las operaciones, la CPU 00:01:53
¿Vale? 00:01:58
Pero bueno, esas reglas nos importan ahora poco 00:01:59
Porque es que el propio Eclipse 00:02:01
nos genera ya una implementación relativamente óptima, ¿vale? 00:02:03
Entonces las implementaciones de esta función de hash 00:02:07
lógicamente hay condiciones que tienen que cumplir. 00:02:10
Como que objetos distintos 00:02:12
tienen que darme siempre códigos distintos, ¿vale? 00:02:14
Es decir, una función de hash 00:02:20
que me llevara a la misma entrada dos objetos distintos 00:02:21
sería una función inválida, por supuesto, 00:02:26
sería una función inválida. 00:02:29
las funciones de hash a objetos distintos, entradas de la tabla distintas 00:02:30
¿vale? se supone que tiene que llevar 00:02:36
principios de dispersión, es decir, que los códigos 00:02:38
de hash no se parezcan mucho entre sí, bueno, principios 00:02:44
que nos importan poco, lo que nos importa a nosotros es 00:02:48
que el hash set a cada objeto le aplicará esta función 00:02:51
para asociarlo a una entrada de la tabla 00:02:56
Y ya a partir de esta entrada de la tabla 00:02:58
Puede hacer muchas operaciones más fácilmente 00:03:01
Que directamente con el objeto 00:03:04
Entonces como la tabla no puede ser arbitrariamente grande 00:03:05
Porque la tabla no puede ser arbitrariamente grande 00:03:10
Si empieza a haber muchos objetos 00:03:13
Pues muchos de ellos pueden llevarte 00:03:16
A partir de cierta cantidad a la misma cajita 00:03:23
y ahora ya de cada cajita 00:03:26
tengo una lista 00:03:29
con todos los que van a esa caja 00:03:34
¿vale? así es como funciona internamente 00:03:36
una lista de códigos manejable 00:03:39
¿vale? y si hay colisión 00:03:42
es decir, la función de hash ha empezado a hacer colisiones 00:03:46
ha empezado a hacerlos 00:03:50
porque ya la tabla no puede crecer indefinidamente 00:03:51
ha empezado a hacerlo, ya ha empezado a pasar esto 00:03:54
que dos objetos me llevan 00:03:56
a la misma entrada 00:03:59
pues entonces de esa entrada 00:04:01
colgarán todos 00:04:03
no es que se ha olvidado 00:04:05
que ya está enlazada 00:04:07
tiene diferentes implementaciones 00:04:08
hace árboles balanceados, hace cosas 00:04:11
dependiendo de la implementación de Java 00:04:13
se han ido incorporando nuevas formas 00:04:14
¿vale? y entonces a partir de aquí 00:04:16
¿cómo sabe 00:04:19
cuál de los objetos es? 00:04:20
a través de virtuales. 00:04:23
Bueno, la idea es esa, por dentro. 00:04:27
Entonces, el hash set es la más eficiente que hay. 00:04:30
¿Vale? Es la más eficiente que hay. 00:04:33
Lo único que nos importa a nosotros para usarla 00:04:34
es que cuando hagamos el add, 00:04:37
si ese objeto ya existe, no se va a insertar. 00:04:40
Cuando usamos el contains y el remove, 00:04:44
el hash set necesita el criterio de igualdad 00:04:47
y el criterio de igualdad del hash set 00:04:50
implica tener las dos funciones 00:04:52
implementadas 00:04:55
el hashcode y el IP 00:04:56
luego, que no se nos olvide nunca 00:04:58
cuando usamos un hashed 00:05:00
en las clases 00:05:02
en la clase 00:05:03
a la cual pertenezcan los objetos 00:05:06
de mi hashed, tener los dos 00:05:08
implementados 00:05:10
tener los dos 00:05:11
por el criterio clave primaria que yo necesite 00:05:13
por el nombre, por el nick, por los dos 00:05:16
por lo que sea, tener los dos 00:05:18
si tengo los dos implementados 00:05:20
en la clase a la que pertenecen 00:05:23
automáticamente ya HashSet 00:05:25
funciona por dentro sin problemas 00:05:26
con esta especie de estructura extraña 00:05:28
una tablita de códigos 00:05:30
cuando hay desbordamiento y colisión 00:05:32
pues de cada código los tengo aquí todos 00:05:34
almacenados 00:05:36
vale 00:05:37
entonces el HashSet 00:05:42
no tiene sentido en él plantearse 00:05:44
orden, no hay orden aquí 00:05:46
aquí están todos donde van cayendo 00:05:48
aquí no hay ningún orden 00:05:50
si yo quiero orden, en principio debería usar una lista 00:05:51
repito, la lista 00:05:55
todos caen en una posición, sobre una filita 00:05:57
y yo ahí me puedo plantear 00:05:59
reordenar según un criterio 00:06:01
como vimos con el comparable, el comparator, lo que quiera 00:06:03
en un hased 00:06:05
aquí no tiene sentido orden 00:06:06
lo uso para entidades 00:06:09
en las cuales el orden no importa 00:06:10
para guardar pues un montón 00:06:12
de muebles 00:06:15
de mi casa, vale 00:06:17
pues me hago un hased de mueble 00:06:19
a un hasher de mueble y ahí meto 00:06:20
pues la silla, mesa 00:06:22
lo que sea 00:06:24
¿necesito yo algún orden? 00:06:25
¿mi aplicación le aporta algo que esos muebles 00:06:28
tengan algún orden? pues no le aporta 00:06:31
nada, pues un hasher 00:06:32
la opción siempre ideal 00:06:34
¿vale? 00:06:36
que ahora queremos hacer colecciones 00:06:38
de cosas en las cuales 00:06:40
que haya un orden si me aporta algo 00:06:42
por ejemplo una colección donde yo meto a todos 00:06:44
mis alumnos, anda pues aquí 00:06:46
el orden sí que me puede importar 00:06:48
porque a lo mejor yo quiero un listado 00:06:51
ordenado alfabéticamente 00:06:52
o quiero un listado ordenado por nota 00:06:54
lo que sea, bueno siempre podría coger 00:06:56
una lista y ya está y hacerlo como 00:06:59
lo hemos hecho hasta ahora, una lista 00:07:00
pero hay una estructura 00:07:02
en cuanto a eficiencia 00:07:05
intermedia que tiene todas las ventajas 00:07:07
del set 00:07:09
en cuanto a que es más eficiente 00:07:10
pero que permite 00:07:12
establecer un criterio de orden 00:07:16
y que por tanto 00:07:18
las cosas que se metan ahí 00:07:20
van a tener un orden 00:07:22
y eso puede que me sea a mi útil 00:07:24
para algunas funcionalidades 00:07:26
del tipo sácame un listado, por ejemplo 00:07:28
¿vale? 00:07:30
bueno, pues, esa es el tríceps 00:07:32
¿vale? 00:07:34
que mencionamos rápidamente 00:07:36
que va y ya está, porque el uso es el mismo 00:07:37
en realidad 00:07:40
de implementaciones de set, luego hay otra 00:07:40
que es el 00:07:46
link 00:07:48
haset 00:07:48
que 00:07:51
es un haset 00:07:56
es exactamente un haset 00:07:59
se usa exactamente igual 00:08:01
todo igual, es un haset 00:08:03
la única diferencia es que si yo le pongo el link 00:08:05
en delante 00:08:07
esta implementación 00:08:08
cuando yo itero 00:08:10
los elementos me van saliendo 00:08:12
por el orden en que los inserté 00:08:15
ya está, es lo que aporta 00:08:17
entonces si eso me es útil por algo 00:08:18
en mi aplicación 00:08:21
pues puedo usar un linker hashet 00:08:21
entonces cada vez que itere con un for, con un iterator 00:08:24
con lo que sea, cada vez que itere 00:08:26
los elementos van a salir en el mismo orden 00:08:27
en que lo inserté 00:08:30
¿significa eso que hay 00:08:31
que los elementos tienen orden, que yo puedo hacer 00:08:34
un sort para ordenar? no, no, no 00:08:36
es simplemente que el linker hashet 00:08:38
conserva el orden de inserción 00:08:40
para luego las iteraciones 00:08:43
ya está, es lo único que aporta 00:08:44
que a alguien le importa eso 00:08:47
porque en la aplicación le interesa 00:08:49
que el orden en que yo inserté 00:08:52
se conserve en las iteraciones porque eso me da 00:08:53
información, bueno, pues 00:08:55
entonces un linked haset en lugar del haset 00:08:57
normal, la estructura más 00:08:59
usada en general 00:09:04
es esta porque es la más eficiente 00:09:05
salvo cuando necesitamos duplicados 00:09:07
o reordenar, si necesitamos duplicados 00:09:10
o reordenar nos vamos a ir a listas siempre 00:09:12
¿cuándo es mejor el linked haset? 00:09:14
el LinkedHashSet te aporta 00:09:20
respecto al HashSet 00:09:22
que conserva el orden en que tú 00:09:23
fuiste insertando 00:09:26
con el HashSet ya vimos ayer, tú ibas insertando 00:09:27
nombres, Ana, Juan, y luego iterabas 00:09:30
con el for y te salían de cualquier 00:09:32
manera, pues en el 00:09:34
LinkedHashSet se conserva 00:09:36
el orden en el que los insertaste 00:09:39
con lo cual cuando tú 00:09:40
hagas un for, te van a salir 00:09:42
en el mismo orden en el que los insertaste 00:09:44
eso puede ser 00:09:46
que sea útil a ti, por lo que sea 00:09:48
que quieres hacer en esa aplicación. 00:09:50
Claro, añade un pelinín más de complejidad 00:09:52
interna, lo cual siempre va a ser un pelín 00:09:54
menos eficiente. Entonces, si eso 00:09:56
no te importa, nunca jamás vas a usar un 00:09:58
LinkedHaset, siempre un Haset. 00:10:00
¿Vale? No, no, no. 00:10:02
Sigue sin admitir objetos iguales. Simplemente 00:10:08
si tú haces en un LinkedHaset un 00:10:10
de uno que ya está, no lo va 00:10:12
a meter. ¿Vale? Y no se asume 00:10:16
que hay una posición. Tampoco hay un get por posición. 00:10:18
eso tampoco existe, es simplemente 00:10:20
que en la iteración te van a salir 00:10:22
en el orden en que los insertaste, nada más 00:10:24
¿vale? 00:10:26
bueno, pues el triset 00:10:29
este, y nos callamos 00:10:30
ya, bueno, pues igual que 00:10:32
la lista enlazada era ese 00:10:43
apaño tan bueno, de ponerlos 00:10:44
a todos, dando la mano del siguiente 00:10:47
y todo eso, pues el triset 00:10:49
es lo mismo, pero en árbol 00:10:51
los elementos se van a 00:10:52
guardar en nodos 00:10:55
vale, pues un tríceps 00:10:56
por dentro internamente, aunque no lo vamos a programar 00:11:17
nosotros, es un poquito más 00:11:19
complicado de vista enlazada 00:11:21
por dentro, cada elemento 00:11:22
cada dato 00:11:26
está metido en un nodo, igual que en la lista 00:11:26
enlazada, que cada dato está metido en un nodo 00:11:31
pero en la lista enlazada 00:11:33
el nodo tiene la dirección de su 00:11:35
siguiente, luego en realidad en la link 00:11:37
es más complicado que la del siguiente, la del anterior 00:11:39
para poder recorrerlo de arriba a abajo 00:11:41
vale, pues aquí 00:11:43
en un triset cada nodo tiene 00:11:45
la dirección del que tengo a la derecha y la dirección del que tengo 00:11:47
a la izquierda, porque es un árbol 00:11:49
vale, entonces 00:11:51
este tendrá la dirección del que tiene a su derecha 00:11:53
y el que tiene a su izquierda, a partir 00:11:55
de este podemos llegar al de su derecha 00:11:57
y al de su izquierda 00:11:59
con lo cual 00:12:01
navegar por un árbol 00:12:03
es más rápido y más eficiente 00:12:05
que navegar por una lista 00:12:07
enlazada, porque para 00:12:09
llegar a este último en una lista 00:12:13
enlazada tengo que pasar por todos 00:12:15
en un árbol para llegar 00:12:17
a este, me puedo 00:12:19
saltar un árbol, una sub mitad del árbol 00:12:21
enterita, me voy por aquí directamente 00:12:23
y ya está 00:12:25
entonces es más rápido acceder 00:12:26
a los elementos en una estructura de árbol 00:12:29
que una estructura de lista 00:12:31
lógicamente 00:12:33
pero claro, la pregunta sería 00:12:34
claro, pero ese que tiene que ir 00:12:39
moviéndose, que afortunadamente 00:12:42
no lo tenemos que programar nosotros 00:12:44
el que ha programado el triset por debajo 00:12:45
como sabe por que lado 00:12:48
tiene que irse para localizar el elemento 00:12:50
en el caso de que yo 00:12:52
le haga un contains o le haga 00:12:54
algo de eso, un remove 00:12:56
como sabe para donde tiene que ir 00:12:57
para localizarlo 00:12:59
bueno porque el triset 00:13:02
necesita obligatoriamente 00:13:03
que le demos 00:13:06
un criterio de orden 00:13:07
vale 00:13:09
yo no puedo hacer un triset 00:13:11
si no le digo además 00:13:18
y este va a ser tu criterio 00:13:21
de orden, lo necesito 00:13:23
obligatoriamente para construirse 00:13:25
¿y cómo usa ese criterio de orden? 00:13:27
pues insertamos un primer elemento 00:13:33
pues ya está, aquí se queda 00:13:35
sus dos manitas 00:13:36
apuntean un las dos 00:13:39
ahora insertamos un segundo 00:13:40
pues él mira, ¿es mayor o menor? 00:13:42
porque para eso tiene un criterio de orden 00:13:45
y que sea, ¿está antes o está después? 00:13:46
si está antes, se va aquí 00:13:49
y si está después, se va aquí 00:13:51
vale, ahora insertamos 00:13:53
su siguiente elemento 00:13:56
pues empieza a compararlo por arriba 00:13:57
¿está antes o está después? 00:13:59
está antes, pues entonces va aquí 00:14:02
ahora, ¿está antes o está después? 00:14:03
¿qué es? ¿está después? pues entonces va aquí 00:14:06
¿vale? 00:14:08
no sé si me estoy 00:14:10
explicando, ¿vale? 00:14:11
es decir, insertamos 00:14:18
un primer elemento, inserta el tricel 00:14:20
Nosotros hacemos el add y nos olvidamos 00:14:23
Hacemos el add y se acabó 00:14:24
Toda esa complejidad ya se hace por debajo 00:14:26
Del add 00:14:28
Pero bueno, ¿qué haría más o menos? 00:14:29
Nosotros hacemos nuestro add de un elemento 00:14:31
¿Qué haría? 00:14:34
Si el trisette está vacío 00:14:39
Pues es el primer nodo del árbol 00:14:41
Y ya está 00:14:44
Y aquí tenemos un null 00:14:44
Es el primero que hemos metido 00:14:46
Ahora vamos a llamar a otro add 00:14:50
Para meter otro más 00:14:53
A otro add 00:14:55
pues entonces ese add internamente 00:14:55
no lo hacemos nosotros, lo hace él, claro 00:14:58
ese add internamente 00:15:00
lo compara con este 00:15:02
según este criterio de orden 00:15:04
¿vas antes o vas después? 00:15:05
¿vas antes? pues te coloco 00:15:08
me voy para la derecha, vale 00:15:10
aquí ya no hay nada, pues aquí te pongo 00:15:12
¿vale? 00:15:13
ala, ahí te pongo 00:15:17
al nuevo 00:15:22
vale, ahora metemos 00:15:23
otro más, metemos otro más 00:15:28
Pues empieza a comparar 00:15:30
¿Es mayor? ¿Va antes o va después? 00:15:32
Va después, pues entonces no hay duda 00:15:35
Lo pondría aquí 00:15:36
¡Hala! Ya tenemos esto 00:15:37
Hacemos otro A 00:15:40
¿Qué hace él internamente por dentro? 00:15:43
Que nosotros no lo hacemos, claro, lo hace él 00:15:45
¡Ah! ¿Va antes? Pues va a este lado 00:15:47
¡Ah! Pero aquí ya tengo otro 00:15:49
Pues voy a compararlo con este 00:15:50
¿Va antes o va después que este? Va después 00:15:52
¡Ah! Pues entonces va colgando de aquí 00:15:54
Y así va añadiendo las hojas al árbol 00:15:55
¿Vale? 00:15:59
va añadiendo las hojas al árbol 00:16:00
y esto se construye como un árbol ordenado 00:16:02
¿vale? 00:16:05
que nosotros no lo vemos 00:16:07
ni lo vamos a ver jamás nunca desde fuera 00:16:08
nos limitamos a hacer AR 00:16:10
y él ya lo va insertando 00:16:12
¿cuál es la ventaja de que él internamente 00:16:13
vaya construyendo un árbol ordenado? 00:16:16
la ventaja es que luego 00:16:19
cuando ya hacemos el remove, el contains 00:16:20
cuando hacemos esas cosas 00:16:22
cuando hagamos remove 00:16:23
para eliminar un elemento 00:16:25
cuando hagamos contains 00:16:27
Para ver si hay un elemento 00:16:29
Pues la búsqueda va a ser mucho más rápida 00:16:31
Porque se quita porciones de árbol de mitad 00:16:34
Se las quita de golpe 00:16:36
Oye, voy a eliminar este 00:16:37
Voy a localizarlo a ver si está 00:16:40
Antes que nada 00:16:41
¿Este es mayor que este primero? 00:16:42
Pues tiene que estar en esta parte del árbol 00:16:44
Pues entonces esta parte entera 00:16:46
Ya ni la miro 00:16:47
Se ha quitado una mitad de elemento 00:16:48
Oye, este que me han dicho es este 00:16:50
¿Está antes o es después? 00:16:52
No, está después 00:16:54
Pues tendrá que estar en esta zona del árbol 00:16:55
Pues sigue bajando 00:16:57
Ah, mira, ya es este 00:16:58
ya lo he encontrado, pero se va quitando 00:16:59
partes del árbol de golpe 00:17:00
dime 00:17:03
claro 00:17:04
cualquier cosa 00:17:08
claro, cualquier cosa 00:17:11
lo que te dé la gana basada en los parámetros 00:17:13
en las propiedades del objeto 00:17:16
claro, cualquier cosa basada en las propiedades del objeto 00:17:17
como si puede ser el criterio 00:17:20
de orden entre dos alumnos cuya propiedad 00:17:21
es la altura 00:17:24
pues que la altura de uno 00:17:25
sea mayor que el múltiplo de 5 00:17:28
de la altura del otro, lo que a ti te dé la gana 00:17:31
cualquier cosa basada 00:17:32
en las propiedades del objeto 00:17:34
lo que tú quieras, en principio será cosas con sentido 00:17:36
según la aplicación 00:17:38
vale, pues entonces 00:17:40
lo único que 00:17:43
nosotros ya sí que usamos 00:17:45
ahora de implementar esto 00:17:47
es que cada vez que 00:17:49
instanciemos un triset 00:17:50
cada vez que lo instanciemos 00:17:52
tenemos que decidir un criterio 00:17:54
de orden para los objetos 00:17:56
que lo componen 00:17:58
¿vale? tenemos que decir un criterio de orden 00:18:00
luego 00:18:02
si el trícer 00:18:04
yo hago aquí 00:18:06
mi trícer 00:18:09
de alumno 00:18:09
¿vale? pues muy bien 00:18:11
puedo hacer mi trícer de alumno, no tengo ningún problema 00:18:14
pero alumno tiene que tener 00:18:16
un criterio de orden 00:18:18
¿cómo hacemos para que alumno 00:18:20
tenga un criterio de orden? 00:18:22
haciendo que alumno implemente 00:18:28
comparable, ¿verdad? 00:18:30
¿Sí o no? 00:18:33
Sí. Que yo no puedo hacer 00:18:35
que alumno implemente comparable 00:18:37
o alumno ya implementa comparable 00:18:38
pero ese criterio de orden no me 00:18:41
gusta. 00:18:43
Pues podemos instanciar 00:18:44
triset y al momento de 00:18:46
instanciarlo decirle, oye, tú 00:18:49
este es tu criterio de orden. ¿Y cómo le damos 00:18:50
un criterio de orden particular 00:18:52
a alguien? Mediante un objeto 00:18:54
comparatorio. 00:18:57
vale, es decir, esto de aquí 00:19:00
lo vemos 00:19:05
rápidamente y listo 00:19:09
vale, pues a ver 00:19:11
en ejemplo set 00:19:58
pues me voy a hacer un 00:20:01
paquetillo 00:20:03
que sea triset 00:20:05
pues venga, clase alumno, ya que hayamos dicho alumno 00:20:06
el nif 00:20:17
el nombre 00:20:38
y la nota, por ejemplo 00:20:39
pues hacemos 00:20:54
el constructor 00:20:55
Y los get y los set 00:20:57
Ahora tenemos ahí un alumno normal y corriente 00:21:05
Con las tres propiedades de siempre 00:21:16
Vale, pues queremos hacer cosas ahora 00:21:17
Con los alumnos del aula 00:21:29
Pues nos hacemos aquí la clase main 00:21:31
Venga, vamos a poner los alumnos aquí fuera 00:21:39
Para variar un poco de estructura 00:21:49
Vale, pues venga 00:22:00
Vamos a suponer que decidimos como implementación 00:22:17
un triset para estos alumnos de aquí 00:22:21
vale, pues esta es la colección de alumnos mía de trabajo 00:22:24
la he puesto en una variable estática fuera del main 00:22:34
por si hago métodos, no tener que pasársela todo el rato 00:22:36
y ya está, pues venga, vamos a suponer 00:22:39
aquí haríamos un menú de opciones 00:22:46
vamos a suponer que aquí vamos a hacer el método 00:22:47
insertar alumno, donde le pasamos 00:22:51
un alumno a, vale, aquí que haríamos 00:23:02
pues alumnos.ad, aquí no cambia respecto a 00:23:07
Todas las colecciones son iguales 00:23:10
Si yo quiero añadir algo, ala, lo añado 00:23:12
Y ya el método add por dentro 00:23:15
Y ahora lo que tenga que hacer 00:23:18
Para expandir el espacio 00:23:19
Y meterla donde sea, en el array, en el árbol 00:23:22
En la lista, donde sea 00:23:24
Vale, pues vamos a probarlo 00:23:25
Desde el main 00:23:30
Vamos desde el main a insertar un alumno 00:23:32
Se me ha olvidado el static 00:23:35
De aquí 00:23:54
Y vamos a recorrer el set 00:23:55
Vale 00:24:07
A través de, vamos a hacer aquí el método 00:24:09
Que sería 00:24:12
Listar alumnos 00:24:13
¿Vale? Listado 00:24:15
A alumnos, bueno pues listado 00:24:20
A alumnos, pues vamos a 00:24:26
Concatenar el resultado aquí 00:24:28
Y ahora para cada alumno 00:24:30
A en 00:24:42
Alumnos 00:24:43
Listado 00:24:45
Más igual 00:24:48
Vale, aquí ya hay algo que seguramente 00:24:49
Alguna cosita que 00:25:05
Estáis a punto de decirme 00:25:08
Que lo sé 00:25:10
Qué listado tan feo te va a salir 00:25:10
Falta un separador 00:25:12
No pasa nada 00:25:21
Yo le pongo un separador 00:25:22
Vale 00:25:23
¿Qué más cosas me decís? 00:25:25
¿Eh? 00:25:36
Un listado, perdona 00:25:40
Bueno, es que si esto ha sido un error 00:25:41
No a propósito 00:25:43
No a propósito 00:25:45
¿qué más cosas? nos saldría un listado muy feo 00:25:46
¿no? 00:25:49
¿por qué? claro, me saldría 00:25:50
el toString de alumno al concatenar 00:25:56
me saldría el toString, el toString es muy feo 00:25:58
porque no lo hemos hecho, claro, pues vamos a hacer 00:26:00
el toString 00:26:01
con nipNombre y nota, ya está 00:26:02
vale, pues ya tengo 00:26:08
mi método de listado alumnos 00:26:11
con el static si quiero llamarlo 00:26:13
desde el main 00:26:15
y ahora me voy a mi main 00:26:16
para 00:26:21
mostrar ese listado 00:26:22
Vale, pues hemos insertado un alumno con el add, vamos a mostrar el listado y lógicamente pues nos dice, no puedo hacer un triset porque alumno no es comparable, ¿vale? 00:26:25
claro, es que nosotros ya sabemos 00:26:56
que el triset necesita 00:27:02
cada vez que meta un alumno, compararlo 00:27:04
con los otros, entonces 00:27:06
e incluso aunque no haya 00:27:08
ninguno antes, vale 00:27:10
fijaos que aquí no había ninguno, es el primero 00:27:12
pero lo primero que hace 00:27:14
la máquina virtual es ver 00:27:15
que hay un criterio de orden ahí puesto 00:27:18
bueno, pues aquí uno si tiene 00:27:19
acceso a la clase alumno diría, vale 00:27:22
pues venga 00:27:23
¿cuál es el 00:27:25
criterio mío 00:27:28
con el que a mí me interesa el orden 00:27:30
y esto no es tan trivial, tan fácil 00:27:31
porque claro, si yo le doy aquí 00:27:34
a implements, comparable 00:27:39
recordad que es 00:27:41
la clase genérica 00:27:43
entonces, comparable de alumno 00:27:44
perdón, alumno 00:27:47
vale, entonces yo quiero 00:27:49
que alumno sea un objeto 00:27:51
comparable con otros alumnos 00:27:53
con otros alumnos, no con otros 00:27:55
objetos cualquiera, con otros alumnos 00:27:57
por eso 00:27:59
concreto 00:28:00
la interfaz genérica comparable alumno 00:28:01
para que alumno sea comparable con otros 00:28:04
no con objetos cualesquiera 00:28:05
bueno, pues si yo lo implemento 00:28:07
entonces tengo que darle cuerpo a este método 00:28:09
y ahora 00:28:12
aquí se nos plantea una situación 00:28:15
difícil 00:28:17
porque uno podría pensar así alegremente 00:28:18
oye, este criterio de orden 00:28:21
yo lo voy a usar para listados, para cosas 00:28:23
¿cuál es el orden que a mí me gusta entre alumnos? 00:28:25
uno podría decir pues el orden alfabético de nombre 00:28:28
entonces uno casca aquí el orden alfabético de nombre 00:28:32
y recordad que para el orden alfabético de nombre 00:28:37
pues podíamos usar tranquilamente esto 00:28:43
dis.nombre es un string 00:28:45
lo comparo con el método compareToDeString a o.nombre 00:28:49
y ya lo tengo porque el método compareToDeString 00:28:54
ya hace la comparación alfabética 00:28:58
entre los dos strings que yo le pase 00:29:00
me va a devolver menos uno 00:29:02
si este está alfabéticamente 00:29:04
antes que este, cero 00:29:06
si este está alfabéticamente 00:29:08
a la vez que este 00:29:10
y, o sea es el mismo 00:29:12
y más uno si este 00:29:14
está alfabéticamente después, luego el otro alfabético 00:29:16
sería este 00:29:18
es que estoy 00:29:19
en la propia clase alumno 00:29:26
¿vale? estoy en la 00:29:28
propia clase alumno, entonces 00:29:30
desde alumno a cualquier 00:29:32
propiedad, sea del dis o de otro 00:29:34
vale, pues 00:29:36
entonces digo, ya está, ya el triset 00:29:41
se va a quedar tranquilo, vamos a ver si 00:29:43
nos deja 00:29:45
volvemos a hacer el main 00:29:45
y aquí está mi alumno 00:29:48
bueno, pues 00:29:51
menos uno, cero y uno 00:30:02
que es el criterio 00:30:04
que se asume para este compare tú 00:30:06
es decir, este método yo lo tengo 00:30:08
que hacer siempre de tal manera que me devuelva 00:30:10
negativo si el 00:30:12
que llama al método va antes que el parámetro 00:30:14
cero si el que llama 00:30:16
al método es el mismo 00:30:17
o sea, está en la misma posición de orden 00:30:19
y positivo 00:30:21
si el que llama al método va después según 00:30:23
ese criterio 00:30:26
es lo que me tiene que volver este método para que 00:30:26
todos los que lo usan lo entiendan 00:30:29
para que lo entiendan 00:30:32
entonces como el compare to the string 00:30:33
funciona exactamente así 00:30:36
para el orden alfabético 00:30:37
de estos, pues lo utilizo 00:30:39
porque yo quiero el orden alfabético entre el que 00:30:41
llama este y este 00:30:45
por nombre, bueno pues ya tenemos 00:30:47
un criterio de orden alfabético en nuestro 00:30:51
comparable, pues yo 00:30:53
ahora ya el main se ha quedado 00:30:56
tan tranquilo 00:30:58
me ha metido al alumno y ya está 00:30:58
vale, pues yo sigo metiendo 00:31:01
alumnos, voy a meter 00:31:03
ahora un segundo alumno 00:31:07
new alumno 00:31:08
mi alumno 00:31:10
5, 6, 7, 8 00:31:13
que también se llama Pepe 00:31:15
porque hay muchos Pepes en el mundo 00:31:19
pero este tiene un 8 00:31:22
y tiene otro NIF distinto 00:31:24
no pasa nada, ¿no? 00:31:27
hay muchos que nos llamamos igual 00:31:28
hay 200.000 personas en España que se llaman Raquel Gómez Sánchez 00:31:29
pues más habrá que se llamen Pepe 00:31:32
vale 00:31:34
bueno, ya he insertado a este otro 00:31:35
ahora, vamos a mostrar 00:31:38
el listado ahora 00:31:41
Nuevo listado 00:31:41
Después de la inserción 00:31:50
Vale 00:31:52
Entonces efectivamente 00:32:02
Como ya os ha dado tiempo a comprobar 00:32:04
No lo ha añadido 00:32:05
¿Vale? 00:32:08
¿Por qué? 00:32:11
Porque para el triset 00:32:12
Para el triset 00:32:13
El criterio de orden que tú le des 00:32:15
Es el criterio de igualdad 00:32:18
Aquí ya el equals no aplica 00:32:20
Para el triset el equals no aplica 00:32:22
para el triset, el criterio de igualdad 00:32:24
para hacer el add, el remove, el 00:32:27
contains, es este 00:32:28
este es el criterio de igualdad 00:32:30
para el triset, vale 00:32:32
entonces 00:32:34
yo lo que tengo que poner aquí no es 00:32:36
el orden que a mí me interesa para los 00:32:38
listados, para lo que sea, si tengo que hacer listados 00:32:40
por orden, pues ya lo llevo a una lista, ordeno 00:32:43
lo que haga falta 00:32:45
pero el criterio para el triset 00:32:45
para que el triset meta en el árbol 00:32:48
tiene que ser el de la clave primaria 00:32:50
porque si no el add no me va a añadir 00:32:52
a los distintos 00:32:55
por clave primaria 00:32:57
entonces 00:32:59
este se convierte automáticamente 00:33:01
el criterio de igualdad para 00:33:03
triset, a mi me da igual que yo haga aquí un equals 00:33:17
por nif, imaginaos que 00:33:19
hacemos aquí un equals por nif 00:33:21
que es el equals que a mi me interesaría para alumno 00:33:23
vale, me voy a borrar el hashcode 00:33:27
porque no lo estamos usando 00:33:29
yo me hago mi equals por nif 00:33:30
que es el que especifica 00:33:32
realmente la lógica 00:33:35
de mi aplicación 00:33:37
que dos objetos de mismo 00:33:39
nif sean iguales, yo me hago mi equals y ya está 00:33:40
y aquí me hago mi compare 00:33:43
to con nombre 00:33:44
como hemos hecho hasta ahora porque me interesa el orden 00:33:46
alfabético 00:33:48
pues entonces aquí 00:33:49
yo ejecuto esto 00:33:51
y efectivamente 00:33:56
hemos comprobado que esto no está 00:33:58
funcionando, tiene que funcionar 00:34:00
entonces si yo estoy usando 00:34:03
un triset de 00:34:05
alumno, el 00:34:07
compare to tiene que ser el de la 00:34:09
igualdad. 00:34:11
El de la igualdad. Entonces, tendría 00:34:13
que comparar por nif. 00:34:15
Ahora ya sí esto nos va a funcionar. 00:34:29
Lo que pasa es que nos deja... 00:34:31
¿Veis? Ahora ya sí lo ha metido. 00:34:32
Ahora ya sí. Porque el 00:34:35
triset mira solo el compare to. 00:34:37
¿Vale? Lo único es que nos da... 00:34:42
Puede ser que esto nos cuadre, 00:34:44
que no nos cuadre, porque imaginaos, por ejemplo, 00:34:46
esta situación. 00:34:48
Yo tengo también una lista de alumnos 00:34:49
Imaginaos que me estoy haciendo 00:34:51
Con estos alumnos que estoy 00:34:53
Me voy a hacer una lista de alumnos 00:34:54
Que quiero ordenar, por ejemplo 00:34:57
Porque el trisete es un set 00:34:59
No lo puedo ordenar 00:35:02
Entonces vamos a hacernos una lista de alumnos 00:35:03
Una lista de alumnos 00:35:05
¿Vale? 00:35:10
Y esta lista de alumnos 00:35:24
Vamos a meterles todos mis alumnos 00:35:25
Pues para eso tengo yo aquí 00:35:28
Mi add all 00:35:29
¿Veis? Tengo mi add all, le meto este 00:35:30
Vale, pues imaginaos que hago esto 00:35:33
Ya está, me echo una lista 00:35:37
Con todos los alumnos 00:35:39
De mi set, una doll con todos 00:35:41
Ya está 00:35:43
Vale, ahora al estar en lista 00:35:44
Esos alumnos, yo ahora puedo hacer cosas 00:35:47
De las que puedo hacer con listas 00:35:49
Que no puedo hacer con sets 00:35:50
Como por ejemplo, ordenar 00:35:52
Porque como todos tienen su posición, ordenar 00:35:54
Entonces 00:35:56
Si yo ahora 00:35:58
ordenar a esta lista para mostrarla 00:36:01
vale, me hago 00:36:04
alumnos 00:36:06
a ver, un momento es que 00:36:07
la he sellado igual, con lo cual 00:36:09
se llama 00:36:11
alumnos 00:36:14
lista, lista alumnos 00:36:15
la voy a llamar porque si no estoy 00:36:17
lista alumnos 00:36:19
la estoy liando, estoy usando 00:36:23
estoy enmascarándola de arriba 00:36:27
así, perdón 00:36:28
vale 00:36:31
ya tengo 00:36:31
mi lista de alumnos 00:36:33
mi lista de alumnos 00:36:35
a la que le he metido todos los objetos 00:36:37
de mi set, alumnos 00:36:40
vale 00:36:41
tengo ahora los alumnos en un set 00:36:42
en el set original y los alumnos en una lista 00:36:45
entonces 00:36:47
lógicamente ahora yo podría hacer 00:36:48
cosas que puedo hacer con las listas 00:36:51
como ordenar, verdad 00:36:53
yo puedo hacer 00:36:54
lista alumnos punto sort 00:36:57
no hace falta 00:36:59
que le pase un comparador, porque alumno ya implementa 00:37:01
comparable, ¿vale? Y 00:37:05
lista alumnos.sort nos devuelve la lista ordenada, ¿no? 00:37:12
Con lo cual lo puedo pasar directamente a un... No, no me la devuelve. 00:37:16
Vale, pues entonces vamos a mostrar el listado ordenado. 00:37:22
Listado ordenado. 00:37:34
Ahí tengo mi listado ordenado 00:37:38
y ahora voy a 00:37:40
para cada alumno a 00:37:42
en lista 00:37:44
alumnos 00:37:46
bueno, podría pasársela al siso 00:37:48
pero bueno 00:37:51
a más 00:37:51
venga, pues ordeno esta lista 00:38:02
que este sort ya sí que lo puedo hacer 00:38:11
porque esto es una lista 00:38:13
y voy a mostrar como se me ha quedado el orden 00:38:14
pues nada, aquí está 00:38:17
vale, mi listado ordenado 00:38:28
a ordenado 00:38:30
por orden de nif 00:38:32
que puede ser el que a mí no me importe 00:38:34
voy a meterlo 00:38:36
en lugar del mismo, todo el rato 00:38:37
en lugar de 00:38:40
aquí voy a meterle 00:38:41
este, vale, pues ya está 00:38:44
me da mi listado ordenado, pero claro, esta situación 00:38:52
normalmente los listados 00:38:54
de cosas ordenadas 00:38:56
no son por clave primaria 00:38:58
no son por clave primaria, la clave primaria 00:39:00
es para distinguir un objeto de otro 00:39:02
para asegurarse de que no pueden tener 00:39:04
la misma de los objetos 00:39:06
como aquí el ni 00:39:08
las claves primarias 00:39:10
no suelen ser lo que nos da los criterios de orden 00:39:11
en una aplicación real 00:39:14
cuando tú quieres ver listados, quieres 00:39:16
recorrer cosas, la clave primaria 00:39:18
no suele ser el criterio de orden real 00:39:20
el que está conectado con la realidad 00:39:22
y aquí el listado 00:39:23
me lo ha ordenado, pero me lo ha ordenado 00:39:26
por ni 00:39:28
no por orden alfabético 00:39:29
ni por nota, ni por nada 00:39:32
¿Y qué podemos hacer? 00:39:33
Este comparable no se puede cambiar 00:39:38
Este comparable con este compare de aquí 00:39:41
No lo podemos cambiar 00:39:45
No se puede tocar para cambiar el criterio de orden 00:39:47
No se puede 00:39:49
Porque aquí hay un triset de alumno 00:39:51
Y necesita que el compare to sea por clave primaria para detectar la igualdad 00:39:54
vale, pero estas situaciones 00:40:01
se pueden arreglar con el comparator 00:40:04
vale 00:40:06
yo aquí en lugar de pasarle un null para que tire 00:40:08
del comparable 00:40:10
pues le paso un comparator 00:40:11
y ya está, un comparator por alfabético 00:40:14
o por lo que sea 00:40:17
eso es una opción 00:40:18
otra opción 00:40:19
pues oye tú, que es que el comparable de alumno 00:40:21
un segundo y ya paramos 00:40:25
es que el comparable de alumno 00:40:28
A mí me da la gana que sea por nombre 00:40:33
Porque comparable es mi criterio de orden 00:40:35
Que lo van a usar un montón de listas 00:40:38
De cosas, es que a mí no me gusta 00:40:39
No me da la gana que en alumno 00:40:41
El comparable sea este tan raro 00:40:43
Por NIF, para que lo use 00:40:45
Un triset de así eso 00:40:47
Eso sería más natural 00:40:49
No quiero eso 00:40:51
Pues entonces una opción sería 00:40:52
Este compare tú 00:40:55
Ponerlo realmente 00:40:57
Con un sentido más real 00:40:59
hacer el compare tú por nombre 00:41:01
hacer un compare tú por nombre 00:41:03
que 00:41:16
¿dónde me lo ha puesto? aquí 00:41:17
que sería pues esto que hemos 00:41:19
hecho antes, dis.nombre 00:41:25
.compare tú 00:41:27
o .nombre 00:41:30
este es el compare tú 00:41:32
real, el que tiene más sentido 00:41:35
en nuestra aplicación que va a ordenar por un alfabético 00:41:37
vale 00:41:40
Pero claro, si lo hacemos así para que este criterio de orden trascienda, que es este, el que se nos estropea, como ya sabemos, es este. 00:41:41
Este se nos ha estropeado. 00:41:50
Se nos ha estropeado porque ahora no va a distinguir alumnos iguales. 00:41:52
No los va a distinguir, se nos ha estropeado. 00:41:56
Pero ¿qué es lo que podemos hacer? 00:41:58
¿Qué es lo más natural? 00:42:00
Oye tú, Triset, te vas a construir, porque yo te lo mando que te construyes. 00:42:01
Pero ojo, el criterio de orden que vas a usar tú 00:42:06
No es el comparable 00:42:09
Porque este tiene un significado real 00:42:12
Es el orden de alumnos 00:42:14
Ojo, no es ese, no uses ese 00:42:15
Ese es para definir la aplicación 00:42:18
Usa este otro que yo te voy a dar aquí 00:42:20
¿Vale? 00:42:23
Pues el constructor de triset admite 00:42:25
Que le demos un objeto comparado 00:42:27
Y lo usa para su almacenamiento interno 00:42:29
Comparador 00:42:36
Nif, por ejemplo 00:42:39
Entonces, oye tú, usa este 00:42:40
Usa este 00:42:45
Para tus operaciones, para tus cosas 00:42:46
Usa este, no uses el otro 00:42:49
Usa este 00:42:51
Lo que pasa es que lo tenemos que hacer, claro 00:42:54
Pero bueno, ya sabemos hacerlo 00:42:56
Nos hacemos nuestra clase 00:42:58
Comparador Nif 00:43:06
Para que sea un comparator 00:43:08
Tiene que implementar 00:43:09
Comparator 00:43:10
comparator 00:43:13
de alumno 00:43:14
para que sea un comparador de alumnos 00:43:16
y ahora ya 00:43:19
implementamos este método 00:43:23
que este será 00:43:25
o uno punto 00:43:28
nombre 00:43:29
ahora ya si que el get 00:43:30
porque estamos fuera de la clase 00:43:33
punto compare tu 00:43:34
o dos punto 00:43:37
get nombre 00:43:39
vale pues me he hecho un criterio de comparación que va a ir por libre 00:43:40
para quien lo quiera usar 00:43:48
un criterio de comparación entre 00:43:50
alumnos, entre alumnos basado 00:43:52
en NIF, perdón 00:43:54
en NIF 00:43:55
porque he puesto aquí nombre 00:43:57
basado en NIF 00:43:59
vale, me he hecho un criterio de comparación 00:44:01
ahí suelto por libre 00:44:04
para quien sea que lo quiera 00:44:05
usar, que no está asociado a alumno 00:44:08
alumno tiene el suyo propio 00:44:10
comparable por nombre, que es el que me gusta y quiero 00:44:11
que esté, porque es mi sentido real 00:44:14
mi sentido real 00:44:16
es comparar por nombre 00:44:18
ese es mi sentido real, quiero que se compare 00:44:20
por nombre, mi criterio de orden 00:44:22
vale, pero me hago este comparador 00:44:23
aquí por libre, por si alguien lo 00:44:26
necesita 00:44:28
¿quién lo va a necesitar aquí? 00:44:28
el triset 00:44:32
cuando yo instancie mi triset, hay que 00:44:33
decirle, oye tú, olvida el 00:44:36
comparable de alumno, que ese es para listados 00:44:38
es para otras cosas, olvídalo 00:44:40
y quédate con este criterio 00:44:41
para tu igualdad 00:44:43
quédate con este 00:44:44
Entonces usa este, ignora el de la clase y ahora ya esto nos funcionaría todo. El tríceps podría incorporar alumnos con el mismo nombre y diferente NIF, ningún problema, podría incorporarlos perfectamente, ¿vale? Por ejemplo vamos a insertar aquí más alumnos para ver el listado, ¿vale? 00:44:47
Por ejemplo, ya aquí he metido a tres, los va a meter a los tres, porque son NIF distintos, los va a meter a los tres, porque son NIF distintos, aunque dos compartan el nombre, pero son NIF distintos, los va a meter a los tres, ¿vale? 00:45:23
Luego, cuando yo los meto en una lista y los ordeno, el criterio de ordenación va a ser el de alfabético, porque es el que tiene alumno. 00:45:36
entonces bueno, ahora todo 00:45:45
funcionará 00:45:47
bien, suponemos 00:45:49
ha metido a los tres 00:45:50
incluso con mismo nombre 00:45:52
para él son distintos 00:45:55
pero ahora ya sí 00:45:56
el orden de la ordenación de la lista 00:45:58
es el del comparable, que es el alfabético 00:46:01
que es el que a mí me gusta 00:46:03
no el de NIF 00:46:04
no el de NIF, pues estas son las ideas 00:46:05
vale, pues estas son 00:46:14
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:
15 de febrero de 2026 - 18:06
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
46′ 29″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
1.08

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid