Saltar navegación

20250204 HashSet_1 - 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 4 de febrero de 2025 por Raquel G.

15 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale. 00:00:01
Tranquilo, no pasa nada. 00:00:05
Examen sorpresa. 00:00:07
Venga. 00:00:08
Bueno, dentro de dos semanas 00:00:11
que es casi ya. 00:00:13
Bueno, relax. 00:00:17
Vale, a ver. 00:00:20
Es otra implementación 00:00:22
de colección, 00:00:24
pero sigue siendo abstracta 00:00:26
porque hay que concretarla 00:00:28
un poquito más. 00:00:30
Para ver cómo hacemos eso de los conjuntos, cómo podemos programar conjuntos. 00:00:31
No los vamos a programar nosotros, porque no sabemos hacerlos, porque es un lío, porque es un rollo patatero. 00:00:36
Pero vamos a ver los conceptos teóricos sobre los que se han sustentado las tres implementaciones de SEP que hay. 00:00:45
Pues de SEP, ahora ya hay tres implementaciones que se hacen así que sin instancia, para meter cositas. 00:00:53
Una es el HASHET, otra es el LINKED HASHET y otra es el TRIZEL. 00:00:58
Esto es lo que he dicho antes. 00:01:25
Hemos dicho que Collection tiene dos formas de implementarse, listas y conjuntas. 00:01:27
las listas, todo lo que hay por debajo 00:01:32
de listas, sobre lo que se basa 00:01:35
lo conocemos y ahora lo que se trata es de usarlo 00:01:37
pues ahora vamos a ver 00:01:39
lo que hay por debajo de conjuntos 00:01:41
muy por encima y luego de nuevo se trata de usarlo 00:01:42
¿vale? 00:01:45
bueno, pues a ver 00:01:46
los conjuntos 00:01:47
recordad 00:01:50
que lo que le diferencia de listas 00:01:51
es que los elementos 00:01:55
no tienen 00:01:57
posición 00:01:58
toma ya 00:01:59
están ahí a lo bestia 00:02:03
entonces tú lo puedes hacer 00:02:08
recupérame el de posición 3 00:02:10
como puedes hacer una lista 00:02:12
eso no lo puedes hacer 00:02:13
¿qué haces con un conjunto? 00:02:15
iterar por él 00:02:17
iterar y ver lo que hay 00:02:18
y cuando encuentras el que estás buscando 00:02:20
pues te lo quedas o lo modificas 00:02:22
o lo que quieras hacer 00:02:24
¿vale? 00:02:25
en una caja con posiciones 00:02:27
tú puedes hacer 00:02:29
voy a coger el 4, metes la mano 00:02:31
sin mirar y coges el 4 00:02:33
en un conjunto 00:02:35
que es una caja sin posiciones 00:02:37
ahí tú, no tiene sentido que tú metas la mano 00:02:39
y saques porque puedes sacar cualquier cosa 00:02:41
luego el método get no existe 00:02:43
¿por qué? ¿qué significa? ¿meto la mano y saco al azar? 00:02:45
no, el método met no existe 00:02:48
lo que existe es ir tú mirando la cajita 00:02:49
ah, este quiere, pues ese 00:02:52
eso es lo que existe 00:02:53
y eso es lo que se llama iterar 00:02:55
iterar por la cajita 00:02:57
por el set, iterar 00:02:59
este es el que quiero modificar, a este le pinto de verde 00:03:00
ahora, este es el que quiero eliminar 00:03:03
pues a este le salgo y le tiro la basura 00:03:05
ese es el que quiero consultar a ver que tiene dentro 00:03:06
entonces va a necesitar 00:03:08
iteración dentro de la cajita 00:03:11
en la lista 00:03:13
podemos iterar, por supuesto, ir uno por uno 00:03:15
pero también podemos sacar uno de golpe 00:03:17
sacar el 3, aquí no 00:03:19
esa es la diferencia esencial 00:03:20
¿vale? ahora 00:03:23
eso permite que la programación 00:03:24
sea más fácil 00:03:27
y que computacionalmente 00:03:28
el rendimiento sea mucho mejor 00:03:30
entonces siempre que uno no necesite 00:03:32
llevar un registro de las posiciones 00:03:34
usará conjuntos 00:03:36
porque computacionalmente son mejores 00:03:37
pero cuando para ti la posición 00:03:40
es importante, usarás vistas 00:03:42
¿vale? 00:03:44
porque además el que la posición 00:03:46
el llevar un registro de la posición 00:03:49
tiene una implicación fundamental 00:03:50
que también hemos mencionado 00:03:53
que en una list 00:03:55
en mi cabeza es más fácil un array que cualquier otra 00:03:56
ah, ahora queréis los arrays por encima de todo 00:03:58
y los char 00:04:02
que no 00:04:02
sobre los char 00:04:05
sobre los char 00:04:06
a ver, en cuanto hagamos 00:04:08
dos, tres, cuatro aplicaciones con list y set 00:04:11
veréis que es lo mismo una y otra vez 00:04:14
y por supuesto súper útil 00:04:15
no os vais a volver locos 00:04:17
ni nada de eso 00:04:19
entonces 00:04:20
el que una lista 00:04:23
lleve el registro de la posición 00:04:25
¿qué implicación tiene? 00:04:27
que tú puedes meter dos objetos iguales 00:04:30
porque uno va en la primera y tú en la tercera 00:04:32
y no pasa nada 00:04:33
porque sean iguales, porque los puedes distinguir 00:04:35
en un conjunto 00:04:37
no puedes meter 00:04:40
dos objetos iguales 00:04:42
porque 00:04:44
se confundirían 00:04:45
porque no hay posición, se quedarían confundidos 00:04:47
luego 00:04:50
el hecho de que el set no lleve 00:04:52
registro de posición implica 00:04:54
que no puedes 00:04:56
meter duplicados, que no admite duplicados 00:04:58
esa es la primera cosa que vamos a comprobar 00:05:01
ahora cuando lo probemos, que si tú metes en el set 00:05:03
el 3 y luego 00:05:05
le vuelves a hacer otro add del 3 00:05:06
ese no te lo ha metido y te dice ya tengo un 3 00:05:08
lo siento mucho 00:05:10
luego simplemente no lo mete, no te dice nada 00:05:11
vale 00:05:14
bueno 00:05:16
ahora ya, ¿cómo se implementa 00:05:18
esto por debajo? 00:05:21
bueno, pues con unas ideas que vamos a mencionar 00:05:23
muy por encima, de las cuales 00:05:25
no me preguntéis muchos detalles 00:05:27
porque los desconozco a nivel de 00:05:29
implementación, ni siquiera los conozco 00:05:31
¿vale? entonces no me preguntéis 00:05:33
¿vale? pero las ideas sobre las que se basa 00:05:34
sí, bueno, pues en sencilla, esto y esto 00:05:37
como se va a lo mismo, lo metemos ahí en mosaico 00:05:39
estas dos 00:05:40
se basan en la idea de tabla hash 00:05:42
estas dos 00:05:45
implementaciones. 00:05:47
Y estas dos se basan en la 00:05:49
idea de árbol binario. 00:05:51
Que son dos estructuras 00:05:54
que no tienen nada que ver. 00:05:55
Nada que ver. 00:05:57
Pero 00:05:58
las dos se han usado para 00:05:59
implementar conjuntos. Que luego a la hora de usarse 00:06:03
se usan igual. Es que me da igual que 00:06:05
el conjunto sea un haset 00:06:07
que sea un triset. Si es que los voy a usar igual. 00:06:09
Una caja para meter cosas. Habrá 00:06:11
algunas pequeñas diferencias que vamos a ver. 00:06:13
Como que una va a tener orden y otra 00:06:15
no, pero ya está, no va a haber más diferencias 00:06:17
van a ser cajas para meter las cosas 00:06:19
ahí, como voy yo 00:06:21
¿vale? bueno, pues 00:06:22
la tabla hash, ¿qué es? esto es como 00:06:24
de la pila, cola, vamos a mencionar qué es 00:06:27
porque uno tiene que saber qué es 00:06:28
para ver cómo se ha usado en estas estructuras 00:06:29
¿qué es una, más que 00:06:35
una tabla hash, una función de hash? 00:06:44
una función que multiplica 00:06:47
para conseguir un código 00:06:48
de un número determinado de caracteres 00:06:50
que luego con ese mismo código puedes 00:06:52
recuperar, justo 00:06:54
La función de hash es una forma de facilitar la clasificación y recuperación de datos. Es decir, uno tiene, hablo de cualquier contexto, no solo en el contexto nuestro de las colecciones, uno tiene un montón de datos. 00:06:55
hay todos a mogollón 00:07:13
entonces 00:07:16
si tú tienes que ir a buscarlos 00:07:17
ahí a mogollón en los 2000 00:07:20
pues 00:07:22
estás ahí emborronado buscando 00:07:23
vale, ¿qué hace la función de hash? 00:07:26
la función de hash es una función 00:07:29
que se aplica 00:07:30
a un elemento 00:07:32
una función que se aplica a un elemento 00:07:33
y te devuelve un número 00:07:36
¿vale? 00:07:37
una función de hash es como transformarte 00:07:40
un elemento del tipo que sea 00:07:42
un objeto alumno, un objeto profesor 00:07:44
un objeto factura, te transforma 00:07:46
un elemento a un numerito 00:07:48
es una transformación a un numerito 00:07:50
vale, entonces la función de hash 00:07:52
no es 00:07:54
biyectiva 00:07:56
es inyectiva 00:07:58
¿qué quiero decir con esto? 00:07:59
que muchos elementos 00:08:01
de la caja 00:08:04
de este mogollón 00:08:04
pueden ir al mismo número 00:08:06
no pasa nada 00:08:08
entonces, lo que realmente hace la función de hash 00:08:10
es como si hiciera 00:08:13
una serie de subconjuntos 00:08:15
es decir, me clasifica 00:08:16
todos los elementos que están 00:08:19
en una caja enorme, me los clasifica 00:08:21
en apartaditos, solamente eso 00:08:23
y cada apartadito 00:08:25
está formado por todos los elementos 00:08:27
que aplicada 00:08:29
la función de hash correspondiente 00:08:30
te llevan al mismo número, estos se llevan al 3 00:08:32
estos se llevan al 4, estos se llevan al 5 00:08:35
entonces es la función de hash 00:08:37
una función que te permite 00:08:39
clasificar un mogollón de datos 00:08:41
en subconjuntos 00:08:43
y todos los elementos de un subconjunto 00:08:45
comparten 00:08:47
que la función de hash aplicada a ellos 00:08:49
se llevan al mismo numerito. 00:08:51
¿Los subconjuntos los eliges tú o es 00:08:53
la de a todo? 00:08:55
La función de hash la eliges tú en función 00:08:56
de la aplicación a la que quieras usar eso. 00:08:59
La función de hash 00:09:01
la implicación que tiene lógicamente es 00:09:03
cuáles van a ser los subconjuntos. 00:09:05
obviamente, en función de cómo sea la función de hash 00:09:07
¿cuál sería la peor función 00:09:09
de hash del mundo? 00:09:11
la peor función del hash del mundo sería esta 00:09:13
por ejemplo 00:09:15
f de x igual a 1 00:09:17
una función perfectamente matemática 00:09:19
perfectamente legal, f de x igual a 1 00:09:21
la función constante 00:09:23
esta función de hash 00:09:24
una función de hash perfectamente válida 00:09:26
no ha hecho nada 00:09:28
porque todos los elementos 00:09:30
caen todos en un único 00:09:32
subconjunto 00:09:35
no he clasificado nada 00:09:36
¿vale? 00:09:37
podría haber otra función de hash 00:09:40
que la mitad de ellos 00:09:41
por ejemplo una función de hash, pues yo que sé 00:09:44
que si es positivo 00:09:46
que hace una operación matemática 00:09:48
que todos los positivos te da uno 00:09:50
y todos los negativos te da menos uno, por ejemplo 00:09:52
pues a lo mejor consigue dos subconjuntos 00:09:54
entonces la función de hash 00:09:56
depende de la aplicación en la que estoy trabajando 00:09:58
pues se crea 00:10:01
de una manera o de otra 00:10:02
¿y qué implicación tiene? 00:10:03
en la cantidad de subconjuntos 00:10:05
que puedes crear. 00:10:07
¿Vale? Pero claro, hay un compromiso. 00:10:09
La función de hash ideal 00:10:12
no es la función 00:10:14
biyectiva, es decir, que cada elemento 00:10:15
te lleva un número distinto. 00:10:17
Porque es que entonces si no, no has ganado nada tampoco. 00:10:19
¿Me explico? Diréis, 00:10:21
vale, ¿y para qué me sirve a mí hacer subconjuntos? 00:10:23
Ya, 00:10:27
está muy emborronado. 00:10:27
Eso diréis, no diréis, ¿y para qué quiero yo hacer subconjuntos? 00:10:29
Pues para facilitar 00:10:32
las búsquedas, es decir 00:10:33
repito 00:10:35
si tú tienes aquí 00:10:37
un montón de elementos y dices 00:10:39
voy a buscar el elemento 00:10:41
depende 00:10:45
el alumno de ojos azules, lo que sea 00:10:47
el que sea, pues 00:10:49
si no los tienes clasterizados 00:10:50
es decir, en subconjuntos 00:10:53
en lo que llamamos un clúster en informática 00:10:55
un clúster 00:10:56
es un subconjunto de algo 00:10:59
por eso cuando hablamos de clústerizar 00:11:00
es cuando estamos 00:11:03
nosotros lo usamos mucho 00:11:05
para clasterizar cualquier cosa 00:11:07
¿vale? 00:11:10
pues si no los tenemos clasterizados 00:11:11
o compartimentados en subconjuntos 00:11:13
para buscar el alumno 00:11:16
de ojos azules, tienes que ir a donde está 00:11:17
lo vas sacando y todo eso 00:11:19
madre mía, lo sacas 00:11:21
pero si tú 00:11:22
has hecho subconjuntos 00:11:25
dices, a ver, ¿dónde está 00:11:27
el de ojos azules? 00:11:31
¿le aplicas la función de hash? 00:11:32
a uno de ojos azules 00:11:34
la función de hash te dice 3 00:11:36
pues tú te vas al subconjunto 3 00:11:38
y ahora ya la búsqueda en la caja 00:11:41
solo es en el subconjunto 00:11:43
esa es la utilidad de la función de hash 00:11:44
que se aplica en muchos contextos 00:11:48
a ver, yo estoy hablando en términos 00:11:50
conceptuales 00:11:55
depende de 00:11:57
a qué estamos aplicando esto 00:11:59
Si estamos hablando allá del hashed, ¿en qué se basa el hashed? El hashed se basa en, yo tengo ahí todos mis elementos a mogollón, defino yo como programador una función de hash, la defino yo, y ahí ese famoso hashcode que aparecía solito, que no sabemos en qué pintaba, pues ese hashcode que aparecía solito me ahorra el trabajo, me hace una función de hash. 00:12:02
¿Para qué me sirve esa función de hash en una clase? 00:12:27
Me sirve, por ejemplo, para esto. 00:12:31
Entonces, yo tengo ahí un montón de elementos. 00:12:33
Hago una función de hash para esos objetos, 00:12:36
la que esté programada en el hash code de la clase. 00:12:38
Porque ese hash code tira de las propiedades del objeto, 00:12:41
luego ese hash code me consigue un número entero 00:12:44
en función de las propiedades del objeto. 00:12:47
Vale, pues ese hash code lo que me sirve es 00:12:50
para que todos esos objetos que yo tengo en el set 00:12:53
Se quedan en subconjuntos separados 00:12:56
Y ahora 00:12:58
Dentro de cada subconjunto 00:13:01
¿Qué hace el hash set? 00:13:03
¿Cómo decide organizar? 00:13:05
El mismo tipo de objeto 00:13:06
Los mete en una lista enlazada 00:13:08
Fíjate en casualidad 00:13:11
Todos los, claro 00:13:12
Entonces cada subconjunto 00:13:15
Para el hash set 00:13:17
Es en realidad una lista enlazada 00:13:18
O sea que la idea de un hash set 00:13:20
Es meter distintos tipos de objetos 00:13:21
Claro, un hash set son 00:13:24
en lugar de tener 00:13:26
un haset es 00:13:28
la idea del haset es 00:13:29
en lugar de tener un linked list 00:13:32
con todos en filita 00:13:34
yo los separo por apartados 00:13:35
me cojo estos de ojos azules 00:13:38
estos de ojos marrones 00:13:40
y estos de ojos grises 00:13:42
los pongo en tres listas enlazadas 00:13:43
la lista enlazada de los ojos azules 00:13:46
y ahora que tú me dices 00:13:48
búscame el alumno 00:13:51
de ojos azules que se llama Pepito 00:13:53
yo me voy al subconjunto 00:13:54
de ojos azules 00:13:57
¿vale? y en ese subconjunto 00:13:58
no tengo que recorrer una lista en la sala entera 00:14:01
recorro una sublista 00:14:02
entonces en ese caso la función de hash sería 00:14:04
color de tus ojos 00:14:07
entonces coges uno cualquiera 00:14:08
y el color de tus ojos decide a qué subconjunto 00:14:10
te vas, esa sería la función de hash 00:14:13
pero claro, puedes coexistir 00:14:15
con otro objeto del mismo color que tú 00:14:17
pues todos en la filita, en la lista 00:14:18
eso optimiza 00:14:20
las búsquedas 00:14:22
en lugar de recorrer la lista entera 00:14:24
tú primero dices 00:14:26
a ver Edward tiene los ojos azules 00:14:28
pues busco solo en tu parro 00:14:29
¿vale? 00:14:31
esa es la idea del Hachette 00:14:34
eso es lo que tiene de fondo 00:14:35
claro, todos los elementos de la colección 00:14:37
los separas 00:14:44
en apartados 00:14:46
como dices tú, o en subconjuntos 00:14:48
¿cuál es el criterio para separarlos? 00:14:50
lo que te diga la función de Hachette 00:14:52
para cada uno de ellos. 00:14:54
Si la función de hash te lleva al 3, 00:14:55
lo llevas al subapartado 3. 00:14:58
Si te lleva al 4, es al subapartado 4. 00:14:59
Entonces tú tendrás varios subapartados. 00:15:01
¿Quieres ver dónde está este? 00:15:04
Dices, oye, tú, voy a aplicar la función de hash a este. 00:15:06
Me dice 4. 00:15:09
Ah, genial. 00:15:10
Pues me voy al apartado 4. 00:15:10
Y ahí ya lo busco. 00:15:11
Lo busco en el caso de hashed en una lista, 00:15:13
que es donde está guardado. 00:15:16
Pero a la hora de implementar esto en tu grabación, 00:15:17
¿no te va a... 00:15:19
Esto es una... 00:15:19
Yo no lo he implementado nunca. 00:15:21
Ah, a ver. 00:15:22
Pero vamos. 00:15:23
a ver, en realidad tampoco es que sea muy complicado 00:15:23
porque es hacer 00:15:26
llevar un registro de varias listas 00:15:27
enlazadas, que seguramente 00:15:29
lo lleven a un array, se podría mirar por curiosidad 00:15:32
en qué estructura llevan 00:15:34
bueno, no, seguramente no, sé que lo llevan a un array 00:15:35
un haset por dentro es un array 00:15:37
de listas enlazadas 00:15:40
claro, cada posición del array 00:15:42
es una lista enlazada, entonces la función 00:15:44
de hash lo que define es 00:15:46
cuántas posiciones tiene el array 00:15:47
claro, la función de hash te lleva 00:15:48
a la posición del array 00:15:52
y luego ya iteras. 00:15:53
Vale. 00:15:56
Entonces, el hash set por dentro 00:15:58
es esto, en realidad. 00:16:00
un array 00:16:04
y cada array 00:16:06
te lleva a una lista enlazada. 00:16:08
Y así están los elementos. 00:16:11
Entonces, la función 00:16:14
de hash te lleva a la 00:16:16
posición del array. 00:16:18
¿Vale? 00:16:20
claro, la función de hash te lleva a la posición 00:16:20
y luego tú ya 00:16:23
buscas 00:16:25
el elemento en la lista 00:16:27
bueno, lo buscas tú, no, lo busca el hash 00:16:29
tú dices 00:16:31
iteras, aceseras, lo que sea 00:16:32
y él ya se ha apañado en todo esto 00:16:34
está parado por dentro 00:16:36
entonces 00:16:38
la función de hash 00:16:40
repito 00:16:49
la decide uno 00:16:50
la decide uno en su aplicación 00:16:52
Y esa función de hash para los elementos, 00:16:55
imaginaos que estos elementos que voy a guardar 00:16:58
son de clase alumno. 00:17:00
Los elementos que voy a guardar todos aquí son alumnos. 00:17:01
Pues entonces, un segundinín en la clase alumno. 00:17:04
Si yo quiero usar un hash set, 00:17:08
bueno, dime antes. 00:17:10
¿Un hash qué es? 00:17:12
Una función hash o una tal, 00:17:14
un hash, o sea, un hash como tal, 00:17:17
no sé cómo diría que prefiero con un hash. 00:17:20
Una función de hash es un código hash, 00:17:22
es el código que te devuelve una función de hash. 00:17:24
Una función de hash es una función que te lleva a un código hash. 00:17:26
Una tabla hash es una tabla de códigos 00:17:28
hashes. O sea, hash a secas no se debe 00:17:30
corregir. 00:17:32
Eso es cuando 00:17:36
cualquier objeto o dato 00:17:38
que le pasa 00:17:40
a la función te devuelve un número de 00:17:41
128 carácteres. 00:17:44
Un código hash 00:17:47
es el número que te devuelve una función 00:17:48
de hash. Que se supone que 00:17:50
sirve para esto que estamos diciendo. 00:17:52
para separar en subconjuntos 00:17:54
un conjunto grande. 00:17:58
¿Vale? 00:18:00
Por hasen, 00:18:01
estás entendiendo tú un código, 00:18:02
has el resultado de una función de hasen. 00:18:04
Vale, pues entonces, 00:18:06
ahora, cuando nosotros decidimos 00:18:08
que vamos a guardar, por ejemplo, 00:18:11
un montón de objetos a luz, 00:18:12
y mi aplicación no necesita duplicados, 00:18:15
es decir, no necesito que el mismo alumno 00:18:20
esté en la colección repetido. 00:18:21
Pues si no he ido a duplicados, no necesito llevar 00:18:24
registro de la posición, no puedo olvidar del list. 00:18:26
Entonces imaginaos que he decidido 00:18:28
meter a mis alumnos en un 00:18:30
HACER. Que el HACER es 00:18:32
una de las estructuras 00:18:34
que mejor rendimiento tiene, 00:18:35
óptimas. Entonces un HACER 00:18:37
lo usamos continuamente. Pero repito, 00:18:40
si usamos un HACER, 00:18:42
no puedo yo pretender 00:18:44
meter el mismo objeto dos veces, 00:18:46
porque no va a caer. 00:18:47
¿Por qué podría meter el mismo objeto 00:18:49
y en dos objetos diferentes? 00:18:51
no, a ver, es que 00:18:54
lo de que por dentro está el linked list 00:18:56
eso es como se ha implementado por dentro 00:18:58
pero esto es un conjunto 00:19:00
y el conjunto no lleva 00:19:02
registro de la posición, con lo cual 00:19:03
no te va a permitir 00:19:05
recuperar la posición, lo cual no permite 00:19:07
recuperar la posición, no te deja 00:19:09
meter un objeto igual a otro 00:19:12
que ya está, porque entonces no lo podrías 00:19:13
distinguir en la iteración 00:19:16
pero igual 00:19:17
da igual 00:19:18
no te deja en ningún caso 00:19:21
Pero bajo qué criterio de igualdad 00:19:23
Bajo el criterio que estén iguales 00:19:25
¿Vale? 00:19:27
Bajo el criterio que estén iguales 00:19:29
¿Vale? 00:19:30
Pero si tú decides un haset 00:19:32
Por ejemplo para guardar alumnos 00:19:33
¿Vale? 00:19:35
Pues entonces 00:19:37
Lo que sí o sí vas a tener que hacer 00:19:38
Es implementar la función de hash 00:19:40
¿Vale? 00:19:43
Y para eso 00:19:47
Se implementará el método de hash 00:19:48
Que es este 00:19:51
claro, entonces ahora ya 00:19:52
este método será 00:19:55
el que 00:19:57
cuando lo llame cada objeto alumno 00:19:58
te lleve 00:20:01
aunque repito, esto es más para 00:20:03
luego veremos que en el uso no hay nada de lo que preocuparse 00:20:05
pero bueno, para entender 00:20:07
lo que es 00:20:09
este método que hagamos aquí 00:20:10
será el que cuando 00:20:12
se aplique para un objeto alumno 00:20:15
concreto, un objeto alumno 00:20:16
pues te lleve 00:20:18
a la posición de esta tabla 00:20:20
de códigos hashing 00:20:22
que hay, te lleva a la posición 00:20:24
pero con llevarte a la posición 00:20:25
no lo tienes todo 00:20:28
ahora el hashing 00:20:29
tiene que seguir iterando hasta que lo 00:20:32
encuentra, entonces ahora ya 00:20:34
una vez que está en la posición 00:20:36
tiene que recorrer la lista 00:20:37
hasta que encuentra uno 00:20:39
igual que el que está escribiendo 00:20:42
claro, lo hace automáticamente 00:20:44
pero ahora ya cuando 00:20:46
él ya está recorriendo la lista 00:20:48
como esto es una lista 00:20:50
¿qué necesita 00:20:52
Java, la máquina virtual 00:20:54
para ver si ha encontrado un objeto 00:20:56
dentro de una lista? 00:20:59
el equals, con lo cual 00:21:00
no vale con el hashcode, hay que poner 00:21:02
también el equals 00:21:04
hay que poner los dos 00:21:05
si ahora mismo os doy un ejemplo y veréis que fácil 00:21:07
y que bonito 00:21:12
¿vale? 00:21:13
No, no, no 00:21:15
Vais a dejar de petar súper rápido 00:21:17
Porque esto es 00:21:19
Vale 00:21:20
Si yo quiero meter alumnos en un Haset 00:21:21
Tengo que tener implementado 00:21:26
El Hasco y el Equal 00:21:28
¿Por qué? 00:21:29
No porque los vaya a usar yo 00:21:31
Porque el Haset dentro los va a necesitar 00:21:33
Porque él los va a necesitar 00:21:36
Y él los va a necesitar 00:21:38
Porque yo me voy a limitar a hacer un Add 00:21:40
Vale, yo voy a hacer un Add 00:21:41
Pero es que después de que yo haga un Add 00:21:43
El por dentro va a hacer el hashCode para ver en qué elemento está. 00:21:45
Luego, para ver en qué posición está de la tabla. 00:21:51
Y luego irá recorriendo la lista, ¿vale? 00:21:54
Para ver si hay uno igual a ese o no. 00:21:57
Porque si hay uno igual te va a decir, no, yo no admito duplicados. 00:22:00
¿Vale? 00:22:04
Y para eso va a necesitar el equals. 00:22:04
Luego, estos dos métodos van a tener que estar implementados. 00:22:10
Ahora, antes de ver un ejemplo. 00:22:14
¿Cómo implementamos el equals? 00:22:17
Eso ya lo sabemos. 00:22:19
Implementamos el equals de tal manera que refleje 00:22:21
la igualdad que nos interesa a nosotros, claro, en nuestra aplicación. 00:22:24
Eso lo tenemos clarísimo. 00:22:27
Si mis alumnos son iguales a igualdad de NIR, mi equals se basa en NIR. 00:22:29
Si mis mesas son iguales a igualdad de color, el equals se basa en color. 00:22:32
Eso yo lo implemento reflejando la situación real, claro. 00:22:35
esto, ¿cómo lo implemento? 00:22:40
pero si no sabemos ni lo que es 00:22:43
esto es un tema que me ha pedido 00:22:44
el Haset, pero es que yo no sé 00:22:47
ni de qué va esto, ¿cómo lo implemento? 00:22:49
claro, entonces 00:22:53
normalmente 00:22:53
optamos a lo que él te ofrece 00:22:55
¿vale? pero claro 00:22:57
podríamos implementar a nosotros 00:22:59
si tuviéramos el tino 00:23:00
de decir, a ver, como yo sé la cantidad 00:23:03
de objetos que tengo 00:23:05
para optimizar que no haya subconjuntos 00:23:06
demasiado grandes, demasiado pequeños 00:23:09
lo podríamos dar a mano a vosotros 00:23:11
pero bueno, hay que tener muchísimo control 00:23:12
de todos los objetos que van a acabar llegando 00:23:14
por ejemplo, no podría hacer esto 00:23:17
lo que yo he dicho antes, podría hacer return 1 00:23:19
y esa es una función de hash 00:23:21
perfectamente válida, return 1 00:23:23
pero ¿qué habríamos conseguido? 00:23:24
una tabla hash así, con una única posición 00:23:26
y todos los objetos 00:23:29
colgando en una única lista enlazada 00:23:31
¡qué tontería! 00:23:33
no hemos ganado nada en eficiencia 00:23:34
para eso hacemos un linked list 00:23:36
podríamos hacer un hash code 00:23:38
que me diera un código 00:23:42
único, que me diera la propia clave primaria 00:23:44
el propio NIF 00:23:47
o sea un código entero 00:23:48
claro, pero entonces 00:23:50
ostras, tengo una tabla hash 00:23:52
tan grandota 00:23:55
tan grandota como objetos tengo 00:23:56
pues para eso hago un array 00:23:58
que tontería, para eso hago un array 00:24:00
lo que yo quiero es un compromiso entre ambas cosas 00:24:02
quiero 00:24:04
la flexibilidad de los arrays 00:24:05
a los que accedo rápido 00:24:08
con código 00:24:10
y la ventaja de las listas enlazadas 00:24:11
entonces la forma de mezclar las dos 00:24:14
cosas es el 00:24:16
haset que te da la ventaja 00:24:18
de los arrays porque una vez que has sacado 00:24:20
el código hash 00:24:22
llegas de buenas a primeras 00:24:23
pero claro, un array con todos los elementos 00:24:25
es demasiado, pues un array intermedio 00:24:28
y los que te rebosan 00:24:30
los que te rebosan 00:24:32
en listas enlazadas 00:24:34
es una mezcla de las dos ideas 00:24:35
pero que os gusta 00:24:39
lo disfrutáis o no lo disfrutáis 00:24:45
pero cuando tú le haces generar métodos 00:24:48
que lo generan los mismos criterios 00:24:50
yo creo que tampoco se lo veo 00:24:52
vamos a ver 00:24:57
vamos a hacer un ejemplito 00:24:58
no, si quieres sin ejemplos 00:24:59
claro, pero si vosotros podéis con todo 00:25:04
hombre 00:25:10
examen sorpresa 00:25:11
el viernes, después del recreo 00:25:17
el que si le da un examen en huelga 00:25:18
mira, las legalidades 00:25:23
no las pasamos nosotros 00:25:26
está grabado 00:25:27
vale, bueno 00:25:42
venga 00:25:46
antes ya de empezar ejercicios, ya que lo mezclen 00:25:52
todo, vamos a hacer 00:25:55
un pequeño esto de hashet, que es con el que más 00:25:56
Quizá os habéis... Vale. Venga. A ver, ¿tengo ya algún proyecto que sea ejemplo, colecciones? 00:25:58
Vale, pues a ver, por ejemplo 00:26:16
en nuestro proyecto Ejemplo Colecciones 00:26:32
vamos a hacer 00:26:35
una aplicación 00:26:37
para trabajar con alumnos 00:26:38
es que es la clase más fácil de hacer 00:26:40
pero como tiene notas, que baje el cacharro 00:26:42
y encienda la luz. Bien. 00:26:44
Buen apunte. 00:26:48
Ya, porque igual no se acercan tanto. 00:26:56
Venga. 00:27:06
Bueno, yo tengo aquí un proyecto, Ejemplo Colecciones, 00:27:10
donde el viernes pasado rápidamente 00:27:12
vimos lo de que las listas 00:27:14
parametrizarlos, cómo funciona 00:27:17
el Contents y el RunMove, todavía voy a reutilizar esto 00:27:18
pero vamos, da igual, ya lo subiré 00:27:21
vale, entonces, este main 00:27:22
me da un poco igual, es lo único 00:27:25
que tenía este proyecto, vale 00:27:27
una aplicación que trabaja con alumnos 00:27:28
entonces como son muchos los tengo que meter en algún lado 00:27:30
el array no me gusta 00:27:32
entonces vamos a hacernos nuestra 00:27:33
clase alumno 00:27:36
Sí, pero es que ya lo tengo hecho entero 00:27:38
Y no quiero rellenarlo de basurilla 00:27:43
Porque ese está solo con listas 00:27:45
Esto es solo para ver lo del Hasco, del Equals y poco más 00:27:50
Vale, pues tenemos 00:27:56
Nuestra clase alumno 00:27:57
Nuestra aplicación trabaja con alumnos 00:28:03
Quiere ver 00:28:06
Las notas que tienen 00:28:07
Para suspenderles 00:28:10
Y todo lo que haga falta 00:28:11
Eso no 00:28:14
Ostras 00:28:22
O sea, ahí estás peligroso 00:28:26
Conviene que no te pongamos 00:28:28
Venga, pues nos hacemos nuestro constructor 00:28:30
Y nuestros getty set 00:28:35
Vale, venga 00:28:47
Pero si no he hecho nada todavía 00:28:54
Nif, nombre y nota 00:28:58
Nuestro alumno con Nif, nombre y nota 00:29:00
Venga, pues vamos a jugar con él 00:29:06
Y vamos a putearle un poco aquí 00:29:09
A este alumno 00:29:13
Venga, esto fuera 00:29:13
Vale, pues tenemos ahora 00:29:18
Yo quiero trabajar con un montón de alumnos 00:29:20
Para hacer las medias de sus notas 00:29:23
Todo eso 00:29:24
Claro, mi montón de alumnos 00:29:25
No quiero meter al mismo alumno dos veces 00:29:27
No tengo ninguna necesidad 00:29:33
De meter al mismo alumno dos veces 00:29:35
Con lo cual el registrar la posición 00:29:36
En la que los voy metiendo 00:29:39
No aporta nada a mi aplicación 00:29:39
Podría haber aplicaciones en las que sí aporta 00:29:41
Registrar la posición en la que lo meto 00:29:44
Pero en esta no aporta nada 00:29:45
pues decido que voy a guardarlos en un set 00:29:47
vale 00:29:50
el set es una clase genérica 00:29:50
claro 00:29:54
yo la podría usar así 00:29:55
set alumnos 00:29:57
y ahora cuando la implemento 00:29:58
aquí ya sí que tengo que decidir la implementación 00:30:01
lógicamente, porque set es la clase abstracta 00:30:03
o interfaz 00:30:05
vale, pues voy a decidir un haset 00:30:06
porque me han dicho que es la más 00:30:09
eficiente y la más guay 00:30:11
venga, pues importo set 00:30:12
De Java útil 00:30:15
Y Hachette también 00:30:17
De Java útil 00:30:20
Y yo puedo trabajar 00:30:20
Con el conjunto así a lo bestia 00:30:24
Esa raya amarilla me dice 00:30:27
Jode, que mal hacen las cosas 00:30:29
No, no, no, no 00:30:32
No es eso lo que me está diciendo 00:30:35
Que está sin parametrizar 00:30:36
Vale 00:30:38
Vale, entonces 00:30:40
Tiene el hash que es el de equals 00:30:42
entonces 00:30:43
yo ahora podría trabajar con alumnos 00:30:47
y decir, venga pues me voy a hacer un nuevo alumno 00:30:50
venga pues 00:30:52
hala 00:30:55
add new 00:30:56
alumno 00:30:59
pues nada, nif1 00:31:01
nombre 00:31:04
alumno1 00:31:06
y nota1 00:31:09
vale 00:31:11
y me deja meter el alumno en la colección 00:31:12
perfectamente 00:31:15
pero claro, yo estoy en otro punto 00:31:15
de la aplicación 00:31:19
tengo otra clase alumno 00:31:22
y ya no sé lo que estoy haciendo 00:31:24
y con esta colección alumnos 00:31:26
pues estoy metiendo de repente 00:31:28
ah vale, pues voy a meter en mis alumnos 00:31:30
un alumno que se llame Pepito 00:31:32
¿por qué no? voy a meter a uno que se llame Pepito 00:31:34
yo quiero meter a uno que se llame Pepito 00:31:37
claro, me deja 00:31:38
meter lo que me dé a mí la gana 00:31:40
como si quiero meter ahí 00:31:42
lo que sea 00:31:44
claro, entonces 00:31:47
este no es el uso adecuado 00:31:48
y profesional de los set 00:31:51
¿por qué? porque yo no me pongo a iterar 00:31:52
a veces saco un objeto alumno, a veces saco 00:31:54
un string, a veces saco un número 00:31:57
como lo casteo, no tengo ni idea 00:31:58
como me hago instance of de todos los tipos 00:32:00
de universo, un desastre 00:32:02
entonces, pues no es la forma de usarlo 00:32:04
¿cuál es la forma 00:32:07
de usar las clases que son genéricas? 00:32:09
porque set 00:32:11
si la abrimos 00:32:12
vemos que efectivamente 00:32:14
es genérica 00:32:17
en lugar de T lo han llamado E 00:32:18
pues SET 00:32:21
te dice 00:32:23
espérate, dime el tipo 00:32:24
de dato que te interesa para este 00:32:27
conjunto en concreto, dímelo 00:32:29
veis que hereda de colección, con lo cual colección 00:32:30
es clase, no es interfaz 00:32:33
vale 00:32:34
y SET es interfaz, me lo afirmas 00:32:35
vale 00:32:38
bueno pues vamos a 00:32:39
oye si yo quiero alumnos 00:32:43
ojo voy a darle 00:32:44
ya el valor al parámetro 00:32:46
alumno 00:32:49
vale 00:32:49
entonces aquí podéis poner alumno 00:32:51
podéis no ponerlo, da igual, con que pongáis las dos 00:32:54
cositas ya se queda claro 00:32:56
da igual, en este caso 00:32:58
da igual, aquí es donde sí que hay que ponerlo 00:33:00
vale, y de nuevo 00:33:02
aquí podríais poner haset también 00:33:04
da igual, da lo mismo 00:33:06
porque como haset hereda 00:33:09
a ver, la única diferencia es que si luego yo quiero usar 00:33:12
la referencia con un tricep 00:33:14
pues no, vale 00:33:16
pero bueno, yo tengo la manía 00:33:17
de la superclase 00:33:20
hacerla siempre lo más 00:33:21
arriba de la jerarquía posible para dejarla abierta 00:33:23
que a veces me paso 00:33:26
porque luego me faltan métodos 00:33:28
entonces tengo que hacer un casting que tampoco mola 00:33:30
pero bueno, tengo esa manía de 00:33:31
las colecciones, instanciarlas como la superclase 00:33:33
perdón, declararlas 00:33:37
como la superclase y luego instanciarlas 00:33:38
como ya quieran, vale 00:33:40
ahora ya como ya le he dado el parámetro 00:33:41
lógicamente esta ya me dice 00:33:44
no puedes meter un stream 00:33:47
luego bien 00:33:50
primera el compilador 00:33:51
ya nos está protegiendo 00:33:55
de hacer alguna burrada 00:33:56
nos está protegiendo 00:33:57
vamos a meter 00:33:58
otro alumno 00:34:01
el mismito 00:34:03
el mismito 00:34:08
alumnos, add, el mismo 00:34:10
su unif es uno, se llama alumno uno y su nota es uno 00:34:12
el mismito 00:34:15
y ahora voy a iterar por la colección 00:34:15
a ver que tengo 00:34:19
vale, ahora ya 00:34:20
vamos a iterar 00:34:23
por una colección, iterar que es 00:34:24
recorrerla y ver que hay en cada 00:34:26
posición, vale 00:34:29
entonces, como podemos 00:34:30
iterar por una colección 00:34:37
de muchas maneras 00:34:38
si, de muchas maneras distintas 00:34:40
la más simple 00:34:42
es el for each 00:34:45
la más simple, que lo usábamos también para los arrays 00:34:47
la más simple es esta 00:34:49
que es 00:34:51
para cada tipo de dato mío en el set 00:34:53
que es alumno 00:34:55
dentro 00:34:56
de mi set de alumnos 00:34:59
si hubiera muchos tipos de datos 00:35:01
como lo hubieras hecho al principio 00:35:02
tendría que poner object 00:35:04
solo me dejaría poner ahí object 00:35:07
si no lo hubiera parametrizado 00:35:08
aquí iría object 00:35:10
porque como en la colección cae cualquier 00:35:12
object, es decir, no parametrizar 00:35:15
sería idéntico 00:35:17
hacer esto 00:35:19
hacer esto 00:35:20
y no poner nada es la misma cosa 00:35:22
es lo mismo, porque object es la superclase 00:35:25
que es cualquier cosa, cualquiera 00:35:27
es object, cualquiera 00:35:29
¿vale? 00:35:30
object sí 00:35:35
bueno, te lo he dicho 00:35:36
muy rápido 00:35:39
no sé si object 00:35:40
no, yo creo que 00:35:42
no lo sé, a ver 00:35:45
creo que puedes instanciar 00:35:46
un objeto, aunque es un objeto 00:35:49
que no va a tener nada dentro 00:35:50
lo que pasa es que abrir objetos tarda un montón 00:35:52
es un rollo 00:35:54
es más fácil buscar la mano 00:35:56
pero bueno, me voy a parar 00:35:58
ya está 00:36:01
voy a pararlo también 00:36:02
ah, pues mira, ya me había salido 00:36:03
bueno, no lo sé 00:36:07
míralo por curiosidad 00:36:09
vale, pero en nuestro caso 00:36:10
no queremos instanciar object 00:36:13
sino alumno 00:36:15
vamos a iterar 00:36:16
esta es la forma más sencilla de iterar 00:36:18
con un for each 00:36:21
voy a ver cada alumno 00:36:23
al que llamo a de esa colección 00:36:25
vamos a ponerle 00:36:27
un toString a 00:36:31
alumno, vamos a ponerle 00:36:33
un toString, vale, para que 00:36:36
así el sistema println me muestre 00:36:38
todo el objeto y no me muestre ese código extraño 00:36:39
que tiene el toString de object. 00:36:42
¿Vale? Para poder 00:36:45
metérselo al System.out, vamos a ponerle un toString. 00:36:46
Venga. 00:36:49
¡Hala! Ya tengo un toString 00:36:55
de object y cada vez que le pase 00:36:57
al System.out del object me va a sacar alumno 00:36:58
con nip, nombre, no sé qué. 00:37:01
Venga, pues vamos a iterar. 00:37:03
Por este set que acabo de hacer. 00:37:04
Pues se han metido los dos. 00:37:11
Claro, 00:37:14
porque para él no son duplicados. 00:37:15
Para él son objetos distintos. 00:37:17
¿por qué? son objetos distintos 00:37:18
porque como en alumno 00:37:21
no hay hasco de equals 00:37:23
él tira 00:37:25
del hasco de equals de object 00:37:27
y ese se genera 00:37:29
en base a la dirección de memoria 00:37:31
con lo cual para el set 00:37:33
este y este 00:37:36
son distintos porque su dirección de memoria 00:37:37
es distinta 00:37:39
pero claro, este no es el uso que yo le quiero dar 00:37:40
claro, yo no quiero 00:37:43
darle, la aplicación tiene que tener un sentido 00:37:45
real, tiene que tener una coherencia, tiene que tener una semántica 00:37:47
que signifique algo 00:37:50
no tiene que ser un absurdo 00:37:51
vale, pues entonces 00:37:53
ahora ya en el 00:37:55
sour le decimos, oye, generame el jasco 00:38:00
de equals 00:38:02
vale 00:38:02
¿cuál es el parámetro clave primaria 00:38:04
para ti? 00:38:08
en nuestro caso, lo que decidamos 00:38:09
si decidimos que nif, que dos alumnos 00:38:11
a igualdad de nif son iguales 00:38:14
pues nif, que es lo que decidiríamos 00:38:15
obviamente 00:38:18
porque a menos que seamos Brian 00:38:19
no duplicamos las documentaciones 00:38:21
personales de la gente 00:38:23
¿verdad? 00:38:24
bueno, o sea que habrá algunos cuantos 00:38:28
que lo habréis hecho seguro 00:38:29
para meteros vuestras litronas con 17 00:38:30
supongo 00:38:33
bueno, tú porque 00:38:34
pero aquí debe haber 00:38:37
mucho bandarra mimetizado 00:38:39
sí, la verdad 00:38:41
no bebo, no fumo 00:38:43
solo como 00:38:47
pues 00:38:48
esa es la mejor elección 00:38:51
eso es lo que hay que hacer, no fumar, no beber 00:38:54
y comer, claro que sí 00:38:55
enhorabuena 00:38:57
porque no sabrá 00:38:59
que coman, pero además de comer 00:39:01
fuman y beban, y eso ya 00:39:03
venga 00:39:05
vale, pues me ha hecho el jasco de equals 00:39:07
del equals 00:39:10
Delicuas no tenemos nada que aportar 00:39:12
Silencio 00:39:17
Que os estáis poniendo nerviositos 00:39:21
Ana, que te estás alterando 00:39:22
Te estás alterando 00:39:27
Ay, que finas sos 00:39:28
Venga 00:39:32
¿Eh? 00:39:37
Claro 00:39:40
No sois nada delicadas 00:39:40
bueno, a ver 00:39:42
ya hemos respirado 00:39:46
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:
15
Fecha:
4 de febrero de 2025 - 17:22
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
39′ 51″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
1005.13 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid