Saltar navegación

Activa JavaScript para disfrutar de los vídeos de la Mediateca.

Clase 19-03-24 - 2 - 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 3 de abril de 2024 por Raquel G.

7 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, pues recordáis que estábamos en colecciones. Las colecciones son clases que me permiten tener un montón de objetos de un tipo alojados dentro de una única referencia. 00:00:00
Yo tengo una lista de alumnos, pues a partir de esa lista de alumnos tengo un montón. Tengo un set de jugadores, pues a partir de ese objeto set, de ese único objeto set, tengo dentro un montón de cosas sobre las que iterar, etc. 00:00:15
Esas eran las colecciones. Había dos tipos, listas y conjuntos, de las que entendemos las diferencias. En las listas cuenta el orden, en los conjuntos no hay orden que valga. Esa es la diferencia fundamental. 00:00:30
y luego ya dentro de las listas y los conjuntos 00:00:45
hay varias versiones 00:00:49
listas pues ArrayList, LinkedList 00:00:51
más o menos de ellas ya contamos mucho 00:00:52
y luego en conjuntos las basadas 00:00:54
en tabla hash como el hashSet 00:00:57
y el LinkedHashSet 00:00:59
y las basadas en árbol 00:01:00
que no tienen nada que ver con la tabla hash 00:01:02
las basadas en hash 00:01:04
ya vimos lo que era la tabla hash 00:01:07
por dentro como estaba 00:01:08
como funcionaba el hashSet 00:01:11
que primero hacía el código hash para irse a la posición 00:01:14
de la tabla hash y luego a partir de ahí navegaba 00:01:17
por la lista con el equals hasta encontrar el objeto 00:01:20
bueno, todo eso ya lo contamos 00:01:23
bueno, pues la versión que nos queda de los conjuntos 00:01:26
es el triset que está pensada 00:01:30
para optimizar las búsquedas 00:01:33
ya el hash set optimiza mucho porque a través 00:01:36
del código hash ya pum, ya te sitúa 00:01:38
ya se elimina muchos y ya te sitúa 00:01:42
solamente en una porción de ellos 00:01:43
ya con la tabla H se hacen las búsquedas eficientes 00:01:45
pero con el trisel se hacen todavía más 00:01:48
bueno, pues 00:01:50
esos que piensan y dicen 00:01:51
a ver, ¿cómo programamos estructuras 00:01:53
por dentro 00:01:56
útiles? pues el que pensó 00:01:57
la lista enlazada, que es así que la programamos 00:02:00
aquí, todo eso 00:02:02
pues ¿qué otra cosa se le ocurrió? 00:02:03
pues se le ocurrió 00:02:06
organizar los objetos 00:02:07
en un árbol 00:02:10
Organizar los objetos en un árbol 00:02:10
Entonces 00:02:13
Mis objetos 00:02:14
Qué pein más raro 00:02:19
¿Qué es esto? 00:02:24
¿Dónde tengo aquí el cuadrado de toda la vida? 00:02:28
¿Eh? ¿Qué? 00:02:31
Ya, ya, ya, pero yo quiero el cuadradito 00:02:36
Ah, formas, joder, parezco tonta 00:02:38
Vale, pues entonces 00:02:40
Ya está 00:02:42
Vale, pues este es un objeto 00:02:44
Este es otro objeto 00:02:48
Este es otro objeto 00:02:50
Este es otro, este es otro 00:02:51
Este es otro 00:02:54
Estos son mi mogollón de objetos 00:02:55
Que yo quiero gestionar 00:02:58
Fácilmente 00:03:00
Entonces ya sabéis que la opción 00:03:01
Básica es 00:03:04
Ah, la tosa una raíz, venga, tosa una raíz 00:03:06
Papapapa, tosa una raíz 00:03:08
Pero ya sabemos por qué los a raíz 00:03:09
Nos son a veces costosos 00:03:12
Y por eso se hacen las colecciones 00:03:13
Bueno, pues que otra opción tenemos 00:03:15
Pues que 00:03:17
A cada nodo de estos 00:03:19
a cada objeto de estos, además de su dato en sí, le acompañe la dirección del nodo de la izquierda y la dirección del nodo de la derecha. 00:03:21
luego este objeto tiene el dato en sí 00:03:52
el alumno, el jugador, lo que sea 00:03:55
y luego además tiene la dirección del objeto de la izquierda 00:03:57
y la dirección del objeto de la derecha 00:04:00
es igual que una lista enlazada 00:04:01
que al dato en sí le acompañaba la dirección del siguiente 00:04:03
pues aquí al dato en sí le acompañan dos direcciones ahora 00:04:06
le acompaña la dirección del de la derecha y la dirección de la izquierda 00:04:10
ahora este objeto tendrá el nodo en sí 00:04:13
o sea el dato en sí, el jugador, el alumno, lo que sea 00:04:17
y además le acompaña la dirección del objeto de la izquierda 00:04:19
y la dirección del objeto de la derecha. 00:04:25
Y así se construye un árbol binario 00:04:28
que optimiza la iteración, optimiza la consulta. 00:04:30
¿Por qué? ¿Qué se hace? Se le ordena. 00:04:39
Esto podría hacerse aleatoriamente. 00:04:42
Estar ahí, pues no, se le ordena. 00:04:44
Todos los elementos mayores que este 00:04:46
van a su izquierda 00:04:49
todos los mayores que este van a su izquierda 00:04:51
todos los menores van a su derecha 00:04:53
todos los menores van a su derecha 00:04:55
entonces cuando hay que hacer una consulta 00:04:56
pues se van comparando con el mayor que, menor que 00:04:58
se van comparando 00:05:00
es mayor que, ah pues está aquí 00:05:01
y todos estos ya no tengo que recoger 00:05:03
en una lista tienes que pasar por todos 00:05:05
en una lista para llegar a uno 00:05:08
es obligatorio pasar por todos 00:05:10
no hay tutía 00:05:12
cuando tienes una lista enlazada quieres llegar a este 00:05:13
tienes que empezar en el primero 00:05:15
eso es lo que hace el linked list por dentro 00:05:17
para nosotros 00:05:20
es transparente, nosotros llamamos a los métodos 00:05:21
a remove, lo que sea 00:05:24
y nos olvidamos, pero lo que hace 00:05:26
él por dentro es colocarse 00:05:28
en el primero e ir avanzando por todos 00:05:30
es lo que hace por dentro, es un rollo 00:05:32
pues este 00:05:33
lo que hace por dentro es un poco 00:05:35
más sencillo, porque no tiene que pasar por todos 00:05:38
para llegar a este 00:05:40
pasa por este y se acabó, no pasa por ninguno más 00:05:41
todos los demás no tiene por qué pasar 00:05:44
en una lista enlazada, como estarían todos en fila 00:05:46
para llegar a uno, hay que pasar 00:05:48
por todos, entonces es 00:05:50
mucho más eficiente los recorridos 00:05:52
en el árbol, porque 00:05:54
llegas antes al nodo objetivo 00:05:56
que en una lista, que están todos en fila 00:05:58
entonces la idea, pues está bien 00:06:00
la idea es buena 00:06:02
lo que pasa es que luego hay que programarla 00:06:03
y claro, no la vamos a programar nosotros 00:06:06
porque ya está hecha, pero podríamos 00:06:08
no es tan complicada, tendríamos que hacer 00:06:10
una clase nodo, como hacíamos en la lista enlazada 00:06:12
que la clase nodo tenía 00:06:14
la propiedad valor 00:06:16
y luego la propiedad siguiente nodo 00:06:17
queda la misma y siguiente, pues aquí tendrá 00:06:21
la propiedad valor 00:06:23
nodo izquierda y nodo derecha 00:06:24
y a partir de ahí lo podríamos 00:06:26
programar esta estructura como hicimos 00:06:28
la lista enlazada, igual, pero bueno 00:06:30
no tiene sentido perder tiempo 00:06:32
en eso porque ya lo está 00:06:34
¿esto está programado? sí, está programado 00:06:36
el objeto triset 00:06:38
bueno, pero ¿qué tenemos 00:06:39
que saber para usarlo bien? 00:06:44
yo he dicho muy alegremente antes 00:06:46
sin pararme 00:06:49
que todos los inferiores a este 00:06:49
van a su izquierda y todos los superiores van a su derecha 00:06:52
y aquí igual, todos los inferiores van a su izquierda 00:06:54
y todos los superiores van a su derecha 00:06:57
pero claro, inferior, superior 00:06:57
da igual 00:06:59
da lo mismo 00:07:01
porque es como 00:07:04
es como este hecho por dentro 00:07:05
supongo que estará hecho 00:07:10
si esto es un grafo, de teoría de grafos 00:07:14
entiendo que 00:07:16
es que no hay 00:07:18
izquierda o derecha, es que no hay un plano 00:07:20
me refiero, es que yo lo dibujo en un plano 00:07:22
pero no es que exista izquierda o derecha 00:07:24
eso lo que hay es un nodo 00:07:26
tiene nodo izquierda y nodo derecha 00:07:28
y cada nodo, o sea, hay dos direcciones 00:07:30
de memoria, cuando tú las dibujas 00:07:32
me da igual donde las dibujo 00:07:34
físicamente es que no hay un nodo izquierda y un nodo derecha 00:07:35
o sea, lo que hay es 00:07:38
nodo para un lado y nodo para el otro 00:07:40
¿vale? no hay izquierda y derecha 00:07:42
físicamente 00:07:44
es como decir si hay arriba y abajo en el universo 00:07:45
tú lo puedes dibujar, pero no lo hay 00:07:47
pues aquí lo que hay es nodos y dos direcciones 00:07:49
una 00:07:52
te lleva hacia los mayores 00:07:53
y otra hacia los menores 00:07:56
¿vale? entonces cada nodo tiene 00:07:57
su valor y dos direcciones 00:07:59
la dirección que te lleva a los que son mayores que él 00:08:01
y la dirección que te lleva a los que son menores que él 00:08:04
si tú quieres hacer un dibujo 00:08:06
de eso, pues 00:08:08
dibújalo como quieras 00:08:10
pero vamos que en sí 00:08:11
no es que no esté predefinido 00:08:12
es que no es un concepto 00:08:17
que exista 00:08:19
no es un concepto que tenga sentido 00:08:20
lo que hay físicamente 00:08:21
lo que está programado es 00:08:24
ese objeto nodo 00:08:25
que tiene luego dos direcciones 00:08:26
y una dirección es 00:08:28
la dirección que me llevan los objetos 00:08:30
que son mayores que yo 00:08:31
pero no es que haya un espacio 00:08:32
no sé si me explico 00:08:35
no hay un dibujo ahí 00:08:38
Esa sí es la pregunta. 00:08:39
Esa sí, claro. 00:08:42
Entonces, eso era justo lo que estaba diciendo. 00:08:44
Yo he dicho antes, 00:08:46
cada nodo te apunta 00:08:49
los que son mayores que tú 00:08:51
hacia este lado, a través de esta dirección. 00:08:53
Los que son mayores que tú hacia otro. Y lo he dicho así alegremente, 00:08:55
pero claro, ahora la pregunta sería 00:08:58
¿y qué significa ser mayor 00:08:59
o ser menor? 00:09:01
Pues otra vez tenemos, volvemos a lo mismo. 00:09:03
Hay clases en Java en los cuales 00:09:06
el orden está definido y ya es natural 00:09:08
que es la de los números 00:09:10
y la de los char 00:09:12
ya está, los números y los char 00:09:13
tienen su orden natural, al que podemos 00:09:16
acceder con el menor que y mayor que 00:09:18
entonces 00:09:20
eso está claro, pero ¿y el resto de los 00:09:22
objetos? pues al resto 00:09:24
de los objetos hay que darles desde arriba 00:09:26
el orden 00:09:28
¿cómo? implementando el comparable y el 00:09:29
comparétum, pues aquí 00:09:32
es obligatorio que 00:09:34
todas las clases que vayan a formar 00:09:36
parte de un triset, aquí ya sí que sí 00:09:38
es obligatorio que implementen 00:09:40
comparable, porque el triset 00:09:42
por dentro, necesita 00:09:44
comparar unos con otros para 00:09:46
decidir si yo te llevo a colgar 00:09:48
del nodo de los mayores 00:09:50
o te llevo a colgar del nodo de los menores 00:09:51
entonces si yo uso un triset 00:09:53
es obligatorio que la clase 00:09:55
a la que pertenecen los objetos 00:09:58
del triset, implemente comparable 00:10:00
¿vale? 00:10:01
porque es lo que usa el triset 00:10:03
Bueno, pues entonces, por ejemplo, aquí, pues nada, vamos a meter, ¿vale? Vamos a meter, por ejemplo, pues, ¿qué metemos en el triset? ¿Qué entidad? ¿Qué metemos? Que no sean alumnos, ni clientes, ni facturas, ni... 00:10:05
Venga, vamos a meter ciudades 00:10:26
Ala 00:10:31
Tengo mi clase ciudad 00:10:32
Y la clase ciudad 00:10:35
Pues tiene el nombre 00:10:38
Y tiene el número de habitantes 00:10:39
Vale, y ahora vamos a trabajar con conjuntos de ciudades 00:10:42
Pues para ver que ciudades 00:10:50
Tienen más habitantes que otras 00:10:51
Etcétera 00:10:53
Aquí tenemos el constructor 00:10:54
Y Getty Set 00:11:04
Vale, pues ya está 00:11:10
Esta es nuestra ciudad 00:11:17
ahora 00:11:18
queremos una aplicación para gestionar ciudades 00:11:19
para gestionar 00:11:23
para ordenar 00:11:24
para, bueno 00:11:28
pocas cosas se pueden hacer si solamente tenemos el nombre 00:11:29
y la cantidad de habitantes, pero bueno 00:11:32
pues venga 00:11:34
hacemos ya ahora el main 00:11:36
entonces vamos a gestionar un montón de ciudades 00:11:37
de nuevo, lo de siempre 00:11:49
las meto en un array, vaya rollo meterlas en un array 00:11:51
venga, no, una colección 00:11:53
¿qué colección? 00:11:54
Venga, pues vamos a usar un tríceps 00:11:57
Pues entonces 00:11:58
¡Hala! Pues ahí se queda 00:12:00
Efectivamente 00:12:21
Vale 00:12:36
Vale, pues yo he elegido tríceps 00:12:50
Porque me han dicho que es muy eficiente 00:12:58
Que está muy bien 00:12:59
Bueno, y ya puedo trabajar 00:13:00
Igual que trabajo con cualquier conjunto 00:13:04
Igual que trabajo con cualquier conjunto 00:13:06
Sabiendo lo que sabemos de los conjuntos 00:13:08
Y es que no admiten duplicados 00:13:12
Que no admiten duplicados 00:13:14
entonces, pues venga, yo no voy a meter ciudades repetidas 00:13:15
pues yo voy a empezar a meter ciudades 00:13:19
así a lo bestia, a ver qué pasa 00:13:20
y ya sabemos los métodos 00:13:22
para las colecciones, el add para añadir 00:13:24
el remove para borrar un elemento 00:13:26
el contains para ver si lo tiene 00:13:28
add all para añadir 00:13:31
muchos de golpe, remove all para añadir 00:13:32
muchos de golpe, ya sabemos los métodos 00:13:34
si no lo sabemos ya de memoria 00:13:36
bueno, pues aquí mismo también podemos usar esos métodos 00:13:37
por ejemplo, vamos a 00:13:40
añadir una ciudad 00:13:42
¿Vale? Todavía no he hecho el comparable 00:13:43
Porque vamos a ver efectivamente el problema que nos da 00:13:48
Venga 00:13:50
A la Madrid 00:13:51
Tenemos esta ciudad 00:13:55
Vale, entonces sabemos recorrer 00:13:59
Un set 00:14:26
Sabemos que con un for de índice no 00:14:27
Porque no hay posiciones 00:14:30
Pero podemos recorrer con un iterador o un for each 00:14:31
Si solamente vamos a consultar 00:14:33
Pues bueno, un for each 00:14:35
No es grave 00:14:37
Pues venga, vamos a ver cada ciudad 00:14:38
Vale, vamos a poner un toString 00:14:42
en ciudad 00:14:53
y así le paso directamente el objeto al system.println 00:14:54
o ponemos un toString 00:14:57
que no nos cuesta nada 00:14:59
vale, y el compilador 00:15:02
pues está encantado 00:15:07
porque 00:15:09
hemos usado el set correctamente 00:15:11
pero a mí se me ha olvidado poner aquí 00:15:14
esto, vale 00:15:15
hemos usado el set correctamente 00:15:17
hemos añadido que es un método 00:15:20
de set, hemos recorrido 00:15:22
lo hemos usado muy bien 00:15:24
Porque todos los conjuntos se usan igual 00:15:24
Se añade, se borra, se recorre 00:15:29
Todos iguales 00:15:31
Pues venga, ahora vamos a ejecutar esto 00:15:32
A ver qué pasa 00:15:36
Lo ejecutamos y efectivamente 00:15:37
Me dice, oye 00:15:41
Si leemos que esto es fundamental 00:15:42
Me dice, espérate tú 00:15:49
La ciudad esta 00:15:51
Yo no puedo 00:15:54
Hacerle un casting a comparable 00:15:57
No puedo 00:15:59
traducido al lenguaje natural 00:16:01
es que yo no sé 00:16:04
traducido al lenguaje natural 00:16:06
oye, yo soy el triset 00:16:11
yo soy el triset 00:16:13
y he intentado 00:16:15
cuando me he cogido cada nodo decir 00:16:17
tú eres mayor que este o menor, a ver de dónde te hago colgar 00:16:19
y no he sabido 00:16:21
no he sabido quién es mayor y quién es menor 00:16:23
entonces como no he sabido quién es mayor y quién es menor 00:16:25
no puedo meter en el triset 00:16:27
y ahí se ha quejado 00:16:29
claro, porque efectivamente 00:16:30
un triset para gestionar 00:16:32
sus objetos por dentro 00:16:34
para gestionarlos, necesita saber 00:16:36
cuál es mayor y cuál es menor 00:16:39
compararlos entre sí 00:16:40
y las ciudades 00:16:41
no tienen un criterio de comparación natural 00:16:43
si yo no se lo doy, no son como los números 00:16:46
entonces, ¿cómo dábamos criterios 00:16:48
de comparación 00:16:50
a los objetos que no eran 00:16:51
números ni char? 00:16:54
pues haciéndoles implementar 00:16:56
la interfaz, de esta manera 00:16:58
¿verdad? 00:17:03
si le hacíamos implementar 00:17:06
implementamos la interfaz 00:17:07
comparable del objeto en particular 00:17:10
y ahora ya al implementar 00:17:12
comparable pues tenemos que 00:17:14
añadir 00:17:16
el método que 00:17:18
falta 00:17:20
y aquí 00:17:20
es donde ponemos ya nuestro criterio de ordenación 00:17:23
y aquí lo tenemos que 00:17:26
decidir 00:17:28
aquí tenemos que decidir 00:17:29
esto pasa 00:17:31
por decidir primero qué propiedad es la que identifica a mi clase de forma única. 00:17:32
Lo normal para que un diseño esté bien hecho, lo natural, 00:17:41
es que haya una única propiedad que me sirva como clave primaria. 00:17:44
Pero como haya claves primarias múltiples ya se complica un montón. 00:17:49
Por eso en las claves, yo no sé más o menos en bases de datos, en diseño, 00:17:53
en qué estáis haciendo en general. 00:17:57
pero normalmente veréis que en las tablas 00:17:59
cuando no hay una clave primaria natural 00:18:03
o sea, tenéis un alumno, nombre, apellido, edad, no sé qué 00:18:06
y a veces se crea siempre un campo id 00:18:09
que además se le pone que es autoincrement 00:18:13
y además haciéndole autoincrement 00:18:16
uno tiene la seguridad de que va a ser único 00:18:19
distinto para cada campo 00:18:21
y así tenemos además una clave primaria 00:18:23
en un solo valor 00:18:26
¿habéis trabajado con tablas 00:18:28
con claves primarias múltiples? 00:18:31
¿o la clave primaria siempre ha sido un campo? 00:18:34
pues es una clave primaria múltiple 00:18:41
que son dos campos 00:18:43
en general es recomendable 00:18:45
que las claves primarias 00:18:49
se puedan recoger en un solo campo 00:18:52
porque facilita muchísimo el trabajo con esos datos 00:18:54
y por eso cuando hay una tabla 00:18:58
que tiene una clave 00:19:02
que tiene claves primarias dobles 00:19:03
se suele generar un campo extra 00:19:04
de tipo autoincrement 00:19:08
y de que pueda hacer 00:19:10
de clave primaria 00:19:12
a ver, para qué quiero decir yo este rollo 00:19:12
pues que en un buen diseño de clases 00:19:15
también suele ocurrir lo mismo 00:19:17
lo natural es que, y en el trícel sobre todo es fundamental 00:19:18
para fitar el orden 00:19:21
que haya un único campo 00:19:22
que sea el campo que permita distinguir de forma única 00:19:24
En este caso estaría claro 00:19:26
¿Qué distingue de forma única una ciudad de otro? 00:19:29
El nombre 00:19:32
Porque pueden tener dos ciudades los mismos habitantes 00:19:33
El nombre 00:19:35
Pues entonces tenemos una clave primaria 00:19:35
Vale, pues entonces ahora ya 00:19:38
Establecemos el orden 00:19:40
En función de ese campo 00:19:42
Tenemos que establecer el orden en función de ese campo 00:19:44
Bueno, pues aquí como el campo 00:19:46
Primario es 00:19:49
Un string 00:19:50
Aquí lo natural es que el orden que fijemos 00:19:51
Sea el alfabético 00:19:55
entonces uno decide, tiene que decidir un orden 00:19:55
si quiere que esto 00:19:59
forme parte de un tríceps, tiene que decidir un orden 00:20:01
eso es incuestionable 00:20:03
tiene que decidir un orden 00:20:05
¿cómo decide ese orden? ¿como le dé la gana? 00:20:06
pues no, lo normal es que se vaya 00:20:08
al campo que está funcionando 00:20:11
como clave primaria 00:20:13
al que distingue de forma única a los objetos 00:20:14
en nuestro caso 00:20:17
es esta propiedad 00:20:19
y ahora ya en esa propiedad decide el orden 00:20:20
pues si es un string 00:20:23
El alfabético es el natural. Si es un número, pues el orden natural de los numeritos. Bueno, pues en nuestro caso el orden que tendría sentido decidir aquí para las ciudades es que se ordenen por orden alfabético de nombre. 00:20:25
Bueno, pues una vez que ya tenemos claro que el orden que nos pega y que viene bien ahí es el orden alfabético por nombre, desde luego no tendría sentido ordenarlos por número de habitantes. 00:20:38
porque ¿qué pasa con dos ciudades con el mismo 00:20:49
número de habitantes? son dos ciudades 00:20:51
distintas 00:20:53
no tendría sentido ordenarlos así, tiene sentido ordenarlos por nombre 00:20:54
que es lo que lo distingue 00:20:57
pues una vez que hemos identificado que eso es el criterio que queremos 00:20:58
nos vamos ya 00:21:01
a programar el método 00:21:03
y esto ya lo hemos hecho otras veces 00:21:05
pues la clase string 00:21:08
tiene el compareTo 00:21:10
para comparar alfabéticamente 00:21:11
entonces podríamos hacer 00:21:13
esto 00:21:16
y ya lo tenemos 00:21:17
nombre es el nombre de la ciudad que llama el método 00:21:21
o punto nombre es el nombre de la ciudad parámetro 00:21:25
esto es ya el compare to de la clase string 00:21:29
que ya me devuelve negativo si este alfabéticamente está antes 00:21:33
cero si alfabéticamente son el mismo 00:21:38
y positivo si este alfabéticamente está después 00:21:41
pues es justo lo que queremos 00:21:44
en mi compare to de ciudad 00:21:46
ordenar 00:21:48
vale, bueno esto ya lo hemos hecho 00:21:49
muchas otras veces 00:21:52
para usar el método sort de las listas 00:21:53
o el de 00:21:57
arrays, ya hemos hecho esto 00:21:59
vale, pues ya le hemos 00:22:00
dado al triset lo que necesita 00:22:03
que es 00:22:04
poder comparar ciudades entre sí 00:22:06
poder comparar ciudades entre sí 00:22:09
vale 00:22:10
entonces ahora ya este mismo código 00:22:14
este mismo código sin haberle cambiado 00:22:17
nada, cuando ahora 00:22:19
ejecutemos, ya está 00:22:21
he puesto una O porque este se llama O 00:22:24
claro, este, este 00:22:28
vale, entonces hará esto mismo 00:22:32
este mismo código sin cambiarlo, si lo ejecutamos 00:22:38
ahora ya sí, ya no tendrá 00:22:41
problema, vale 00:22:42
y además el triset nos da 00:22:44
otras prestaciones, otras comodidades 00:22:50
que como el árbol está ordenado 00:22:51
a la hora de iterar 00:22:53
él itera según el orden 00:22:55
que le hemos dicho, veis, Cádiz va antes que 00:22:57
Madrid y va antes que Sevilla. Entonces, el orden 00:22:59
de iteración en un tríceps es el 00:23:01
orden de los objetos. Es ese. 00:23:03
Entonces, cuando nos 00:23:07
interesa 00:23:07
que los objetos estén 00:23:08
ordenados 00:23:11
según el criterio de orden que 00:23:12
yo he fijado, pues un tríceps es 00:23:15
estupendo porque es que me los va colocando 00:23:17
ordenaditos y cuando yo itero por él 00:23:19
ya están ordenados según ese orden. 00:23:21
No según el orden al que lo metí. 00:23:24
No según ese orden al que lo metí, sino según 00:23:26
el orden que yo he dicho. 00:23:27
y si le meto aquí 00:23:29
una ciudad 00:23:31
le voy a añadir ahora otra 00:23:33
pues si alfabéticamente 00:23:36
es la primera, me la va a poner la primera 00:23:38
bueno, aunque la 00:23:40
voy a quitar la tilde porque no sé dónde está 00:23:52
en la tabla 00:23:55
vale, pues yo ahora cuando itere, veré que 00:23:56
Alaba la ha colocado la primera, porque el triset 00:24:03
va metiendo por orden y si yo itero 00:24:05
va iterando por el orden 00:24:07
del comparable 00:24:08
entonces efectivamente pues 00:24:10
conserva el orden que yo haya dicho 00:24:16
que puede ser útil 00:24:18
o puede no ser útil, nos puede dar igual o no 00:24:21
pero bueno, pues 00:24:22
es esa prestación que tiene 00:24:24
conserva el orden a la hora de iterar 00:24:26
¿y ahora qué ocurre? 00:24:29
en el set hemos dicho 00:24:32
en el set en general, en cualquier set 00:24:33
hemos dicho que el set no admite duplicados 00:24:35
yo no puedo meter el mismo objeto 00:24:37
una segunda vez, y aquí me podéis decir 00:24:39
¿y qué entiende por duplicados? 00:24:42
porque aquí no has hecho 00:24:44
un equal, si han hecho nada, un duplicado 00:24:45
según el equals de object, no 00:24:47
para el preset 00:24:48
los duplicados 00:24:50
son los que 00:24:53
el compare to da 0 00:24:55
ni equals ni nada 00:24:57
este es el único método que a él le importa 00:24:59
el único 00:25:01
entonces si yo ahora meto aquí 00:25:02
voy a intentar meter 00:25:04
otra vez a esta 00:25:06
voy a intentar meterla otra vez 00:25:12
y voy a volver a recorrer 00:25:20
¿vale? 00:25:22
tengo estas 4, las muestro, vuelvo a meter 00:25:30
esta con otros habitantes 00:25:32
otros, vuelvo 00:25:34
a meter esta y vuelvo a recorrer 00:25:36
vale 00:25:39
ejecuto esto 00:25:40
vale 00:25:43
y veis, esta es 00:25:44
la primera iteración 00:25:47
y esta es la segunda 00:25:49
no ha metido álava por segunda vez 00:25:50
no lo ha metido 00:25:52
y diréis, pero si no hay ningún equals aquí 00:25:53
¿cómo ha podido saber 00:25:56
que no hay ningún equals basado en nombre? 00:25:59
está el igual de obvio, el igual de obvio es proyección de memoria 00:26:00
¿por qué para él son iguales? 00:26:03
si solo tienen igual el nombre 00:26:05
porque para el triset la igualdad la da 00:26:06
este método 00:26:09
este 00:26:10
la da ese 00:26:11
entonces, este método dice 00:26:14
que la álaba 00:26:17
esta de aquí, de 4.000 habitantes 00:26:19
y la álaba que yo he metido después 00:26:21
de 10.000, según el compare 00:26:23
tú, me está devolviendo 0 00:26:25
luego son el mismo 00:26:27
no se niega a meterlo 00:26:28
porque en un set no se pueden meter duplicados 00:26:30
bueno, pues estas son 00:26:32
todas las particulares del tricer 00:26:36
y ya está 00:26:38
que necesita que haya un criterio 00:26:39
de orden en las clases 00:26:42
a las que 00:26:44
pertenecen los objetos 00:26:46
que van a formar parte del set 00:26:47
que los va metiendo ordenados 00:26:49
con lo cual cuando yo itere 00:26:52
voy a ver ese orden 00:26:53
que puede serme útil o no 00:26:55
aquí no hace falta que haya un sort, por ejemplo 00:26:57
aquí no hay que hacer un sort, es que ya 00:26:59
van entrando ordenados 00:27:01
y que los duplicados 00:27:02
para él 00:27:06
son los que devuelve 00:27:06
este método, para él el equals lo ignora 00:27:10
cuando yo 00:27:12
haga aquí un remove 00:27:14
por ejemplo, imaginaos que ahora queremos borrar 00:27:15
vamos a borrar de ciudades 00:27:17
quiero borrar Madrid 00:27:20
pues con hacer esto 00:27:24
es suficiente 00:27:26
poniendo aquí cualquier cosa, me da igual 00:27:26
vale, porque el remove que hace 00:27:35
recordad que lo que hace es 00:27:40
coge este objeto 00:27:41
y busca en la colección 00:27:44
el que sea igual a ese 00:27:46
y cuando lo encuentra 00:27:48
fuera 00:27:50
pero aquí que significa igual para el remove 00:27:51
aquí para el remove igual no significa 00:27:54
llamar al equals 00:27:56
aquí para el remove del triset 00:27:56
igual va a significar 00:28:00
el compare to 00:28:02
con lo cual, aunque no hay 00:28:03
ningún equals basado en el nombre 00:28:06
si me va a eliminar esa ciudad 00:28:07
me la va a eliminar porque cuando le aplique 00:28:10
el compare to verá que me da cero 00:28:12
con esta otra, luego es el mismo 00:28:14
vale, vamos a comprobarlo 00:28:15
porque yo no me fío nada de lo que digo 00:28:18
espera, vamos a ponerle 00:28:20
vale 00:28:27
pues si ejecutamos esto 00:28:45
los cuatro primeros 00:28:47
el segundo alabato no lo ha metido 00:28:51
y ha eliminado Madrid 00:28:53
el remove, pues me ha eliminado Madrid 00:28:55
me lo ha eliminado 00:28:57
porque el remove en este caso 00:28:59
no está tirando de equal, está tirando 00:29:01
del compare to 00:29:03
entonces el triset es 00:29:03
si uno se pusiera a contar 00:29:07
lo que pasa es que en números de objetos tan pequeños 00:29:09
es difícil de estimar 00:29:11
pero si en aplicaciones con 00:29:13
volúmenes de datos grandes, si uno 00:29:15
contara los milisegundos 00:29:16
que tardan los accesos 00:29:19
pues vería que el triset es 00:29:20
el más rápido en realidad 00:29:23
pero el triset lo que pasa es que exige 00:29:24
que haya un criterio de orden 00:29:27
y ese criterio de orden pues me puede complicar 00:29:28
la vida o no me la puede complicar 00:29:31
no sé, depende 00:29:32
en general los conjuntos 00:29:33
siempre son mejor elección que las listas 00:29:37
si yo no necesito 00:29:39
duplicados ni posición 00:29:41
y el hash set es el más sencillo 00:29:43
es el más sencillo 00:29:47
esperamos, el triset se usa mucho 00:29:49
porque es de accesos muy rápidos 00:29:51
¿vale? 00:29:53
bueno, sí 00:29:55
y ya con esto si queréis 00:29:57
lo dejamos 00:29:59
lo único, imaginaos que estáis en la situación 00:30:01
en la que queréis usar un triset 00:30:03
queréis usar un triset que es muy rápido 00:30:04
y está muy bien y queréis usar un triset 00:30:07
pero no tenéis acceso a las clases entidad 00:30:08
no tenéis acceso 00:30:10
entonces al no tener acceso, esto no lo podéis hacer 00:30:12
imaginaos que estáis en ese caso 00:30:15
a mí me han dicho 00:30:17
que tire de ciudad 00:30:19
pero, lo siento 00:30:20
no puedo tocarla 00:30:22
con lo cual si no puedo tocarla 00:30:25
no puedo hacer que implemente 00:30:27
entonces esto no estaría 00:30:29
esto de aquí 00:30:31
no estaría 00:30:33
entonces 00:30:36
según eso 00:30:39
pues el triset no va a funcionar 00:30:41
efectivamente no va a funcionar 00:30:44
pero todavía se puede hacer un apaño que es 00:30:45
al constructor de triset 00:30:47
yo le puedo pasar 00:30:50
un criterio de ordenación concreto 00:30:51
para él y decirle oye tú 00:30:54
usa este criterio 00:30:55
y ya está, y eso a través de 00:30:57
qué objeto se hacía, ¿alguien se acuerda? 00:31:00
cuando quiero pasar un criterio de ordenación concreto 00:31:02
por ejemplo, cuando ordenábamos una lista 00:31:03
con sort y queríamos pasarle 00:31:06
un criterio de ordenación 00:31:08
a través del objeto 00:31:09
comparator, que es otra cosa, no es el 00:31:13
comparable, ¿vale? 00:31:16
pues entonces, me voy a hacer un objeto 00:31:17
comparator, que es un criterio de ordenación 00:31:20
concreto, y ese criterio de ordenación 00:31:22
concreto se lo paso al tríceps 00:31:24
Y así no tengo que tocar la clase ciudad. 00:31:25
Y ese criterio de ordenación va a valer para ese triseto. 00:31:29
Entonces, ¿cómo se hacían esos comparator? 00:31:32
Pues, hacíamos un objeto en orden ciudad, ciudades. 00:31:37
Este objeto tenía que implementar este otro. 00:31:54
Entonces, al implementar este otro 00:31:58
Se hacía automáticamente 00:32:04
Criterio de ordenación 00:32:07
Y le tocaba implementar el método este 00:32:11
Vale, entonces aquí decíamos 00:32:13
Vale, muy bien 00:32:17
Pues dame el orden entre la ciudad O1 y la ciudad O2 00:32:18
Dame el orden entre la ciudad O1 y la ciudad O2 00:32:22
Bueno, como es el alfabético 00:32:24
Podríamos hacer O1.nombre 00:32:26
compare-tool 00:32:29
o dos.nombre 00:32:32
¡Hala! 00:32:39
Ya tengo un criterio de ordenación concreto 00:32:44
entre dos ciudades 00:32:46
y este criterio de ordenación 00:32:47
se lo paso a quien quiera. Al sort para ordenar 00:32:50
al triset para sus usos 00:32:53
se lo paso a quien quiera. Pues venga 00:32:54
vamos a pasárselo a este triset 00:32:56
como este triset me va a dar problemas 00:32:58
porque ciudad no tiene comparable 00:33:00
como me va a dar problemas 00:33:02
pues le voy a decir, oye 00:33:04
Cuidado, que te voy a pasar un nuevo criterio 00:33:06
Orden 00:33:08
Ciudades 00:33:11
Ala, como veis el constructor de Triset 00:33:14
Está sobrecargado, admite varias 00:33:18
Vale, le decimos 00:33:19
Ah, vale, me pasas un criterio de ordenación 00:33:21
En concreto 00:33:24
Pues muy bien, pues yo ya funciono 00:33:24
Según ese criterio de ordenación 00:33:28
Y ya está 00:33:30
Y bueno 00:33:32
Está funcionando igual 00:33:32
Y ciudad no implementa comparable 00:33:35
Pero le hemos dicho al triset 00:33:37
Cómo solucionar ese problema 00:33:38
Vale 00:33:40
Bueno, pues este es el triset 00:33:43
Su uso, etcétera, etcétera 00:33:47
Vale 00:33:49
Preguntas 00:33:51
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
7
Fecha:
3 de abril de 2024 - 18:42
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
34′
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
154.22 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid