Saltar navegación

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

Clase 02-04-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 3 de abril de 2024 por Raquel G.

14 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, pues esta era la famosa jerarquía de las colecciones, en las cuales efectivamente aquí nos falta eso de los mapas, nos falta, ¿verdad? 00:00:03
Había una primera interfaz iterable que no ofrece prácticamente ningún método, solamente el de general iterator, de esa heredaba collection, que incorporaba métodos abstractos, porque esto que está en azulito son interfaces. 00:00:14
lo que está en azulito 00:00:31
son clases vacías 00:00:34
o clases abstractas o interfaces 00:00:37
lo que está en azulito 00:00:38
y lo que está en amarillo 00:00:40
esto ya sí que eran clases implementaciones 00:00:41
y implementaciones 00:00:45
entonces en la raíz 00:00:46
de la jerarquía de colecciones estaba esta 00:00:48
interfaz que lo único que 00:00:50
obligaba era a tener un método vacío 00:00:52
iterator para crear un iterador 00:00:55
de ese le daba 00:00:56
collection que además 00:00:58
te incorporaba métodos para 00:01:00
añadir, borrar 00:01:01
y poquito más, entonces cualquiera 00:01:04
que implementaba de aquí tenía que incorporar esos 00:01:06
métodos y luego ya teníamos 00:01:08
las dos grandes 00:01:10
variantes 00:01:12
la de list y la de set 00:01:12
que la de list ya te incorporaba 00:01:16
un chorizo de métodos 00:01:18
para recuperar por posición, etc 00:01:19
y luego serían las implementaciones 00:01:22
¿vale? 00:01:24
que de list pues ya 00:01:26
sabemos que teníamos estas 00:01:28
ArrayList, LinkedList 00:01:29
y estas dos 00:01:32
antiguas 00:01:34
las 00:01:35
primeras versiones 00:01:36
y luego de Set, pues 00:01:39
estas. Vale, entonces aquí en esta 00:01:41
jerarquía no aparecen los mapas 00:01:45
¿vale? Porque los mapas 00:01:47
no heredan de aquí, van por libre 00:01:49
Entonces, ¿qué es un mapa? 00:01:51
Dentro del término colecciones, en general 00:01:53
se mete lo de los mapas porque vale 00:01:55
para guardar cosas 00:01:57
entonces en general se interpreta como colecciones 00:01:58
todo lo que vale para guardar objetos 00:02:01
entonces los mapas valen para guardar objetos 00:02:03
pero de una forma un poquito distinta 00:02:06
entonces vale para guardar objetos 00:02:08
pero de una forma un poquito distinta 00:02:11
y por eso no heredan ni de colección 00:02:13
ni de iterator ni de nada 00:02:16
porque funcionan de manera un poco distinta 00:02:17
y van por libre 00:02:19
pero valen también para guardar cosas 00:02:20
bueno pues los mapas 00:02:22
¿en qué se basan? 00:02:25
los mapas en realidad tienen una jerarquía 00:02:26
Mucho más sencillita 00:02:27
Que es 00:02:29
Esto de aquí, en realidad 00:02:30
¿Me lo doy? 00:02:33
¿Me puedo poner esto más grande o qué? 00:02:39
De verdad, estos niños tan listos de hoy en día 00:02:43
A ver, venga 00:02:45
Vamos a ver 00:02:47
Esto, le di 00:02:48
Lo conseguí, me costó 00:02:50
Vale 00:02:53
Eh, destruir más, ¿verdad? 00:02:54
Sí, vale, la jerarquía es más sencillita 00:02:57
¿Vale? 00:03:00
Esta es la interfaz map, la superinterfaz, que tiene unos métodos que luego implementan las implementaciones HashMap, LinkedHashMap y TrimMap. Estas son, ¿vale? Las tres implementaciones, porque esta es otra interfaz intermedia, esta también es una interfaz. 00:03:01
estas son las tres impermeaciones 00:03:20
y como veis 00:03:22
tienen un nombrecito 00:03:23
prácticamente igual 00:03:25
que haset, linked, haset 00:03:27
y triset, pero cambiando 00:03:30
set por map 00:03:32
porque por dentro en realidad 00:03:33
el funcionamiento 00:03:36
es como haset, linked, haset 00:03:37
triset, salvo 00:03:40
por una pequeña variante que veremos ahora 00:03:42
y el hastable 00:03:44
esta es como la versión antigua 00:03:46
del diccionario, del mapa 00:03:48
la versión antigua, pues como vector y stack 00:03:50
eran la versión antigua de las listas 00:03:52
pues el hash table es como 00:03:55
la primera versión de este concepto de mapa 00:03:56
la primera versión 00:03:58
pero estas de alguna manera son un poco las 00:03:59
implementaciones más 00:04:02
utilizadas, no nos vamos a 00:04:04
volver locos con ellas, simplemente 00:04:06
¿para qué existen? 00:04:08
existen para reproducir 00:04:10
una idea que se utiliza 00:04:12
muchísimo y está 00:04:14
precisamente relacionada con la famosa 00:04:16
clave primaria que mencionamos siempre 00:04:18
La mayoría de los objetos, de los conceptos, de las cosas, es muy útil que tengan algo que los identifique de forma única para poder gestionarlos de forma fácil. 00:04:20
Si todos los objetos tienen algo que los identifica de forma única, los vamos a gestionar de manera mucho más fácil. 00:04:31
¿Vale? Esa es la idea de partida. 00:04:38
Entonces, esa propiedad que los identifica de forma única es lo que normalmente conocemos como clave, con el término clave, ¿verdad? 00:04:40
En informática, el término clave está asociado a identificador único. 00:04:48
Clave tiene como significado, en términos informáticos, identificador único. 00:04:55
Bueno, pues entonces, lo que hacen los mapas es guardar objetos con un identificador único asociado. 00:05:01
Pero ese identificador único asociado va fuera del objeto, no es una propiedad interna. 00:05:10
No es una propiedad interna. 00:05:16
Entonces tienes tu objeto ciudad, lo guardas en el mapa 00:05:17
y le asocias un identificador único que lo guardas por libre. 00:05:20
Entonces por eso los mapas se le llaman diccionarios. 00:05:25
¿Por qué un diccionario es eso? 00:05:27
La lista de palabras del diccionario serían las claves o identificadores únicos. 00:05:29
Todas las palabras de diccionario son distintas. 00:05:35
Todas son diferentes. 00:05:37
Todas. 00:05:38
Las 3.000 que haya. 00:05:38
Todas son distintas. 00:05:39
Y el significado sería el objeto en sí. 00:05:41
lo que se llama en el mapa el valor 00:05:44
entonces un mapa 00:05:46
o un diccionario que son 00:05:48
sinónimos, son sinónimos mapa 00:05:50
y diccionario, es un 00:05:52
conjunto de pares 00:05:54
que son clave, valor 00:05:55
clave, valor, clave, valor, es un conjunto 00:05:58
de pares y la clave 00:06:00
tiene que ser única 00:06:02
y el valor puede estar repetido 00:06:03
en diferentes pares, puede estar repetido 00:06:06
entonces es como un diccionario 00:06:08
un diccionario es una secuencia 00:06:10
de palabras donde las palabras serían 00:06:12
la clave, son todas distintas. 00:06:14
Y los significados 00:06:16
serían el valor. 00:06:17
Los significados sí que se pueden repetir. 00:06:20
¿No? Puede haber 00:06:23
dos palabras distintas 00:06:24
que tengan el mismo significado. 00:06:26
¿Verdad? 00:06:29
Bueno, pues ese es el concepto 00:06:30
de mapa o diccionario. 00:06:32
Un conjunto de pares 00:06:33
es un conjunto de pares 00:06:35
¿vale? 00:06:41
De esta forma, clave, valor. 00:06:44
eso es un diccionario, clave, valor 00:06:46
eso es un mapa, un conjunto de pares 00:06:51
clave, valor, clave, valor 00:06:59
lo que lo define 00:07:00
las claves tienen que ser 00:07:03
distintas, las claves tienen que ser 00:07:05
distintas para todos los elementos 00:07:07
del mapa 00:07:09
todos los elementos que forman un mapa 00:07:09
tienen que tener claves diferentes 00:07:12
la clave tiene que ser única 00:07:14
pero los valores 00:07:16
se pueden repetir 00:07:18
este sería un mapa válido 00:07:20
uno 00:07:23
por lo que fuera 00:07:24
¿vale? esto es un mapa válido 00:07:27
porque las claves son únicas 00:07:48
uno, dos, tres 00:07:50
no tienen por qué ser numéricas 00:07:52
no tienen por qué ser numéricas 00:07:54
la clave puede ser cualquier valor, cualquier tipo de dato 00:07:56
no tienen por qué ser numéricas 00:07:59
lo importante es que todos los pares 00:08:02
que forman el mapa 00:08:05
tengan diferentes valores en esta clave 00:08:06
sean números, sean letras 00:08:08
pero sean diferentes 00:08:11
pero el valor puede estar repetido 00:08:12
entonces este es un mapa válido 00:08:14
este también es un mapa válido 00:08:15
también es un mapa perfectamente válido 00:08:18
el valor de este y el valor de este son iguales 00:08:20
pero la clave no 00:08:22
que es lo que importa 00:08:24
este sin embargo no es un mapa válido 00:08:25
este no es un mapa válido porque 00:08:28
hay dos claves repetidas 00:08:29
bueno pues entonces 00:08:31
la interfaz map 00:08:35
lo que busca es una manera 00:08:36
lo que programa es una manera de guardar mapas 00:08:39
guardar conjuntos de pares 00:08:42
que funcionen así, es lo que guarda 00:08:43
es lo que, para lo que está hecha esa interfaz 00:08:45
map, para guardar conjuntos 00:08:47
de pares, y es muy útil 00:08:49
porque muchas veces a nuestros objetos 00:08:52
no tienen ellos 00:08:53
en sí una propiedad 00:08:55
interna, que podamos 00:08:58
asegurar que es única, no la tienen 00:08:59
es que eso es lo que hay que ver con 00:09:01
cualquier objeto que esté 00:09:03
almacenado en un set, yo supongo que tiene 00:09:07
una hash, y la hash es 00:09:11
un identificador también, sí 00:09:13
claro, pero esto 00:09:15
lo que te permite es 00:09:17
que sea visible para ti 00:09:18
claro, entonces lo que te permite 00:09:20
es otra forma de guardar las cosas 00:09:22
y localizar por ella 00:09:24
entonces es más fácil 00:09:27
porque si cada uno tiene un código 00:09:28
único, asociado, visible 00:09:31
para ti, que tú has decidido 00:09:32
pues puedes recuperar por él, por ejemplo 00:09:34
puedes decir, devuélveme 00:09:36
el objeto de clave 2, por ejemplo 00:09:38
entonces te optimiza a trabajar 00:09:41
con ello 00:09:43
de alguna manera es que hay 00:09:43
muchas situaciones 00:09:46
en las cuales hay objetos 00:09:48
que ya de por sí tienen asociado 00:09:50
un identificador que es único, que no tiene por qué 00:09:52
estar generado por una clave hash 00:09:54
sino el identificador que tú asocias, pues por ejemplo 00:09:56
yo tengo aquí un conjunto de alumnos 00:09:58
y cada uno de ellos tiene un DNI 00:10:00
claro, entonces 00:10:02
yo aquí tengo un conjunto de alumnos 00:10:04
entonces los alumnos están 00:10:07
caracterizados por nombre y nota 00:10:08
por ejemplo, pero yo sé 00:10:10
que además cada uno de ellos tiene un DNI que es único 00:10:12
entonces puedo decidir que mi forma de gestionarlo 00:10:14
sea un conjunto 00:10:17
de pares donde 00:10:19
la clave sea el DNI que elijo yo 00:10:21
cuál es la clave, no tiene por qué provenir de 00:10:23
aplicar una función hash, la clave 00:10:25
sea el DNI y el objeto 00:10:27
sea el objeto alumno, el valor 00:10:29
entonces es una opción más 00:10:31
y en este caso es interesante porque entonces yo 00:10:33
ya puedo recuperar por DNI 00:10:35
dame el par con DNI 3 00:10:37
por ejemplo, 3 tiene mucho más sentido 00:10:39
porque yo aquí elijo la clave que me da la gana 00:10:41
Con que sea única, no hace falta que sea una función de hash ni nada. 00:10:43
Entonces, en una situación que se da, que yo me di cuenta de que le pega esto, 00:10:49
que le pega, pues uso los mapas y son muy útiles por eso, 00:10:54
porque la clave ahora ya me sirve como elemento para decidir cuál borro, cuál recupero, etc. 00:10:58
En un set, yo no puedo recuperar por clave hash. 00:11:05
En un set yo lo que puedo hacer es iterar a ver lo que tengo. 00:11:09
o puedo borrar y le doy un objeto 00:11:12
y que me borre el igual a ese 00:11:14
pero no puedo hacer más que eso 00:11:15
¿vale? sin embargo en esta estructura 00:11:17
pues tengo más posibilidades 00:11:20
¿vale? pues entonces puede ocurrir 00:11:22
que yo ya he decidido que hay una situación 00:11:24
que se presta a eso, tengo objetos 00:11:26
y tengo además 00:11:28
algo 00:11:30
que los identifica de forma única 00:11:31
que no tiene por qué ser una propiedad del objeto 00:11:34
que esa es otra ventaja, no tiene por qué ser 00:11:36
a lo mejor mi objeto alumno tiene DNI dentro 00:11:38
y yo no se lo puedo poner 00:11:40
no se lo puedo poner porque no puedo modificar la clase 00:11:42
no puedo poner el DNI 00:11:44
pero yo sí sé que hay una propiedad 00:11:46
DNI, o sea que los abogados tienen un DNI único 00:11:49
pues digo, estupendo 00:11:51
me hago un map 00:11:52
que tenga por un lado el DNI 00:11:54
y por otro lado el propio objeto 00:11:56
y me permite hacer ya muchas cosas 00:11:58
con esta estructura 00:12:01
entonces como en otros casos 00:12:02
esta es una, un recurso más 00:12:05
es un recurso más para usar 00:12:07
un recurso más y uno selecciona 00:12:08
de todos los recursos que tiene el que ve que le pega 00:12:10
más con la situación que está estudiando 00:12:13
¿vale? bueno pues este 00:12:14
recurso en concreto vale para eso 00:12:16
para guardar pares 00:12:18
y en esos pares 00:12:20
el primer elemento que es el que 00:12:23
se llama clave, tiene que ser único 00:12:24
y normalmente elegiremos 00:12:27
algo que identifique de forma única 00:12:29
al objeto que viene después 00:12:31
que es lo que se llama valor 00:12:32
y el valor puede estar repetido, puede no estarlo 00:12:34
etc. 00:12:37
Entonces, es un mapa. 00:12:38
¿Vale? 00:12:41
Entonces, vamos a hacer unos pequeños ejemplos 00:12:41
de cómo se usan y poco más. 00:12:43
Ejemplo triset y ejemplo mapas. 00:12:48
Bueno, pues, por ejemplo, 00:13:20
vamos a hacer eso mismo que ha surgido. 00:13:21
¿Vale? 00:13:26
Pues, resulta que estamos trabajando con alumnos, 00:13:27
la clase alumno, 00:13:29
y la clase alumno, por la razón que sea, 00:13:30
solo tiene estas dos propiedades. 00:13:32
vamos a hacerle un constructor 00:13:33
con los dos parámetros 00:13:48
y get y set, pues bueno, ya por hábito 00:13:49
vale, y ahora ya 00:13:55
para trabajar con estos alumnos 00:14:04
habría millones de 00:14:06
posibilidades 00:14:08
en función de la aplicación con la que ya estoy trabajando 00:14:09
ahora ya, claro 00:14:12
hay millones de cosas que se puede hacer con esto 00:14:14
en función de la aplicación 00:14:16
entonces, pues bueno 00:14:17
resulta que ahora mi aplicación 00:14:19
vamos a meterla en la clase main 00:14:22
como siempre 00:14:24
mi aplicación es esta, la que está allá en el main 00:14:25
entonces mi aplicación 00:14:34
tiene que trabajar con alumnos 00:14:36
y hacer cosas con los alumnos 00:14:37
pues las medias, las notas 00:14:40
recuperar un alumno 00:14:43
lo que sea, lo que sea, tiene que hacer cosas 00:14:44
con alumnos, entonces ahora 00:14:46
aquí hay un montón de posibilidades 00:14:48
hay un montón de opciones sobre, vale, dónde guardar 00:14:50
los alumnos, en un set 00:14:52
en un list 00:14:54
aquí vendría lo de siempre 00:14:55
va a haber alumnos duplicados 00:14:57
que significa que los alumnos sean iguales 00:15:00
bueno, aquí hay un montón de opciones 00:15:02
que dependerán de 00:15:03
mi problema en concreto 00:15:06
que tendré que estudiar, tendré que hablar 00:15:07
con el secretario de un instituto que me diga 00:15:09
estos son los datos 00:15:12
que se pueden repetir, los que no, lo que sea 00:15:13
pero bueno, nosotros ahora 00:15:15
lo que sí que tenemos claro 00:15:18
es que vamos a trabajar con un montón de alumnos 00:15:20
¿dónde metemos ese montón de alumnos? 00:15:21
bueno, pues 00:15:24
en este caso podríamos decir, vale, además 00:15:24
tengo el dato del DNI del alumno 00:15:27
lo tengo 00:15:29
con la ventaja de que ese dato me identifica 00:15:30
al alumno de forma única 00:15:33
el DNI del alumno no está 00:15:35
dentro del objeto alumno 00:15:37
no está dentro 00:15:39
podría estar dentro 00:15:41
podría estar dentro 00:15:43
y entonces ya me hago un set 00:15:45
de los de toda la vida 00:15:47
con el equals y el hashcode con el nif 00:15:48
por ejemplo, y tendría un diseño 00:15:51
de aplicación, tendría un diseño 00:15:53
me meto el nif aquí dentro 00:15:55
me meto el nif aquí dentro 00:15:58
me hago el hascode y el equals 00:15:59
basado en el nif 00:16:02
porque el nif identifica de forma única 00:16:03
al alumno y trabajo 00:16:05
con un set de alumnos 00:16:07
o con un list si yo quiero que haya 00:16:09
duplicados, como me dé la gana 00:16:11
pues ya está, es una opción más de diseño 00:16:13
¿vale? pero vamos a hacer otra 00:16:14
para trabajar con el map 00:16:16
bueno, pues resulta que el nif no está dentro de esta clase 00:16:18
alumno por la razón que sea 00:16:21
pero el dato del NIF 00:16:23
yo sí que lo voy a conocer 00:16:26
tengo disposición de él, tengo ese dato 00:16:27
es una información que tengo del alumno 00:16:29
vale, pues entonces 00:16:31
el diseño que me puedo hacer 00:16:33
que es un diseño que me va a facilitar muchísimo 00:16:34
la vida es, vale, pues voy a 00:16:37
guardar a mis alumnos 00:16:39
en un mapa, que es un conjunto 00:16:40
de pares, donde la clave 00:16:43
va a ser el NIF 00:16:45
y el valor va a ser ya el objeto 00:16:46
alumno concreto asociado a ese NIF 00:16:49
el objeto alumno concreto 00:16:51
Entonces me he hecho otro diseño distinto 00:16:52
Un diseño basado en un mapa 00:16:55
Y ese diseño es muy útil 00:16:57
Bueno, pues entonces 00:17:00
¿Cómo declaro yo un objeto map? 00:17:03
Vale 00:17:08
Pues de nuevo es un objeto genérico 00:17:09
Es una clase genérica, perdón 00:17:11
Y en este caso depende 00:17:14
De dos tipos 00:17:15
De datos 00:17:17
De hecho, si nos vamos aquí a 00:17:19
Espera, voy a ver si 00:17:20
Open implement 00:17:24
A esta, quería yo, vale 00:17:29
Si nos vamos a la implementada 00:17:31
No, esta no quiero 00:17:34
Quiero la de útil 00:17:35
Esta 00:17:42
Joder, ¿por qué no me abre la de útil? 00:17:43
Open map 00:17:52
A esta quería yo, vale 00:17:53
De hecho, si nos vamos a interfaz map 00:17:55
Vemos que es genérica 00:17:57
Y en este caso depende de dos tipos de datos 00:17:59
depende de dos tipos de datos 00:18:01
la lista dependía de uno 00:18:04
los set dependían de uno 00:18:06
que era el tipo de dato al que pertenecían los objetos 00:18:08
que iban dentro 00:18:10
pues el map es una clase genérica 00:18:11
interfaz genérica que depende de dos 00:18:14
tipos de datos 00:18:16
y esos dos tipos de datos ¿cuáles son? 00:18:17
el tipo de dato al que pertenece 00:18:21
la clave y el tipo de dato 00:18:23
al que pertenece el valor que yo los puedo elegir 00:18:24
¿vale? 00:18:27
este es el tipo de dato al que van a pertenecer 00:18:28
las claves de los pares 00:18:30
y este es el tipo de dato 00:18:31
al que van a pertenecer 00:18:34
los valores de los pares 00:18:35
y yo elijo 00:18:36
los que me interesen 00:18:37
según mi aplicación 00:18:38
bueno pues en mi caso 00:18:39
la clave 00:18:42
el NIF 00:18:46
el NIF 00:18:47
¿en qué lo guardamos? 00:18:48
pues en string 00:18:49
por ejemplo 00:18:50
pues entonces aquí coloco 00:18:51
string 00:18:53
la cosa es que entonces 00:18:54
la clave tiene su número entero 00:18:58
entonces el nif lo unió que no podía tener la letra 00:18:59
pero vamos 00:19:02
que aquí lo que importa es que 00:19:04
pongas el tipo de dato al que pertenece tu clave 00:19:06
si tu clave es un número entero 00:19:08
pones integer efectivamente 00:19:10
si tu clave es un número decimal 00:19:11
pones double, tu clave puede ser cualquier tipo de dato 00:19:14
eso sí 00:19:16
tiene que ser un tipo de dato 00:19:18
de tipo objeto 00:19:19
efectivamente si fuera un número 00:19:21
aquí nunca podríamos poner int 00:19:23
pero esto es lo mismo que en las listas 00:19:25
esto ya nos ha pasado 00:19:27
aquí no podríamos poner esto 00:19:28
ya lo sabemos, pero para eso podríamos 00:19:30
la envolvente 00:19:32
¿verdad? que es lo mismo, ya lo sabemos 00:19:34
bueno, pues en nuestro caso 00:19:36
si yo he decidido 00:19:37
que mi DNI se guarde en string 00:19:39
pues aquí pondría el tipo string 00:19:42
porque las claves son nil que va en string 00:19:44
ahora, el valor 00:19:46
el valor de cada par, ¿cuál va a ser? 00:19:47
el objeto alumno en concreto 00:19:50
el objeto alumno, pues entonces aquí 00:19:51
pongo alumno 00:19:54
pues aquí tengo ya 00:19:55
mi la declaración 00:20:01
lo que pasa es que a la instancia 00:20:04
a la hora de instanciar 00:20:06
tengo que elegir una implementación 00:20:08
concreta, recordad que 00:20:10
la variable se puede declarar 00:20:12
de la superclase, pero luego 00:20:14
no instancia ya una implementación 00:20:16
obviamente 00:20:18
tres implementaciones, hashMap, linkedHashMap 00:20:19
trimap, vamos a coger la primera 00:20:22
de ellas, vale 00:20:24
pues ya tenemos nuestra estructura de datos 00:20:45
vale, es otra 00:20:47
variante, en lugar de meter todos los 00:20:49
alumnos en un set 00:20:51
y ya sabemos lo que podemos hacer con eso 00:20:52
pues hemos metido los alumnos 00:20:56
en un mapa 00:20:58
donde además van acompañados de su DNI 00:20:59
que es su clave 00:21:02
entonces ahora, ¿qué podemos hacer con una colección? 00:21:04
como esta, con un mapa 00:21:07
lo mismo que con todas, meter pares 00:21:08
recuperar pares 00:21:11
en este caso, recuperar por clave 00:21:13
que esa es la principal ventaja 00:21:15
borrar por clave, podemos hacer mil cosas 00:21:16
por ejemplo, vamos a meter 00:21:19
pues un alumno, pues nada 00:21:20
alumnos, uno ya puede 00:21:22
mirar aquí todos los métodos que hay 00:21:24
en los mapas 00:21:26
¿vale? que hay pues 00:21:28
pues unos cuantos 00:21:32
métodos 00:21:38
de map 00:21:39
algunos por su propio 00:21:41
nombre, pues ya podemos deducir lo que hacen 00:21:44
pues este obviamente eliminará todos los pares 00:21:46
de la colección 00:21:48
¿vale? no hay muchos 00:21:49
porque lo único que es meter pares, borrar 00:21:54
pares, no hay ningún at 00:21:57
no hay ningún at porque aquí 00:21:59
no se llama at, se llama put 00:22:01
simplemente, porque ha cambiado el nombre 00:22:02
aquí se llama put 00:22:04
vale, el at aquí se llama put 00:22:06
bueno, pues en nuestro caso 00:22:08
que queremos meter un nuevo alumno 00:22:10
que queremos meter un nuevo 00:22:13
alumno, pues tenemos que meter el par entero 00:22:20
clave, pues venga, alumno con dni 00:22:22
este, y aquí tenemos que 00:22:24
meter un alumno, pues venga, new 00:22:28
alumno, pues el alumno 00:22:30
que sea, que era nombre y nota 00:22:38
con esta cacholetraza no me 00:22:40
no me aclaro, vale 00:22:54
pues ya hemos metido un par, entonces aquí 00:22:57
va todo por pares 00:22:59
vale, entonces después de meter aquí 00:23:00
esto vamos a ejecutarlo 00:23:25
solamente para verificar que no nos sale 00:23:29
ningún error de ejecución ni nada 00:23:31
no vayamos a haber escrito algo mal, pero no vamos a ver nada 00:23:32
no vamos a ver nada porque 00:23:35
no he hecho nada, solamente meter 00:23:37
dos pares y ya está 00:23:39
vale 00:23:40
vale, pues esos dos pares ya están aquí 00:23:41
entonces vamos a ver, tendrá un size 00:23:44
para ver cuántos hemos metido 00:23:47
vamos a 00:23:49
que está aquí 00:23:50
vale, entonces efectivamente si ejecutamos 00:23:55
esto, veremos, se supone que dos 00:23:58
veremos dos 00:23:59
lo ejecutamos y sí, hemos metido dos pares 00:24:01
vale 00:24:04
entonces, insertar pares, ninguna complicación 00:24:06
con put se van insertando 00:24:09
que queremos insertar un montón de pares 00:24:11
a la vez, tiene un put all 00:24:14
también 00:24:16
entonces al put all le pasamos 00:24:16
a su vez dentro otro mapa 00:24:19
y todos los pares del mapa 00:24:21
los mete en ese 00:24:24
igual que en la lista 00:24:24
o el set tenía también un add all 00:24:28
que le pasábamos una colección 00:24:29
y te metía todos los elementos de esa colección 00:24:31
en la lista 00:24:34
pues este tiene un put all donde le metes 00:24:35
un mapa y todos los del mapa se van 00:24:37
Pero bueno, no tiene mayor. Aquí lo único es que, lógicamente, si yo repito a un alumno con la misma clave, no lo va a meter. Es decir, yo meto a otro alumno distinto, que es el Carlos II este, otro distinto, pero para la misma clave. 00:24:39
¿Vale? 00:25:02
Meto otro alumno distinto 00:25:07
Y sigue teniendo dos 00:25:08
¿Por qué? Porque este lo ha ignorado 00:25:12
Es como al set 00:25:15
Cuando al set le intentábamos meter 00:25:16
La clave siempre va a ser 00:25:18
El primer parámetro 00:25:20
Siempre, va en ese orden 00:25:21
Clave, valor 00:25:24
Siempre va a ser el primero 00:25:25
Tiene que ser el primero 00:25:27
Entonces, este lo ha ignorado 00:25:28
Pues el segundo no lo ha metido 00:25:31
Como cuando en un set intentas meter un objeto duplicado 00:25:32
Pues no lo ha metido 00:25:35
vale 00:25:37
entonces, vamos a hacer 00:25:38
otro cambio 00:25:49
vamos a hacer ahora un cambio en el cual 00:25:50
imaginaos que ahora 00:25:54
queremos 00:25:55
trabajar con alumnos 00:25:57
y a cada alumno asociarle 00:26:00
un aula 00:26:02
es una cosa un poco retorcida, pero bueno, un aula 00:26:03
que va a ser el nombre de aula en stream 00:26:05
entonces yo decido 00:26:07
que mi estructura de datos 00:26:09
entonces sea un mapa 00:26:11
donde la clave en este caso sea 00:26:12
el alumno, el objeto alumno 00:26:15
y el valor el aula 00:26:17
entonces en ese mapa 00:26:18
todos los objetos alumnos son distintos 00:26:19
por eso me he funcionado como clave 00:26:22
y el valor es la clase 00:26:24
en la que está, el valor se puede repetir 00:26:27
puede haber dos alumnos en la misma aula 00:26:28
entonces imaginaos que yo decido ahora 00:26:30
porque me interesa para mi aplicación 00:26:32
una estructura de datos que sea así 00:26:34
un conjunto de pares que son 00:26:36
objeto alumno, clase en la que está 00:26:38
objeto alumno, clase en la que está 00:26:41
por ejemplo, me apetece a mí 00:26:43
hacer un mapa de esos 00:26:44
porque resulta que luego 00:26:45
me va a ser útil 00:26:46
para las operaciones 00:26:47
que voy a hacer. 00:26:48
Pues venga, 00:26:50
vamos a hacernos ahora 00:26:50
ese otro mapa. 00:26:51
Este está entendido, ¿no? 00:26:52
Es un mapa normal y corriente 00:26:53
donde yo meto 00:26:54
nif, objeto, 00:26:55
nif, objeto. 00:26:56
Vale, pues ahora resulta 00:26:58
que me interesa a mí 00:26:59
hacer un mapa 00:27:00
asignaciones 00:27:01
que es alumno, aula, 00:27:02
en la que está, 00:27:03
alumno, aula, 00:27:04
en la que está. 00:27:04
Pues entonces, 00:27:05
me hago yo mi mapa. 00:27:06
En este caso, 00:27:07
mi mapa, 00:27:10
los tipos de datos serían 00:27:12
alumno, 00:27:13
el primero de todos, 00:27:14
Porque el tipo de dato al que pertenece la clave es alumno, la clave será el objeto alumno, distinto para cada entrada del mapa. Cada elemento de un mapa se les llama la entrada, normalmente la entrada del mapa para cada entrada. 00:27:16
y ahora el valor, el nombre 00:27:30
del aula, le ponemos un string 00:27:32
pues entonces aquí ponemos un string 00:27:34
vale, pues bueno, imagínate 00:27:36
a este mapa 00:27:39
se llama asignación sin más 00:27:42
y ahora ya lo 00:27:44
lo instanciamos como hash map 00:27:46
vale, pues venga 00:27:48
vamos a colocar al primer alumno en un aula 00:27:57
pues asignación 00:27:59
put, vamos a 00:28:03
poner al alumno 00:28:07
este que tiene nota 4, a este alumno 00:28:08
Lo vamos a poner en el aula 00:28:20
Esta de aquí 00:28:22
Ahí se queda 00:28:23
Vamos a poner aquí 00:28:30
Unos asteriscos para cuando lo ejecutemos 00:28:32
Sepamos 00:28:35
Que es lo que estamos viendo 00:28:37
Vale, pues ya hemos metido la primera asignación 00:28:38
Y ahora 00:28:47
No me falta un paréntesis 00:28:48
Si me falta un paréntesis 00:28:52
Ah no, no me falta 00:28:53
Entonces vamos a meter a otro 00:28:54
Entonces según lo que yo he dicho 00:28:59
Si vuelvo a meter al mismo alumno 00:29:03
Y me equivoco 00:29:06
Vuelvo a por alumno carlos4 00:29:07
Le pongo en dos dam 00:29:10
Según lo que yo he dicho 00:29:12
Como he metido dos veces la misma clave 00:29:15
No me lo va a meter 00:29:18
La segunda asignación no lo va a meter 00:29:21
Vamos a verlo 00:29:23
Asignación 00:29:25
Punto 6 00:29:28
Vale, hemos dicho que la clave tiene que ser única 00:29:29
He metido dos veces 00:29:36
el mismo objeto, igual que aquí he metido 00:29:37
dos veces este mismo 00:29:40
objeto y efectivamente he comprobado que el 00:29:42
segundo lo ha ignorado, pues aquí he metido 00:29:44
dos veces el mismo objeto 00:29:46
vamos a ver 00:29:47
qué es lo que 00:29:49
me hace 00:29:52
y sin embargo aquí sí que 00:29:53
me lo ha metido, aquí sí 00:29:56
claro 00:29:59
pero seguro que podéis contestarme 00:30:01
¿por qué para el HashMap 00:30:03
este y este no son el mismo? 00:30:05
¿por qué no son el mismo? 00:30:07
a ver, esto y esto es igual 00:30:11
es clavado, pero para el HashMap 00:30:17
esto y esto 00:30:19
es distinto, ¿por qué es distinto? 00:30:21
¿por qué estos objetos 00:30:24
son distintos? 00:30:25
porque tienen otro valor distinto 00:30:27
¿o no se acuerdan? 00:30:29
no, no, no 00:30:30
sí, pero no es por eso 00:30:31
es que antes de 00:30:34
mirar el valor 00:30:37
claro, o sea, antes de mirar el valor 00:30:37
él cuando, él ha metido esto 00:30:40
ahora tú le pasas esto, y dice, a ver, clave 00:30:42
¿esta clave existe ya? 00:30:45
sí existe, entonces lo ignoro 00:30:47
que es lo que nos ha hecho antes 00:30:48
¿esta clave no existe? es que ya ni mira el valor 00:30:50
entonces él ha llegado a la conclusión 00:30:52
de que este objeto no existía previamente 00:30:54
porque lo ha vuelto a meter 00:30:57
¿por qué 00:30:58
no ha encontrado 00:30:59
no se ha dado cuenta de que este objeto es igual que el anterior? 00:31:01
no sabemos si está guardando 00:31:05
¿eh? 00:31:07
si está guardando el objeto 00:31:08
¿cómo que no se está guardando? 00:31:09
pero 00:31:13
exactamente 00:31:13
es que no son iguales 00:31:17
porque la clase alumno 00:31:20
no tiene su hashcode ni su equals 00:31:21
con lo cual el que usa 00:31:24
es la de object 00:31:26
y object como siempre 00:31:27
la implementación de equals de object 00:31:29
es dos objetos son iguales 00:31:32
si está en la misma dirección de memoria 00:31:35
si no, no 00:31:36
entonces este objeto 00:31:37
se ha creado en la dirección de memoria 00:31:39
y este otro se ha creado en otra 00:31:41
los valores son los mismos 00:31:44
pero son dos objetos en diferentes direcciones de memoria 00:31:45
es el problema de siempre 00:31:48
que se manifiesta en todas las situaciones 00:31:50
que yo no he hecho ningún 00:31:52
equals en alumno 00:31:54
entonces al no haber hecho ningún equals 00:31:56
esos objetos son distintos 00:31:58
entonces yo ahora es cuando tengo que decidir 00:31:59
ah no, perdona, es que para mí 00:32:01
la igualdad se basa en esto 00:32:03
pues tengo que programarla para que el resto lo entienda 00:32:06
yo no puedo esperar 00:32:08
es que el string 00:32:10
sí que tiene el equals 00:32:13
porque la clase string ya está hecha 00:32:13
esta es la clase string 00:32:16
y la clase string 00:32:18
es una clase que ya está hecha 00:32:19
y tiene su propia implementación de equals 00:32:22
que está hecha en función de que los caracteres 00:32:24
sean iguales 00:32:26
entonces dos string 00:32:27
no, alumno lo acabo de hacer yo 00:32:28
y no tiene ninguna implementación de equals 00:32:33
alumno es esta 00:32:34
claro 00:32:35
pero coge el equals de object 00:32:38
y el de object está basado en dirección de memoria 00:32:41
entonces 00:32:43
el equals de string 00:32:45
ya ha sobrescrito el de object 00:32:47
basado en que los caracteres sean iguales 00:32:49
pero alguno no lo ha sobrescrito 00:32:52
es el problema con el que nos hemos 00:32:53
encontrado en un montón de situaciones 00:32:55
pues aquí con el mapa 00:32:58
exactamente igual 00:33:00
entonces para el map este objeto 00:33:01
y este objeto son distintos 00:33:04
porque yo no les he dado 00:33:05
un criterio de igualdad 00:33:07
vale, pues ahora viene lo importante 00:33:08
y es, para el map 00:33:10
¿cuál es el criterio de igualdad? 00:33:12
pues depende de si es hash map 00:33:14
linked hash map o tree map 00:33:16
para el hash map 00:33:17
el criterio de igualdad es el mismo 00:33:20
que para el hash set 00:33:22
que es hash code equals 00:33:23
con lo cual, en la clase 00:33:26
a la que pertenezcan las claves 00:33:28
y solo las claves 00:33:29
hay que implementar 00:33:31
hay que implementar hash code equals 00:33:33
porque ahí es donde importa, él es donde mira la igualdad 00:33:35
entonces el hashMap, por eso se llama así 00:33:37
internamente guarda las claves en un hashSet 00:33:40
las claves las guarda en un hashSet, internamente 00:33:43
y por tanto necesita que haya hashCodeEquals 00:33:45
en esta clase para poder 00:33:49
comprobar si son iguales o no 00:33:52
igual que el hashSet necesitaba hashCodeEquals en la clase 00:33:54
para ver si dos eran iguales o no 00:33:58
pues como en el hashMap las claves se guardan en un hashSet 00:34:00
pues aquí tiene que haber 00:34:04
jasco de equals, si no hay jasco de equals 00:34:06
para él esto es distinto 00:34:08
vale, pues entonces será bien 00:34:09
bueno, y nosotros 00:34:12
que hace que los alumnos sean 00:34:13
iguales, en este 00:34:16
caso, el nombre, tiene que haber un criterio 00:34:18
de igualdad, porque es que si lo estoy usando como clave 00:34:20
si los uso como 00:34:22
clave, tiene que haber un criterio de igualdad en ellos mismos 00:34:24
aquí no hay nada 00:34:26
es que son ellos la clave 00:34:28
pues tengo que dar un criterio de igualdad 00:34:29
para ellos, pues mi criterio de igualdad 00:34:32
¿cuál decido? pues por nombre 00:34:34
decido que por nombre, porque puede haber alumnos 00:34:35
distintos con la misma nota 00:34:38
pues nada, me hago el jasco de 00:34:39
equals, por nombre 00:34:42
solamente, por nota no 00:34:46
por nombre 00:34:48
ala, ya tengo el jasco 00:34:49
de equals por nombre 00:34:52
pues estupendo, ahora ya 00:34:53
sí, ahora ya 00:34:56
si yo repito esta aplicación 00:34:58
el hashmap ya va a ver 00:35:00
que carlos4 es igual que el carlos4 00:35:02
como si pusiera carlos5 00:35:04
porque para él 00:35:06
la igualdad viene por nombre 00:35:09
entonces ahora si ejecutamos esto 00:35:10
efectivamente el segundo 00:35:13
no lo va a haber metido 00:35:15
¿vale? el segundo ahora ya 00:35:17
no lo ha metido 00:35:21
¿vale? 00:35:22
entonces de nuevo, si usamos 00:35:26
hasMap o linked hasMap 00:35:29
tenemos que tener en cuenta que la clase 00:35:30
a la que pertenecen las claves 00:35:33
tiene que tener el hasCode equals 00:35:34
tiene que tenerlo porque si no va a funcionar 00:35:36
con coherencia 00:35:39
la diferencia entre HashMap y LinkedHashMap 00:35:40
la misma que entre HashSet y LinkedHashSet 00:35:48
que si ahora iteramos 00:35:50
por el map, iteramos 00:35:52
en el HashMap 00:35:54
me va a iterar en el orden que 00:35:55
dé el dedo a entender y en el LinkedHashMap 00:35:57
me va a iterar 00:36:00
en el mismo orden en el que inserté 00:36:01
es la única diferencia 00:36:03
¿vale? 00:36:05
bueno pues 00:36:11
ventaja de usar un map, pues efectivamente 00:36:12
que recuperar 00:36:15
para recuperar, consultar 00:36:18
es más fácil porque lo puedo hacer por clave 00:36:20
directamente, por ejemplo 00:36:24
que ahora yo quiero en mis alumnos 00:36:26
borrar el que tenga un DNI 00:36:28
pues bueno, tengo mi método 00:36:32
remove, al que yo le paso la clave 00:36:38
entonces la ventaja de los mapas es que yo puedo 00:36:40
hacer operaciones basadas en la clave 00:36:45
operaciones basadas en la clave 00:36:48
cuando tengo set y list 00:36:50
no puedo trabajar con clave, no hay clave 00:36:52
yo tengo que pasar al remove el objeto 00:36:54
entero y me borra uno 00:36:56
igual que ese objeto, es un poco 00:36:58
más farragoso y más complicado 00:37:00
con un mapa le paso la clave 00:37:02
y él me borra por clave 00:37:04
pues este me va a 00:37:06
borrar el alumno cuya clave sea esta 00:37:08
por ejemplo 00:37:10
entonces esa es la ventaja que tiene 00:37:12
que es muy práctico para eso 00:37:14
cuando yo tengo muy claro 00:37:16
que mis objetos de mi aplicación 00:37:18
tienen una clave asociada 00:37:21
pues me va a ser mucho más fácil 00:37:22
meter esos objetos en un mapa 00:37:24
con la clave, porque luego ya borro 00:37:26
por clave, recupero por clave, hago por clave 00:37:29
lo que quiera, y es mucho más sencillo 00:37:31
¿qué quiero recuperar 00:37:33
por clave? pues ya está 00:37:37
tendré el método 00:37:38
get por ahí 00:37:40
le paso la clave y me dice cuál es el que tiene 00:37:42
esa clave, bueno pues 00:37:45
queda mucho más bonito 00:38:07
hacer accesos por clave 00:38:08
queda más bonito que para borrar 00:38:10
tener que dar un objeto entero 00:38:13
y decir, bórrame uno igual a este, eso es mucho más feo 00:38:14
digo, bórrame el que tiene este DNI y ya está 00:38:17
es mucho mejor 00:38:19
pero para eso tengo que haberlo guardado en un mapa 00:38:20
tengo que haberlo guardado en un mapa 00:38:22
entonces es la ventaja que tiene 00:38:24
los accesos por clave y ya está 00:38:29
recorrer el map 00:38:31
recorrer el map es un poquito 00:38:34
más pesado 00:38:36
es un poquito más pesado porque estos son pares 00:38:37
entonces tengo que transformarlo 00:38:39
primero 00:38:42
puedo recorrer de muchas maneras 00:38:43
un mapa en realidad 00:38:46
pero una de las más sencillas 00:38:46
tengo un método para transformarlo 00:38:49
a un conjunto 00:38:52
y luego ya iterar por ese conjunto 00:38:53
como hemos iterado de toda la vida 00:38:56
queda muy largo 00:38:58
escrito porque el nombre de las clases es largo 00:39:00
pero luego es una tontería 00:39:02
entonces vamos a ver 00:39:03
si volvemos a ver 00:39:06
los métodos de 00:39:09
¿vale? lo que vamos a hacer ahora es 00:39:10
recorrer el map 00:39:15
¿cómo recorrería uno un map para ver lo que tiene? 00:39:16
para ver lo que tiene simplemente 00:39:22
vale, pues bueno, si uno ve 00:39:23
los métodos que tiene 00:39:27
¿veis? hay un 00:39:28
contents key que también es muy práctico 00:39:31
que te dice si hay algún par 00:39:33
que tenga esa clave 00:39:35
tiene un contents value que te dice si hay 00:39:36
algún par que tenga ese valor 00:39:39
que puede ser más de uno 00:39:41
en este caso solo va a ser uno 00:39:42
en caso de existir, en este caso puede ser más de uno 00:39:45
entonces tiene una serie de métodos 00:39:47
que bueno, te dice si está vacío 00:39:48
¿vale? 00:39:50
este método 00:39:54
por ejemplo, el key set 00:39:58
te devuelve un conjunto 00:39:59
con las claves 00:40:02
el key set devuelve un conjunto con las claves 00:40:03
entonces 00:40:06
este lo podemos usar 00:40:08
para recorrer 00:40:10
por ejemplo, si queremos, ¿vale? 00:40:12
Xset te devuelve un set que tiene 00:40:13
las claves, solamente. 00:40:15
Solo las claves, los valores los ha quitado. 00:40:17
Entonces, imaginaos que 00:40:19
a ver, 00:40:20
pues me voy a quedar yo con las 00:40:28
claves 00:40:29
de mis alumnos, que eran 00:40:30
DNI, lo van en string, 00:40:33
pues por ejemplo, 00:40:38
estas serían 00:40:45
solamente las claves, un conjunto 00:40:45
con las claves. 00:40:49
Y ahora ya, pues por ejemplo, 00:40:51
puedo hacer esto, por ejemplo, 00:40:53
Recorrer este conjunto 00:40:54
Para cada clave 00:40:56
En mi conjunto de claves 00:40:58
¿Vale? Pues puedo hacer esto 00:41:01
Mostrar esa clave 00:41:04
Y el valor que hay en el mapa asociado a esa clave 00:41:07
Por ejemplo, voy a poner aquí abajo 00:41:18
Eh... 00:41:20
Alumno 00:41:25
Y ahora cojo del mapa de alumnos 00:41:30
El alumno asociado a esa clave 00:41:33
Por ejemplo 00:41:36
voy recorriendo todas las claves 00:41:44
que están en este set 00:41:47
y ahora muestro la clave 00:41:48
y el objeto alumno que está asociado a esa clave 00:41:50
recordad que get es el método para 00:41:53
recuperar por clave 00:41:55
aquí lo que pasa es que como lo he metido en un 00:41:56
system.out.println 00:41:59
el alumno como no tiene 00:42:00
un toString me lo va a mostrar raro 00:42:03
pues vamos a ponerle un toString alumno 00:42:05
para que me muestre el objeto alumno más bonito 00:42:07
le vamos a poner un toString 00:42:09
vale, ya tiene un toString 00:42:11
en el alumno. Entonces, si ejecutamos esto, voy a quitar el remove porque si no solamente 00:42:21
va a mostrar un alumno. Vamos a, pues aquí están los dos alumnos, ¿vale? Este es el 00:42:29
recorrido, el resultado de mi recorrido. DNI el alumno. Bueno, pues esta es una posibilidad 00:42:49
para recorrer el mapa. Y bueno, hay otra que mencionamos ahora. Paramos un momentito y 00:42:57
la mencionamos. 00:43:02
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
14
Fecha:
3 de abril de 2024 - 18:43
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
43′ 05″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
194.32 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid