Saltar navegación

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

Clase 08-03-24 - 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 10 de marzo de 2024 por Raquel G.

16 visualizaciones

Más información Transcripción

Descargar la transcripción

vale, que hace que sea más fácil de gestionar 00:00:03
porque no hay que llevar a cuenta 00:00:05
la posición en la que está cada elemento 00:00:07
bueno, pues dentro de la jerarquía 00:00:09
set sigue siendo otra interfaz 00:00:11
otra interfaz que lo que dice 00:00:13
es los métodos que tienen que tener los conjuntos 00:00:15
vale 00:00:17
set conjunto, ya sabéis que es lo mismo, claro 00:00:19
es la traducción 00:00:21
entonces, cualquier cosa 00:00:22
que sea conjunto 00:00:26
cualquier cosa que sea conjunto, como esta variable 00:00:27
de aquí nombres 00:00:30
cualquier cosa que sea conjunto 00:00:31
como esta variable de aquí nombres 00:00:46
tiene que ofrecer una implementación 00:00:48
para estos métodos 00:00:51
añadir a un conjunto 00:00:52
añadir un montón de elementos a la vez 00:00:55
que a su vez están en una colección 00:00:57
limpiar el conjunto enterito de elementos 00:00:59
no dejarlo a nul 00:01:02
simplemente dejarlo sin elementos 00:01:03
ver si en un conjunto está 00:01:05
un objeto igual 00:01:09
al que yo le paso por parámetro 00:01:11
ver si en un conjunto 00:01:13
están 00:01:16
todos los, hay elementos 00:01:16
iguales a todos estos 00:01:20
que yo le paso una colección por parámetro 00:01:22
entonces como veis 00:01:24
cualquier cosa que sea conjunto 00:01:26
los métodos que tiene que implementar 00:01:28
son mucho menos que los de las listas 00:01:30
cualquier cosa que sea lista tiene que implementar 00:01:32
pues el adfers, el atlas 00:01:34
el get 00:01:36
por posición, muchas más cosas, cualquier cosa que sea conjunto 00:01:37
tiene que implementar 00:01:40
muchas menos, veis aquí hay muy poquitos 00:01:42
métodos en realidad 00:01:44
¿vale? en realidad 00:01:45
tiene añadir, limpiarlo 00:01:48
ver si contiene un objeto o no 00:01:50
lo contiene, no hay un get 00:01:52
por posición, efectivamente, un iterador 00:01:54
para iterar por él, un iterador 00:01:56
para iterar 00:01:58
borrar un objeto 00:01:59
que pasamos por parámetro 00:02:02
en ese conjunto, si se le pasa 00:02:04
ese objeto por parámetro, se borrará 00:02:06
aquel igual 00:02:08
el primero que se encuentre igual a él 00:02:11
¿vale? ante las dudas 00:02:14
siempre uno puede mirar la documentación 00:02:16
del método, bien en oracle 00:02:18
o bien esta que es la misma 00:02:19
o bien esta que es la misma 00:02:22
¿vale? 00:02:23
aquí te dice borra el elemento 00:02:26
de este conjunto si está presente 00:02:28
entonces aquí 00:02:30
yo he dicho borra la 00:02:32
primera aparición 00:02:34
de un 00:02:35
objeto igual a este 00:02:37
igual a este 00:02:40
dentro del conjunto 00:02:42
¿vale? 00:02:44
ese método remove ya lo vimos con las listas 00:02:46
si queríamos que borrara todos los que fueran 00:02:47
iguales, no solo el primero, ¿qué poníamos? 00:02:50
delante 00:02:52
¿eh? 00:02:53
vale, ese método remove que ya lo hemos visto en listas 00:02:57
¿verdad? 00:03:00
este método, tú le pasabas un objeto 00:03:01
y dentro de la colección 00:03:03
que llamaba el método, en este caso el conjunto 00:03:06
pues borra el elemento 00:03:08
que encuentra igual a este 00:03:10
eso hacía el remove 00:03:12
¿vale? pero solamente 00:03:13
borraba el primero que encontraba 00:03:16
igual a ese, entonces si queríamos 00:03:18
que borrara todos los que había iguales 00:03:20
a ese, le poníamos un while 00:03:22
porque como este devuelve boolean diciéndote si ha borrado 00:03:24
de forma efectiva o no ha borrado 00:03:26
si notemos esto en un while 00:03:28
pues volverá a hacer otro remove, otro remove 00:03:30
es este que no encuentro en ningún 00:03:32
¿vale? pues aquí funcionará igual 00:03:33
como que si no puede 00:03:36
funcionar igual, es una burrada lo que he dicho 00:03:42
esto es un conjunto 00:03:44
no puede haber dos elementos iguales 00:03:45
es imposible 00:03:48
entonces, el remove 00:03:49
en caso de existir un objeto igual a este 00:03:51
es que solo va a existir uno 00:03:54
no puede existir dos iguales a este 00:03:55
en las listas sí, aquí no 00:03:58
por eso 00:04:00
si uno mira la ayuda del remove de conjunto 00:04:02
no te dice 00:04:04
borra la primera ocurrencia de este 00:04:05
en las listas si que te decía 00:04:08
borra la primera ocurrencia 00:04:10
de un objeto cuyo equals 00:04:11
da true 00:04:14
aquí no te dice la primera ocurrencia porque 00:04:15
un objeto solo puede estar 00:04:18
una vez en un conjunto 00:04:20
entonces aquí no tendría sentido 00:04:21
poner el while porque 00:04:24
solo puede haber un objeto 00:04:26
igual a este 00:04:28
luego pues seguimos 00:04:29
cualquier implementación de set 00:04:32
tiene que implementar pues remove all 00:04:34
que este borra todos los que sean iguales 00:04:36
a todos los de la colección 00:04:38
que tú le pases 00:04:40
¿vale? bueno, esto remueve, borra 00:04:41
los que cumplen una condición 00:04:44
o sea, puesta en forma de predicado 00:04:46
pero los predicados pues 00:04:48
no sabemos hacerlos, entonces nos podemos olvidar 00:04:50
¿vale? el tamaño de la colección 00:04:52
este es para 00:04:54
generar otro tipo de iterador 00:04:56
otro tipo de iterador distinto 00:04:58
con una forma distinta que podemos pasar de él 00:05:00
bueno, pues poquitos métodos 00:05:02
para convertir en un array 00:05:04
¿vale? cualquier colección 00:05:05
tiene también este método 00:05:07
para convertir 00:05:08
esa colección en 00:05:11
un array, por si uno prefiere 00:05:13
trabajar con esos elementos en un array 00:05:15
pues tenemos esto, bueno pues aquí 00:05:17
hay muchos menos métodos en set 00:05:19
que en list 00:05:21
muchos menos 00:05:23
cuando tenemos sin embargo una lista de lo que sea 00:05:24
aquí hay muchos 00:05:27
más métodos, un montón más 00:05:38
hay un montón más que en set 00:05:40
¿vale? 00:05:42
Bueno, ¿qué quiero decir con esto? 00:05:42
Que las implementaciones de la interfaz set son más sencillas 00:05:46
Y más eficientes computacionalmente 00:05:50
Tienen que hacer menos cosas, no gestionan las posiciones 00:05:53
Pero si necesitamos elementos duplicados, pues no nos valen 00:05:56
Pero si no lo necesitamos, son las mejores 00:05:59
Bueno, pues ahora ya sí 00:06:00
¿Qué implementaciones de hash set tenemos? 00:06:02
Pues tenemos estas tres 00:06:08
que vimos aquí 00:06:11
bueno, no merece la pena 00:06:14
que conecte internet para ver otra vez 00:06:16
jerarquía 00:06:20
vale, entonces 00:06:22
esta, esta 00:06:36
y esta 00:06:42
esto ya sí que son tres clases 00:06:48
ya hechas, ya no son clases abstractas 00:06:51
ni interfaces, ni nada 00:06:53
esto ya sí que son tres implementaciones de set 00:06:54
que implementan 00:06:57
esos métodos cada uno a su manera 00:06:58
bueno, pues vamos a ver un poquito 00:07:01
por encima 00:07:05
cómo funcionan 00:07:06
en que se basan para usarlas correctamente 00:07:09
pero luego el uso de todas las colecciones 00:07:11
en última instancia siempre viene a ser el mismo 00:07:13
como ya sabéis 00:07:15
insertar, borrar un elemento que sea igual a otro 00:07:16
recorrer 00:07:20
de eso se trata, de insertar elementos 00:07:21
de recorrer, de borrar elementos 00:07:24
ya está, de eso se trata, nada más 00:07:26
bueno, pues aquí por ejemplo 00:07:28
ya el otro día 00:07:36
probamos el hash set 00:07:37
pero vamos, lo probamos 00:07:40
pues nada, para usar una colección 00:07:42
para meter cadenas 00:07:44
entonces, como es de cadenas 00:07:45
pues decimos, oye 00:07:49
la parametrizo a que sea cadenas 00:07:50
igual que hacíamos con las listas 00:07:54
recordad que no es obligatorio 00:07:56
indicar 00:07:58
el tipo de dato que va a ir en una colección 00:08:00
no es obligatorio, las clases genéricas 00:08:04
no te obligan 00:08:06
a que tú digas en el momento de 00:08:08
instanciarlas qué tipo de dato vas a meter 00:08:10
no te obligan, tú puedes dejarla 00:08:12
abierta 00:08:14
si la dejas abierta, ¿qué significa? 00:08:14
que puedes meter lo que te dé la gana 00:08:18
cualquier cosa que sea object 00:08:20
sería como hacer esto 00:08:22
si tú la dejas abierta, sería como 00:08:23
hacer esto de aquí 00:08:26
y en object ¿qué cae? en object cae cualquier 00:08:27
dato, en object cae cualquier 00:08:32
cosa, sería como hacer esto 00:08:33
vale 00:08:35
entonces hombre 00:08:37
a la hora de programar es magnífico 00:08:38
porque no te va a salir ningún error 00:08:41
de compilación 00:08:43
yo le meto una cadena, hola, estupendo 00:08:44
pero le voy a meter un numerito 00:08:47
genial, también coge el numerito 00:08:48
y ahora le voy a meter 00:08:51
un objeto 00:08:53
alumno que tengo por ahí 00:08:55
por ejemplo, este en que proyecto estábamos 00:08:57
estructuras dinámicas 00:09:00
a ver si tiene alguna clase por ahí 00:09:01
Pues eso, imaginaos que yo tengo aquí 00:09:03
Aquí tengo en el main 00:09:15
Tengo este objeto cliente 00:09:23
¿Qué ahora le quiero meter un objeto cliente? 00:09:24
A esta colección 00:09:27
Vale, cliente, tenía constructor 00:09:28
Sin parámetros, no 00:09:42
Le voy a poner un constructor sin parámetros 00:09:43
Para que 00:09:46
Para que 00:09:46
Me deje instanciarlo así 00:09:51
Sin más, vale 00:09:54
Entonces, pues eso 00:10:05
¿Qué ahora le meto un objeto cliente? 00:10:07
o le meto un objeto cliente 00:10:08
esto ocurre con una colección si yo no decido 00:10:10
el tipo de dato aquí, que puedo hacerlo 00:10:12
si yo no lo decido, entonces le puedo meter 00:10:14
cualquier cosa que sea object 00:10:16
y cualquier objeto en Java 00:10:17
es object, porque cualquier clase 00:10:20
hereda de object, como ya sabéis 00:10:22
entonces, claro, a la hora de 00:10:24
desarrollar esto 00:10:26
en el momento en el que estás escribiendo 00:10:28
el código, en el momento de escribirlo 00:10:30
es que no te sale ningún error de compilación 00:10:32
no te sale ninguno, si en este set 00:10:34
cabe cualquier cosa 00:10:36
y si fuera una lista lo mismo 00:10:37
claro, me da igual, como si esto es una lista 00:10:40
cualquier tipo de colección 00:10:41
y yo decido no darle el parámetro 00:10:43
como si es una lista 00:10:48
yo decido en ese momento no comprometer 00:10:53
el tipo de dato, pues cabe cualquier cosa 00:10:55
pero claro 00:10:57
que no salgan errores de compilación 00:10:58
aquí 00:11:01
luego seguramente se traduzca 00:11:01
en que a la hora de ejecutarse las cosas 00:11:05
aquí empiezo a cascar 00:11:07
porque en esta colección hay de todo 00:11:08
hay una cadena, luego hay un número 00:11:10
Luego hay un cliente 00:11:12
¿Y qué pasa cuando yo itere por aquí? 00:11:13
Imaginaos que yo ahora itero por la colección 00:11:16
Tendría que iterar de esta manera 00:11:18
Para cada cosa que sea object 00:11:23
Porque es que yo no sé 00:11:30
Qué es cada cosa de la colección 00:11:32
No tengo ni idea 00:11:33
Puede ser de lo que sea 00:11:34
Solo sé que es object 00:11:36
Pues tendríamos que iterar por la colección así 00:11:37
¿Y ahora con este objeto yo qué hago? 00:11:39
A saber, tendría que empezar 00:11:42
Con los get instance 00:11:44
Viendo a ver qué es 00:11:45
Con el instance of, perdón 00:11:46
no os olvidéis del instansoft ni de nada de lo que hemos visto 00:11:49
claro, si instansoft.do 00:11:51
es un cliente hago no sé qué, si es un 00:11:53
string hago no sé cuánto, o sea esto se convierte en una 00:11:55
locura, por eso no es recomendable 00:11:57
usar una lista 00:12:00
sin parametrizar, porque entonces cuando la recorramos 00:12:00
lo que hay aquí 00:12:03
está declarado como object 00:12:05
yo tengo que hacerle un casting 00:12:07
cuando le haga el casting vete a saber 00:12:09
si ha acertado o no ha acertado 00:12:11
porque este en la primera iteración 00:12:13
es un string, pero en la siguiente es un número 00:12:15
el día siguiente es un cliente, entonces vete a saber 00:12:17
con ese casting si luego un tiempo de ejecución 00:12:19
me peta porque me dice, pero ¿qué estás 00:12:21
convirtiendo a qué? 00:12:23
entonces, aunque se pueden usar las colecciones 00:12:25
sin comprometer ahí el tipo de datos y meter 00:12:27
object, pues esto 00:12:29
no es recomendable 00:12:31
a menos que tenga uno muy controlado lo que va ahí 00:12:33
y por eso es por lo que nos salen los 00:12:35
avisos en amarillo, el aviso en amarillo 00:12:37
no es un error de compilación, como ya sabéis 00:12:39
me dice, cuidado 00:12:41
hay un cuidado 00:12:43
que 00:12:44
deberías, de hecho te dice 00:12:46
deberías parametrizarlo, te lo dice 00:12:49
te lo recomienda, deberías parametrizarlo 00:12:51
porque si no ahí cabe cualquier cosa 00:12:53
que sea object, y luego tú ya 00:12:55
vete a saber lo que es eso, como hagas 00:12:57
casting, vale 00:12:59
entonces no es este el uso habitual 00:13:01
entonces 00:13:03
vale 00:13:05
entonces si yo ya 00:13:14
he analizado bien la aplicación, la tengo ya bien 00:13:15
analizada y diseñada 00:13:18
pues entonces ya he visto, oye esta colección 00:13:19
va a tener solamente alumnos 00:13:22
pues la parametricio de alumnos 00:13:24
esta colección va a tener solo cadenas 00:13:25
pues la parametricio de cadenas 00:13:27
si voy a tener alumnos y cadenas en mi aplicación 00:13:28
pues me hago dos colecciones distintas 00:13:31
como para los alumnos y dos para las cadenas 00:13:33
no mezclo, aunque pueda no mezclo 00:13:34
porque se nos va a complicar muchísimo el programa 00:13:37
bueno pues en este caso 00:13:40
que 00:13:41
hicimos como una primera prueba 00:13:43
de headset 00:13:45
pues decidimos que no van a ser cadenas 00:13:46
pues le pongo string y aquí no se me olvida 00:13:49
también ponerle los corchetillos 00:13:51
si no se los pongo me va a seguir dando ahí el aviso 00:13:53
vale 00:13:55
entonces 00:13:57
se los pongo 00:13:59
más que nada para que se me quite el aviso ese 00:14:01
en amarillo ahí 00:14:03
vale 00:14:04
y ahora en cuanto hemos decidido que esto sea 00:14:06
string, cuando hemos decidido que esto sea string 00:14:09
pues automáticamente el compilador 00:14:11
dice, ah lo siento solamente puedes 00:14:14
meter un string, no puedes meter un numerito 00:14:15
ni puedes meter un cliente, ni puedes meter nada 00:14:18
que no sea un string 00:14:20
vale 00:14:20
bueno pues 00:14:22
siempre y cuando metamos cosas 00:14:24
que sean stream 00:14:27
pues ya está, yo las meto 00:14:29
y lo que estuvimos haciendo 00:14:30
pues fue recorrer esta colección 00:14:32
aquí para 00:14:35
mostrarlos y no hicimos más 00:14:37
el otro día de conjuntos 00:14:38
vale 00:14:40
bueno vamos a ver un pelín más 00:14:41
pero solo muy por encima 00:14:44
sobre que conceptos teóricos 00:14:46
están basados, sobre qué conceptos libres están basados 00:14:49
y luego ya las implicaciones 00:14:51
prácticas de su uso 00:14:53
que tienen alguna que hay que conocer 00:14:55
para usarlas correctamente 00:14:57
vale, entonces 00:14:58
pues vamos a empezar 00:15:00
con el headset, vale, vamos a empezar 00:15:03
con el headset, para lo cual 00:15:05
me vendría muy bien un 00:15:06
vale, pues ya está 00:15:08
bueno, a ver, pues entonces, la primera que decimos 00:15:11
tampoco es que pinte mucho 00:15:29
pero bueno, mira que me lo había imaginado 00:15:33
cuando me lo habían dicho 00:15:34
cuando me lo habían dado que este no iba a pintar 00:15:35
vale, el hashed 00:15:37
el hashed 00:15:40
está relacionado 00:15:42
con el concepto de 00:15:43
tabla hash, vale 00:15:45
voy a coger el otro, perdonadme 00:15:47
porque con este no hacemos nada 00:15:53
vale, ahora sí 00:15:55
este es mucho mejor 00:15:57
¿Vale? Pues la implementación 00:16:12
de este 00:16:20
A ver, no sé si se va a ver escrito al revés 00:16:21
pero bueno, da igual en la cámara 00:16:27
La implementación del haset 00:16:29
este entonces está basado en 00:16:33
el concepto de tabla hash 00:16:36
que es una idea 00:16:40
con la que se trabaja en informática 00:16:44
de toda la vida, bueno, en otros ámbitos también 00:16:46
que en realidad no es nada, que es 00:16:48
yo tengo un conjunto de cosas 00:16:50
que pueden ser 00:16:52
de más o menos complejidad 00:16:55
cada una de ellas, vete a saber lo que puede ser cada una 00:16:56
de ellas, desde un objeto 00:16:58
como es en nuestro caso, a cualquier otro 00:17:00
concepto, en función de donde esté yo 00:17:02
trabajando, bueno, pues una 00:17:04
función de hash 00:17:06
una función a la que tú le pasas 00:17:09
uno de estos elementos 00:17:15
y te la transforma 00:17:17
en un número entero 00:17:18
simplemente 00:17:20
la función de hash 00:17:23
te transforma los elementos 00:17:26
a los que está aplicado 00:17:29
en un número entero 00:17:30
entonces la idea de fondo de esta transformación 00:17:32
es poder 00:17:35
trabajar de forma más fácil 00:17:36
con esta colección de números 00:17:38
que con los objetos en sí, no para todas las tareas 00:17:41
solo para algunas, claro, porque la tabla hash 00:17:46
de cada elemento solo tiene un número asociado 00:17:50
pero para tareas del tipo de distinguir si son iguales, ver proximidades 00:17:53
hacer agrupaciones, pues a través del numerito asociado 00:17:58
se pueden ya hacer cosas, se pueden hacer funciones solamente con ese numerito asociado 00:18:02
sin que haga falta el resto 00:18:06
de la información del objeto 00:18:10
y a veces también en función de cómo esta 00:18:11
función de hash esté hecha 00:18:14
en función de cómo esté hecha 00:18:16
este numerito entero también puede dar información 00:18:18
de cosas de dentro del objeto 00:18:20
tiene aplicaciones en seguridad 00:18:23
en cosas 00:18:24
entonces una función de hash es simplemente una función 00:18:25
que coge elementos 00:18:28
de un sistema y los transforma en un número entero 00:18:30
porque si yo tengo 00:18:32
esos elementos convertidos en números enteros 00:18:33
hay cosas que las puedo hacer más fácil 00:18:36
más fácilmente 00:18:37
entonces 00:18:38
¿cómo es la función de hash? 00:18:41
como a uno le dé la gana 00:18:43
cualquier función que transforma 00:18:44
un elemento en número entero ya es una función 00:18:47
de hash 00:18:49
incluso una función que lo que hace es 00:18:49
cualquier elemento 00:18:52
lo transforma en el 00:18:54
número 1 00:18:57
también es una función de hash, es decir 00:18:57
no todas las funciones de hash tienen que transformar 00:19:00
los elementos en números distintos 00:19:02
no tienen por qué, lo pueden transformar en el 00:19:04
mismo, a lo mejor estos dos van al 3 00:19:07
este va al 5 00:19:09
vamos, que la función de hash se puede 00:19:10
hacer como a uno le dé la gana 00:19:13
pero claro, la tendría que hacer 00:19:14
adaptada a qué 00:19:17
espera, qué quiere hacer con esos 00:19:18
numeritos, ¿vale? 00:19:20
entonces muchas veces la función de hash 00:19:23
se usa para cosas de dispersión 00:19:24
para facilitar separar los elementos 00:19:26
entonces son elementos que si tú los tratas 00:19:28
así, es más confuso tratarlos 00:19:31
pero si tú les aplicas una 00:19:33
función de hash que los dispersa 00:19:35
a números muy separados 00:19:36
pues computacionalmente igual es más fácil 00:19:38
manejarlo, entonces a veces es una especie 00:19:41
de función de dispersión 00:19:43
para muchas cosas se usa, depende 00:19:44
de la aplicación, para un montón de cosas 00:19:47
se usa, ¿vale? pero es simplemente eso 00:19:49
bueno 00:19:51
pues el hash set 00:19:53
utiliza internamente una tabla hash 00:19:54
para cada objeto 00:19:57
de la colección le hace corresponder 00:19:59
un numerito 00:20:01
le hace corresponder un número entero 00:20:01
y cuando tiene que trabajar dentro 00:20:04
para ver si dos elementos son iguales 00:20:07
si un elemento está, que son cosas 00:20:09
que el hash set tiene que hacer todo el rato 00:20:11
cuando hacemos un add 00:20:13
de un elemento cualquiera a la colección 00:20:15
o cuando hacemos un remove 00:20:17
pues el hash set tiene que mirar 00:20:20
si este elemento está o no está 00:20:23
para hacer el add o no hacerlo 00:20:25
cuando hacemos un remove tiene que mirar 00:20:27
si este elemento está o no está 00:20:29
para eliminarlo o no 00:20:30
entonces 00:20:32
le va a ser más rápido 00:20:33
ver si un elemento está o no está en la tabla hash 00:20:35
a través del código hash 00:20:38
que a través del propio elemento 00:20:40
porque se hace 00:20:41
aplica la función de hash a este 00:20:43
y dice, a ver 00:20:46
este se corresponde con el 3 00:20:48
ah, pues sí 00:20:49
el elemento que se corresponde con el 3 lo tengo 00:20:50
entonces 00:20:54
lo borro 00:20:55
entonces si tiene una especie de asociación de números 00:20:56
a los elementos 00:21:00
la gestión de algunas cosas 00:21:01
va a ser muy rápida 00:21:03
bueno, pues eso es lo que se basa 00:21:04
de fondo, esto 00:21:07
y ya está, el haset 00:21:08
en los elementos que están en el conjunto 00:21:10
que son estos 00:21:13
les asocia un numerito 00:21:14
y algunas de las cosas 00:21:16
de gestión interna suya 00:21:18
las hace directamente sobre los numeritos 00:21:20
porque va a ser mucho más rápido en un array de números 00:21:23
que directamente 00:21:25
navegar por los objetos 00:21:27
que va a ser mucho más rápido trabajar en un array de números 00:21:28
esa es la idea 00:21:31
de cómo funciona por dentro 00:21:34
y de hecho 00:21:35
es la colección 00:21:37
prácticamente la más 00:21:40
rápida que hay 00:21:42
la más rápida 00:21:43
y la más eficiente 00:21:45
entonces si uno tiene que hacer una colección de cosas 00:21:47
y la posición no le importa 00:21:50
y no necesita 00:21:52
que se repitan elementos 00:21:53
pues directamente ni se lo piensa 00:21:55
hace un hashet y ya está 00:21:57
que es la más eficiente 00:21:59
por estar hecha por dentro 00:22:01
con una tabla hash, la más eficiente 00:22:03
vale 00:22:04
bueno, pues entonces, más cosas 00:22:06
internamente 00:22:09
el hash set, como he dicho, lo que lleva 00:22:13
es los códigos hash de cada elemento 00:22:15
a un array de numeritos 00:22:17
y trabaja con ese array para algunas cosas 00:22:18
que es muy rápido y muy eficiente 00:22:20
pero claro, los arrays 00:22:21
vale, están muy bien 00:22:24
hasta cierto punto, cuando el array 00:22:26
ya empieza a ser muy grandote 00:22:29
es decir, si yo tuviera un set 00:22:30
un hash set de muchas cosas 00:22:32
el array de códigos hash 00:22:34
empezaría a ser ya muy grande 00:22:36
entonces ya no sería tan eficiente ese hash set 00:22:38
porque los arrays son muy engorrosos 00:22:41
también para 00:22:43
si yo tengo que insertar 00:22:44
uno nuevo, ya sabéis que un array 00:22:46
tengo que hacer otro, y copiar y pegar 00:22:48
entonces si tengo 10.000 00:22:50
y quiero insertar el 10.001, tengo que hacer 00:22:52
un array de 10.001 y copiar 00:22:54
10.000 en ese 00:22:56
entonces, llegados a cierto tamaño 00:22:57
de Arrays, pues esto ya 00:23:00
tener un Array de números tampoco es tan bueno 00:23:02
entonces el hash es lo que hace 00:23:04
es una especie de 00:23:06
intermedio 00:23:07
y se hace una tablita 00:23:09
de un tamaño razonable 00:23:11
de un tamaño razonable 00:23:14
y ahí es donde va a llevar los códigos 00:23:16
hash de los elementos que se van metiendo 00:23:20
¿vale? y entonces 00:23:22
¿qué pasa? 00:23:29
cuando yo meta 00:23:31
silencio por favor 00:23:33
cuando yo meta uno más 00:23:34
y ya no quepa aquí en mi tabla 00:23:36
¿qué hace? 00:23:39
pues lo que hace es empezar a colgarlos 00:23:41
en una lista enlazada desde aquí 00:23:43
luego el hashed lo que tiene 00:23:44
dentro en realidad es esto 00:23:47
tiene una array 00:23:48
una array donde tiene 00:23:58
unos cuantos elementos 00:23:59
o más bien el código de esos elementos 00:24:01
y luego los que ya van desbordando 00:24:03
porque ya estamos metidos los que ya van desbordando 00:24:06
van colgando desde una lista enlazada 00:24:08
desde la posición del array que sea 00:24:09
entonces esto es lo que es 00:24:18
un hasher por dentro, que no lo vamos a programar 00:24:23
nosotros y nos da igual, pero sí 00:24:25
está bien que lo sepamos 00:24:26
para ver luego como tenemos que usarlo 00:24:28
entonces 00:24:30
el hasher cuando le damos un elemento 00:24:32
a meter con el add 00:24:34
el que hace, primero le aplica 00:24:37
el código, la función de hash 00:24:41
le aplica la función, bueno 00:24:42
lo primero que tiene que ver es ver si ese elemento está o no 00:24:44
antes de insertar 00:24:46
vale, pues para ver si está 00:24:47
lo primero que hace es meterle la función de hash 00:24:49
a este elemento 00:24:53
para ver a qué posición de la tabla cae 00:24:53
entonces la función de hash a lo mejor le lleva 00:24:56
aquí 00:24:59
si aquí no hay nadie, fenomenal 00:24:59
ese elemento no está, pues lo insertamos 00:25:02
pero si aquí si hay alguien 00:25:04
ahora ya 00:25:07
lo que tiene 00:25:09
puede ocurrir que haya solo uno 00:25:11
o que haya varios 00:25:13
porque haya desbordado 00:25:14
entonces tiene que recorrer toda la lista 00:25:15
enlazada 00:25:17
tiene que recorrer toda la lista enlazada 00:25:18
para ver si es igual a este 00:25:21
o si es igual a este 00:25:23
o si es igual a este 00:25:24
entonces para ver si es igual y si es igual 00:25:25
lo que aplica ya es el equals 00:25:29
entonces el hashSet 00:25:31
cuando le pasamos un elemento 00:25:33
le aplica 00:25:35
dos pasos 00:25:37
para ver si está o no está 00:25:38
primero la función de hash 00:25:40
que es el famoso hashCode que nos generaba 00:25:42
que lo hemos ignorado hasta ahora 00:25:44
primero la función de hash que le lleva a la posición 00:25:45
y luego aplicando el equals 00:25:47
hasta que 00:25:50
lo encuentre 00:25:52
¿vale? luego 00:25:53
cuando usamos un hashSet de elementos 00:25:55
la clase 00:25:58
a la que pertenecen los elementos del hashSet 00:26:00
tiene que tener implementado el hashCode y el equals 00:26:02
porque si no tiene implementado 00:26:04
el hashSet 00:26:06
su criterio de igualdad 00:26:07
no va a funcionar correctamente 00:26:09
porque para el hashSet el criterio de igualdad es 00:26:11
primero llamo a la función de hash 00:26:13
y ahora voy llamando al equals 00:26:16
esa es la idea 00:26:18
vamos a ver ahora cómo se aplica 00:26:19
pero bueno, más o menos está claro, ¿no? 00:26:21
cómo lo ubica 00:26:23
se hace una tablita de numeritos asociados a cada uno 00:26:23
cuando tengo más 00:26:28
de los que me caben en la tablita 00:26:29
voy colgándolos en listas enlazadas 00:26:31
y que van desbordando 00:26:34
y ahí ya no hay tamaño máximo límite 00:26:36
porque estas listas enlazadas pueden crecer hasta el infinito 00:26:38
entonces uno puede 00:26:40
configurar el hasset 00:26:43
uno puede configurarlo para decidir 00:26:45
qué tamaño de tabla quiere, que eso sería 00:26:47
lo ideal, claro, y lo óptimo 00:26:49
en función de la cantidad 00:26:51
de elementos que tú estimas 00:26:53
que va a haber en el hasset prácticamente 00:26:55
siempre, yo creo que casi siempre va a haber 7 00:26:57
a lo mejor hay veces que hay más 00:26:59
y hay veces que hay menos, pero la mayor parte 00:27:01
del tiempo hay 7, pues uno puede 00:27:03
hacer una tabla de 7 00:27:05
¿vale? pues 00:27:06
estimo que casi todo el tiempo 00:27:09
va a haber en torno a 10 00:27:11
a veces más, a veces menos 00:27:13
pues uno puede establecer una tabla de 10 00:27:15
entonces eso es configurable en el hashing 00:27:17
pero normalmente uno se mete a configurar eso 00:27:18
primero porque no es 00:27:21
que sea especialmente sencillo 00:27:23
y segundo porque tendría que tener 00:27:24
perfectamente estudiado su problema 00:27:27
para ver en tiempo real 00:27:28
realmente cuántos datos va a haber 00:27:30
la mayor parte del tiempo y eso es muy complicado de saber 00:27:32
entonces normalmente 00:27:34
uno no configura la tabla 00:27:36
de hash con los valores que quiera 00:27:38
sino que le deja al hash set 00:27:40
que lo haga él con su configuración 00:27:43
por defecto 00:27:45
y él pues bueno 00:27:46
ya veremos, hace ya una configuración 00:27:48
por defecto y ya está 00:27:51
o sea los dos extremos 00:27:52
serían una tabla de hash 00:27:54
solo con una posición, ese sería un 00:27:57
extremo, pero entonces 00:27:59
todos los elementos estarían colgando 00:28:00
desbordando de aquí, luego una tabla 00:28:02
de hash con una única posición 00:28:05
en realidad es como una lista enlazada, no hemos cambiado nada 00:28:06
es igual que una lista enlazada 00:28:08
luego no hemos ganado en eficiencia 00:28:10
un hash set 00:28:12
con una tabla de hash 00:28:14
donde hay tantos 00:28:15
elementos 00:28:18
tantas posiciones como elementos 00:28:20
sería como un array, luego tampoco hemos ganado 00:28:22
nada 00:28:24
entonces el hash set es una especie 00:28:24
de intermedio 00:28:28
entre lo bueno que es el array 00:28:30
y luego 00:28:32
cuando ya no quiero estirar más el array 00:28:34
porque es pesado, voy desbordando 00:28:36
en listas enlazadas 00:28:37
es una especie de mezcla de las dos cosas 00:28:39
ni una ni otra 00:28:41
y repito, lo ideal sería adaptar esta tabla 00:28:42
a mi situación real 00:28:46
pero eso no es fácil 00:28:47
se hace una configuración por defecto y ya está 00:28:48
bueno, esta es la idea de cómo funciona por dentro 00:28:51
y de lo que es una tabla hash 00:28:55
que se aplica en un montón de casos 00:28:57
y de por qué tiene interés esta 00:28:58
esta estructura 00:29:01
vale, pues 00:29:03
Vale, pues bueno, para no liarlo mucho 00:29:06
Vamos a hacer un proyecto 00:30:02
Ejemplo de conjuntos 00:30:04
Vale, pues venga, vamos a hacerle un paquete 00:30:09
Para el modelo de datos 00:30:30
Como solo un ejemplo, una cosa sencilla 00:30:33
Y luego ya en ejercicios, aplicaciones 00:30:35
Ya lo aplicáis vosotros con más clases 00:30:39
Pues venga, vamos a 00:30:41
Lo primero que se nos ocurre siempre 00:30:51
Bueno, venga, no vamos a cambiar 00:30:55
Pues yo que sé, una clase 00:30:57
Jugador 00:30:59
Cualquiera 00:31:00
El número 00:31:02
El nombre y el equipo, por ejemplo 00:31:11
Porque tenga tres propiedades 00:31:21
Vamos a hacerle el constructor 00:31:22
Y un constructor 00:31:28
Sin parámetros, que siempre 00:31:52
Nos gusta 00:31:54
Bueno, a mí por lo menos 00:31:56
¡Hala! 00:31:57
Ya está 00:32:05
Bueno, pues vamos a hacer un main cualquiera 00:32:06
que con un conjunto de jugadores 00:32:11
y ya está 00:32:14
vale, pues si vamos a trabajar 00:32:15
con un montón de jugadores 00:32:53
pues un montón de jugadores 00:32:54
si el mismo jugador no va a estar dos veces 00:32:56
en mi conjunto de datos 00:33:01
pues puedo elegir 00:33:03
un conjunto y ya está 00:33:05
¿qué implementación? 00:33:07
bueno, pues podemos elegir 00:33:16
esta implementación que por ahora es la única 00:33:21
que conocemos 00:33:22
¿vale? 00:33:24
Entonces yo tengo mucha manía 00:33:26
De en el momento de declararlo 00:33:29
Decir simplemente 00:33:31
La interfaz a la que pertenece 00:33:33
Y luego cuando lo instancio 00:33:34
Ya tengo que decir el tipo de dato 00:33:36
Pero a ver, uno puede 00:33:38
También podéis hacer esto 00:33:40
¿Vale? 00:33:43
También podéis desde ya decir 00:33:46
Es que esto va a ser un hashet 00:33:48
Si o si 00:33:49
Vamos a importar jugador 00:33:50
¿Vale? 00:33:54
A efectos prácticos 00:33:59
da un poco igual 00:34:01
ya sabéis la diferencia, claro, la diferencia 00:34:02
es que en esta variable jugadores 00:34:06
ahora ya, de aquí para 00:34:07
todo el futuro, solamente 00:34:09
pueden ir haset, porque está declarada así 00:34:12
pero si la declaráis así 00:34:14
vale, pues entonces en esta variable 00:34:16
cabe cualquier cosa 00:34:20
aquí se nota menos 00:34:21
las implicaciones de esto, pero 00:34:24
ahora un segundo y ahora paramos 00:34:26
pero imaginaos que tengo yo aquí un método 00:34:27
para mostrar 00:34:29
Vamos a mostrar 00:34:31
Nombres de jugadores 00:34:34
Por ejemplo 00:34:35
Imaginaos que me hago yo aquí 00:34:36
Un método dentro de mi main 00:34:39
Con el único objetivo de mostrar por consola 00:34:41
Los nombres 00:34:47
De un montón de jugadores 00:34:51
Vale, entonces yo aquí le tengo que pasar 00:34:52
Un conjunto de jugadores 00:34:59
Entonces esto yo lo puedo 00:35:01
Declarar así 00:35:02
Si lo declaro así 00:35:04
Yo ahora ya pues haría 00:35:16
Recorrer el set de jugadores 00:35:18
etcétera, lo que hiciera falta 00:35:20
vale 00:35:22
entonces aquí 00:35:22
en el momento de declarar un conjunto 00:35:26
como parámetro de un método 00:35:29
aquí sí que es recomendable 00:35:30
y tiene su interés 00:35:32
que yo lo deje abierto y diga 00:35:33
con que sea un conjunto me vale 00:35:35
porque así luego a este método 00:35:37
imaginaos que yo lo quiero llamar por aquí 00:35:39
si no le pongo lo static 00:35:41
no me va a dejar llamarle 00:35:46
vale, porque ahora imaginaos que yo llamo a este método 00:35:47
perfectamente 00:36:02
en este método le puedo llamar 00:36:04
con la colección de arriba 00:36:06
porque es un hash set 00:36:07
y este necesita un set 00:36:09
luego estupendo 00:36:12
que ahora cambio y digo 00:36:13
ha cambiado mi código 00:36:15
ha cambiado mi main 00:36:18
y esto ahora ya no va a ser un hash set 00:36:19
sino que es un tree set porque ha cambiado mi main 00:36:22
genial, este método le da igual 00:36:24
este método le da exactamente 00:36:28
lo mismo, entonces la idea es 00:36:30
cuando yo tengo que incorporar alguna modificación en un código 00:36:32
que eso afecte lo menos posible a lo demás 00:36:34
eso es un principio básico 00:36:37
del desarrollo, si tengo que modificar algo 00:36:39
que salpique lo menos posible 00:36:41
a los demás, entonces si yo 00:36:43
aquí hubiera decidido 00:36:45
declarar este parámetro 00:36:47
ya como haset 00:36:49
pues entonces aquí ya era lío 00:36:51
porque si yo he cambiado mi código 00:36:53
y digo ahora me interesa un triset 00:36:55
pues no puedo llamar a este método 00:36:56
entonces le tengo que decir al que ha hecho 00:36:59
el método, oye cambia esto 00:37:01
entonces 00:37:03
cuando declaro parámetros de métodos 00:37:04
ahí es donde sí que es 00:37:07
especialmente relevante 00:37:09
importante que lo deje lo más abierto 00:37:11
posible, que yo diga 00:37:13
este parámetro pertenece a esta interfaz 00:37:15
luego pásame la implementación que quieras 00:37:17
pertenece a esta interfaz 00:37:19
porque si yo desde aquí ya 00:37:21
comprometo el tipo 00:37:23
como luego cambia aquí 00:37:24
pues tengo que cambiar el método también 00:37:26
cuando es haset 00:37:29
fenomenal, pero cuando es 00:37:31
triset, porque he decidido cambiar 00:37:36
este punto, pues este ya no vale, entonces tengo que cambiarlo 00:37:37
entonces aquí 00:37:40
sí que tiene relevancia y es recomendable 00:37:40
oye, pásame cualquier cosa que sea un conjunto 00:37:43
luego tú ya en tu main 00:37:46
ya hagas lo que quieras, que quieres esto, vale 00:37:47
que luego quieres lo otro, lo que sea 00:37:50
¿vale? bueno, pues esto venía 00:37:51
a cuento de que yo tengo mucha manía 00:37:53
general de cuando 00:37:56
declaro una colección en cualquier punto 00:37:57
fijo el tipo 00:38:00
claro, si es conjunto, si es lista 00:38:01
y... 00:38:03
Pero la dejo abierta 00:38:05
Y luego ya decir 00:38:07
Pero esto ya es una manía mía 00:38:08
Donde realmente tiene implicaciones es aquí 00:38:10
Cuando es parámetro de método 00:38:13
Aquí arriba da un poco igual 00:38:15
Que si la queréis declarar de partida 00:38:16
Así, pues la declaráis de partida así 00:38:19
Lo que pasa es que luego ya jugadores 00:38:20
Nunca va a poder ir ningún conjunto 00:38:22
Que no sea haset, no va a poder ir luego un triset ni nada 00:38:24
Vale, pues entonces 00:38:27
Esto lo vamos a quitar ya 00:38:29
Y hemos dicho que íbamos a parar un momentajo 00:38:31
pues venga 00:38:33
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
16
Fecha:
10 de marzo de 2024 - 14:20
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
38′ 37″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
529.06 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid