Saltar navegación

20260303 Map_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 marzo de 2026 por Raquel G.

2 visualizaciones

Más información Transcripción

Descargar la transcripción

Venga, dale 00:00:00
Vale 00:00:02
Pues hemos visto 00:00:04
Cómo guardar 00:00:06
Un montón de cosas a mogollón 00:00:07
Muy bien 00:00:09
En unas listitas 00:00:11
Y en unos conjuntos 00:00:13
¿Vale? 00:00:17
Si necesitamos orden 00:00:20
Una lista mejor 00:00:21
Pero bueno, un poquito más de computación 00:00:22
A la hora 00:00:26
De hacer los accesos 00:00:27
Las búsquedas 00:00:30
pero bueno, eso es un problema de la CPU 00:00:31
no tanto, no es nuestro 00:00:33
o si no necesitamos orden, pues un conjunto 00:00:34
ahí todo a mogollón y ya está 00:00:36
bueno, esto ya lo tenemos dominado y controlado 00:00:38
¿vale? 00:00:41
en la vida real 00:00:44
en la vida real hay otra 00:00:45
estructura que realmente 00:00:47
facilita muchísimo las cosas 00:00:49
que es 00:00:51
la estructura del diccionario de toda 00:00:53
la vida, ¿verdad? 00:00:55
es decir, si nosotros tuviéramos 00:00:57
todos los significados 00:00:59
de todo lo que existe 00:01:01
metidos en un conjunto 00:01:02
y tuviéramos que encontrar 00:01:04
el significado mesa 00:01:06
pues ostras 00:01:08
buscar ahí en el conjunto 00:01:10
todos los significados 00:01:13
del lenguaje español 00:01:15
hasta que encontremos el significado 00:01:17
que se adapta al concepto de mesa 00:01:18
sería una locura 00:01:20
¿vale? 00:01:22
¿pero qué hace un diccionario? 00:01:23
un diccionario asocia 00:01:25
cada significado 00:01:28
a una palabra clave 00:01:29
que es el término que tiene asociado 00:01:32
lo asocia a una palabra clave 00:01:34
y luego además 00:01:36
al implementar un orden 00:01:38
pero eso ya es secundario 00:01:40
al implementar un orden 00:01:41
pues nos falta la búsqueda 00:01:42
entonces si tú quieres saber 00:01:44
qué es una mesa 00:01:46
vas directamente clave 00:01:46
la clave mía de búsqueda 00:01:49
que es lo que yo quiero 00:01:50
la mesa 00:01:51
vale pues busco por esa clave 00:01:52
y por esa clave ya puedo encontrar 00:01:54
de todo 00:01:56
me encuentro su significado 00:01:57
los sinónimos, todo lo que quiero 00:01:58
lo encuentro ahí todo 00:02:00
pero todo eso que me pueda encontrar 00:02:01
significado, sinónimos, antónimos 00:02:03
traducción al hebreo, todo 00:02:06
lo tengo ahí 00:02:08
asociado a una única clave, que es mesa 00:02:09
¿qué ahora quiero eso mismo 00:02:12
pero con silla? 00:02:14
pues yo con mi clave silla me voy 00:02:16
a esa estructura de diccionario 00:02:18
y a través 00:02:20
de esa clave silla encuentro 00:02:22
todo lo que está asociado a esa clave 00:02:24
lo que es una silla 00:02:26
sus sinónimos, sus antónimos 00:02:28
pues como se dice en arameo, etcétera 00:02:30
todo lo que yo quiera 00:02:32
¿vale? entonces una estructura habitual 00:02:33
¿vale? que los objetos que nosotros manejamos 00:02:35
tengan un montón de cosas 00:02:39
pues alumno tiene un montón de cosas 00:02:40
factura tiene un montón de cosas 00:02:43
y yo a ese montón de cosas 00:02:45
le asocio una clave 00:02:47
que lo identifica de forma única 00:02:49
¿vale? esa es la idea del diccionario 00:02:51
asociar a cada uno 00:02:53
de mis objetos 00:02:55
Una clave sencillita 00:02:56
Que lo identifique de forma única 00:02:58
Entonces si cada uno de mis objetos 00:03:00
Tiene asociado una clave sencillita 00:03:02
Que lo identifica de forma única 00:03:04
A través de esa clave 00:03:05
Va a ser más fácil acceder 00:03:07
Para eliminar, para recuperar 00:03:10
Lo que sea 00:03:12
Por ejemplo yo en mi set 00:03:13
Yo aquí 00:03:15
Pues tendré, tengo aquí un montón de 00:03:16
Por ejemplo tengo aquí pues eso 00:03:20
Tengo aquí 00:03:22
Un montón de alumnos 00:03:23
con un montón de cosas 00:03:25
esos alumnos 00:03:30
entonces 00:03:31
si yo quiero encontrar 00:03:33
al alumno que cumpla no sé qué condición 00:03:35
con nombre tal, pues me tengo que meter en el conjunto 00:03:38
e ir uno por uno 00:03:40
me voy a ir en el conjunto, voy sacando el conjunto 00:03:41
este no es, este no es, este no es 00:03:43
hasta que encuentro al alumno 00:03:45
pero bueno, es una tarea un poco pesada 00:03:46
¿vale? 00:03:49
entonces, estrategia de programación 00:03:50
práctica 00:03:52
a cada alumno 00:03:53
asociarle una clave 00:03:55
a cada alumno le asocio una clave 00:03:59
que tiene que ser algo que lo identifique de forma única 00:04:02
no puede haber dos objetos con la misma clave 00:04:05
pues en el caso de alumnos 00:04:08
uno podría pensar en el NIF 00:04:10
entonces cada objeto 00:04:13
que uno de mis alumnos tiene asociada su clave 00:04:18
y ahora ya las búsquedas 00:04:20
por NIF, son mucho más sencillas 00:04:24
yo miro exclusivamente 00:04:26
esto 00:04:28
y digo, ah, este 00:04:29
pues ya está, me saco todo esto 00:04:32
no tengo que meterme en la caja mogollón 00:04:34
hasta que lo encuentro 00:04:36
¿vale? que quiero eliminar por NIF 00:04:38
¿vale? pues entonces 00:04:40
ah, es este, fuera 00:04:42
yo tiro de la clave, tiro de la clave 00:04:44
porque buscar en la 00:04:46
en la caja de claves es más fácil 00:04:48
tiro de la clave a este 00:04:50
fuera 00:04:52
¿vale? no tengo que ir sacándolos 00:04:53
ahí, hasta que encuentro el de eliminar 00:04:56
y eliminarlo 00:04:58
esa es la idea del diccionario 00:04:59
llamado en Java 00:05:01
el map 00:05:04
¿vale? map pues porque 00:05:05
mapea una clave 00:05:08
a todo su contenido, que puede ser una cosa 00:05:09
enorme, están cosas 00:05:12
entonces, en realidad un map vale 00:05:12
para guardar cosas, lo que pasa es que 00:05:16
no hereda de collection en realidad 00:05:17
si miráis la estructura 00:05:19
de jerarquía de collection 00:05:21
pues no hereda 00:05:23
de collection, map es una 00:05:25
interfaz por sí misma 00:05:27
que luego tiene varias implementaciones 00:05:29
el hash map, el link 00:05:31
el hash map, el tree map 00:05:33
tiene varias implementaciones 00:05:34
¿no es lo mismo que crisis? 00:05:36
y ahora lo vas a ver 00:05:40
entonces esta es la idea, la idea es 00:05:42
asociar a cada objeto 00:05:45
una clave única 00:05:47
¿vale? entonces si cada objeto tiene asociado 00:05:48
una clave única, ahora a partir 00:05:51
de esa clave, va a ser mucho más sencillo. 00:05:53
Las modificaciones, 00:05:56
las consultas 00:05:58
por clave 00:05:59
y las eliminaciones. 00:06:01
Esa es la idea, que yo no tenga que iterar 00:06:03
para localizar ni para nada. 00:06:05
¿Tú no tienes el map 00:06:07
en proceso, solo las claves? 00:06:09
No, ahora vamos a ver, 00:06:11
la idea es esta. Vale, ahora vamos a ver cómo se 00:06:12
implementa, cómo se 00:06:14
se implementa esto. 00:06:16
Vale, pues 00:06:19
vale, pues el map 00:06:20
es una caja de pares 00:06:23
un map es esto 00:06:25
un map es una caja de pares 00:06:27
no como una lista 00:06:30
una lista era una caja de objetos sin más 00:06:33
y un set también 00:06:38
un set era una caja de objetos sin más 00:06:40
ahí estaban todos los objetos 00:06:44
aquí con orden y ahí sin orden 00:06:45
pero bueno, eran una caja de objetos 00:06:47
un map es una caja de pares 00:06:49
Cada elemento del map es un par, son dos cosas. 00:06:52
Cada elemento del map son dos cosas, ¿vale? 00:06:56
El primer elemento del map es el que se llama clave. 00:06:59
Y el segundo es el que se llama valor. 00:07:04
¿Vale? Pues eso es lo que tiene el map. 00:07:08
Un conjunto de pares, una caja con muchos pares. 00:07:10
Y cada par va indisolublemente unido a su clave con su valor. 00:07:13
¿Vale? 00:07:18
pues esto es un map 00:07:18
clave, valor, clave, valor 00:07:21
entonces 00:07:26
el valor en sí que es 00:07:28
pues el objeto gordo, el dato que yo quiero guardar 00:07:30
el valor en sí 00:07:33
sería lo que yo 00:07:34
en realidad guardo en la lista 00:07:37
es la idea 00:07:38
el objeto gordo, el dato 00:07:40
el alumno entero, lo que yo quiera 00:07:42
y la clave 00:07:44
que está afuera 00:07:46
es aquello 00:07:47
que lo identifica de forma única 00:07:51
un if, un entero 00:07:53
lo que sea 00:07:55
entonces las claves 00:07:56
obligatoriamente 00:08:01
tienen que ser 00:08:02
únicas, si yo intento 00:08:04
meter en un map un par 00:08:06
porque en el map siempre que meta algo 00:08:08
tiene que ser un par, clave, valor 00:08:10
clave, valor, no puedo meter un valor suelto 00:08:12
o una clave suelta, no 00:08:14
clave, valor, bueno puedo meter una clave 00:08:16
asociada a un null, puedo 00:08:18
¿vale? pero no puedo 00:08:20
meter una clave null, la clave null no 00:08:22
entonces pues siempre que meta 00:08:24
en un map un par 00:08:26
las dos cosas obligatorias 00:08:27
la clave tiene que ser única 00:08:30
para que me deje meterlo 00:08:32
si trato de meter 00:08:34
un par donde la clave está repetida 00:08:36
no inserta un par 00:08:39
nuevo, lo que hace es 00:08:41
modificar el valor del que ya hay 00:08:42
ahora lo probamos con tres o cuatro ejemplitos 00:08:45
sencillos, ¿vale? 00:08:47
simplemente esto es para ver en general 00:08:48
de que va, nada más 00:08:50
vale 00:08:51
entonces 00:08:53
los valores 00:08:54
sí pueden estar repetidos 00:08:57
es decir, puede haber dos claves 00:09:00
que tengan asociados aquí 00:09:02
dos objetos iguales, el mismo 00:09:03
objeto, incluso con la 00:09:06
misma dirección de memoria, eso no es problema 00:09:08
los valores pueden estar repetidos 00:09:10
lo único que importa es que las claves no lo estén 00:09:12
vale, en un diccionario normal 00:09:14
dos palabras 00:09:16
Pueden tener el mismo significado idéntico 00:09:18
Pero son dos claves distintas 00:09:20
Hembra, mujer, me da igual 00:09:22
No has dicho que la clave 00:09:24
Es la clave primaria 00:09:27
La clave lo tiene que identificar 00:09:29
De forma única 00:09:31
Pero son dos cosas distintas 00:09:32
Tú dijiste que por un lado 00:09:34
Hay que tener una clave 00:09:37
Y por otro lado el valor 00:09:38
Cuando tú guardas en un map 00:09:40
Aquí ya no es tan importante 00:09:42
Que esté la clave 00:09:44
porque esa clave la tienes aquí 00:09:46
fuera, tú puedes hacer el diseño 00:09:48
que quieras en realidad 00:09:50
¿vale? entonces si tú vas a 00:09:51
tú has diseñado tu aplicación 00:09:54
para que los alumnos estén en un map 00:09:55
el objeto alumno, la clase alumno 00:09:58
no tiene por qué tener un NIF 00:10:00
porque ese NIF ya está 00:10:01
en la clave del map 00:10:03
¿vale? pero eso sí, si luego 00:10:05
esos objetos alumnos los usas en otras 00:10:10
colecciones, si no tiene una propiedad 00:10:12
clave primaria, pues ahí sí que sería 00:10:14
complejo, pero si solo lo usas en un map 00:10:16
no hay problema, porque esto ya hace 00:10:18
como clave 00:10:20
entonces esta estructura de aquí 00:10:20
ahora ya hace 00:10:24
que todo sea mucho más sencillo 00:10:26
es mucho más sencillo 00:10:28
manejar conjuntos de 00:10:30
alumnos, de facturas, de no sé qué, si están en 00:10:32
un map, que si están en una colección 00:10:34
sin clave asociada 00:10:36
¿vale? vamos a ver 00:10:37
cómo se 00:10:40
se usaría 00:10:41
Venga, pues a ver 00:10:44
Pues venga, ejemplo más 00:11:04
Vamos a hacer 00:11:11
Vale, pues por ejemplo, vamos a suponer que yo tengo 00:11:12
Pues ala, alumnos 00:11:51
A ver, espera, que no he hecho ningún paquete 00:11:53
Y eso, eso es muy peligroso 00:11:57
Pues yo que sé 00:12:01
Modelo, pues venga 00:12:03
Voy a trabajar con alumnos 00:12:05
venga, propiedades, nombre y nota 00:12:08
con get y set 00:12:18
lo ideal sería pues un constructor 00:12:41
un toString, un equals 00:12:42
lo de siempre, pero bueno ahorramos tiempo 00:12:44
vale, si yo fuera a usar 00:12:46
esto con list o con set 00:12:52
aquí pues de nuevo tendría 00:12:54
que plantearme, vamos a ver 00:12:56
en un list cuando tú quieras 00:12:57
cuál es tu criterio de igualdad 00:13:00
o en un set 00:13:02
cuál es tu criterio de igualdad 00:13:04
para cuando quieras borrar un alumno, localizarlo 00:13:05
pues habría que decidirlo 00:13:08
dentro de los parámetros que tenemos 00:13:10
habría que decidirlo 00:13:12
el nombre, vale, pero entonces 00:13:13
cuidado que tu aplicación no va a permitir 00:13:16
alumnos con el mismo nombre 00:13:18
¿es un problema? 00:13:20
no, no es un problema 00:13:23
es imposible que dos alumnos se llamen igual 00:13:24
imposible, pues no es un problema, tiro 00:13:26
y ya está 00:13:28
cuidado que tu aplicación sí puede ser 00:13:29
que tú tengas alumnos que se llamen igual 00:13:32
cuidado, venga pues añade 00:13:34
un if que los identifique 00:13:36
haces un equals por nif y ahora ya no tienes 00:13:37
problemas con tus list o tus set para hacer 00:13:40
remove, etcétera. Bueno, estas son 00:13:42
las consideraciones que hemos hecho hasta ahora. 00:13:44
¿Vale? 00:13:46
Bueno, aquí, aunque sería, aún así, 00:13:47
sería feo 00:13:49
dejarlo así, sin clave 00:13:50
primaria, aunque sería feo. 00:13:53
Vamos a decidir 00:13:56
por cuestiones de diseño que vamos 00:13:58
a trabajar en un map. 00:13:59
¿Vale? Pues si trabajamos en un map, 00:14:01
el nif, que es lo que lo identifica 00:14:04
de forma única, puede ser la clave. 00:14:06
Del map, con lo cual no tengo que meterlo aquí. 00:14:07
Venga, vamos a hacernos ahora nuestra aplicación. 00:14:10
Ahora ya sí, nuestra aplicación que trabaja con estos alumnos. 00:14:15
Venga, pues nuestra aplicación con el método main, este de aquí. 00:14:22
Vale, datos de mi aplicación. 00:14:33
Un map de alumnos. 00:14:36
vale, si yo quiero un map 00:14:39
el map necesita 00:14:42
dos tipos 00:14:44
el tipo 00:14:46
al que pertenece la clave 00:14:48
y el tipo al que pertenece el valor 00:14:50
no, no la he puesto 00:14:52
vale 00:14:59
vale, pues entonces 00:15:01
yo voy a usar mis alumnos en un map 00:15:03
bueno, pues entonces me voy a declarar 00:15:04
aquí van a estar mis datos, mis alumnos 00:15:07
vale, el map 00:15:09
necesita dos tipos 00:15:13
de datos 00:15:16
para instanciarse, el primero 00:15:16
es el tipo al que pertenece la clave 00:15:20
y el segundo 00:15:22
el tipo al que pertenece el valor 00:15:23
el tipo al que pertenece el valor 00:15:25
en este caso está claro, van a ser alumnos 00:15:28
y ahora 00:15:29
la clave, que va a 00:15:31
identificar de forma única 00:15:34
a cada alumno 00:15:35
a cada alumno lo va a identificar 00:15:36
de forma única 00:15:39
su NIF, por ejemplo 00:15:41
el NIF es una cadena 00:15:43
pues entonces string 00:15:45
tranquilos 00:15:47
que prisas 00:15:56
vale, con esto yo he dicho 00:15:58
mi estructura de datos 00:16:00
va a ser un par 00:16:02
un montón de pares 00:16:04
donde cada par tendrá en la clave 00:16:06
el NIF del alumno 00:16:08
y en el valor el propio 00:16:09
objeto alumno 00:16:12
Está declarado, pero bueno, vamos a instanciarlo 00:16:13
Map es la interfaz 00:16:16
Tiene varias 00:16:21
Posibles implementaciones 00:16:23
Map 00:16:25
Tiene HashMap 00:16:26
LinkedHashMap y Tremap 00:16:28
Entonces 00:16:31
Como veis 00:16:32
Casan perfectamente con HashSet, LinkedHashSet 00:16:34
Y Treset 00:16:37
¿Por qué? 00:16:38
LinkedHashSet 00:16:44
dijimos que es igual a todos los efectos 00:16:44
que HashSet, pero 00:16:46
conserva el orden de inserción. 00:16:48
Con lo cual, si tú en un 00:16:51
LinkedHashSet iteras, 00:16:52
te va a salir por el mismo orden 00:16:54
en que lo insertaste. 00:16:56
Que el HashSet no. 00:16:58
¿Vale? Pues el HashMap 00:17:00
es una posible implementación 00:17:05
la más 00:17:06
habitual. 00:17:08
El HashMap significa 00:17:13
las claves 00:17:15
se guardan en un HashSet. 00:17:17
Es lo único que significa 00:17:18
Las claves 00:17:20
¿Vale? 00:17:33
Guarda las claves en un hash set 00:17:35
Entonces 00:17:37
Eso automáticamente nos lleva a cuidadín 00:17:38
String que tenga hasco de equals 00:17:43
Ah, lo tiene, no hay problema 00:17:45
Lo tiene porque string, la clase string ya está hecha 00:17:46
Tiene hasco de equals 00:17:49
Pero bueno, vamos a ver cómo se usaría 00:17:50
Vale, vamos a empezar a introducir 00:17:55
Alumnos, ¿vale? Vamos a meter 00:17:57
Un primer alumno 00:17:59
Alumnos, aquí no es add 00:18:00
Para insertar en un diccionario o map 00:18:03
Es put 00:18:06
¿Vale? 00:18:08
Y hay que meter dos cosas, efectivamente 00:18:10
Hay que meter la clave del alumno 00:18:13
Y el alumno 00:18:16
Me voy a hacer un constructor con parámetros 00:18:18
Para poder meterlo aquí directamente 00:18:25
¿Vale? 00:18:28
Cada inserción en el map 00:18:36
Implica insertar dos cosas 00:18:38
la clave y el valor 00:18:40
vale, entonces yo aquí me he insertado 00:18:43
ahora ya mi map tiene dos cosas 00:18:46
vamos a verlo 00:18:48
num 00:18:52
tiene dos cosas pero un solo elemento, claro 00:18:58
num alumnos 00:19:01
alumnos.size 00:19:02
el size lo tiene, que es la cantidad de pares que tiene 00:19:04
si ejecutamos esto 00:19:07
main 00:19:14
vale, pues un alumno he metido 00:19:17
con los dos valores 00:19:26
Vale, voy a meter otro 00:19:27
Ahora le ponemos valores 00:19:33
O lo que sea 00:19:38
Si yo intento hacer esto 00:19:39
Esto no lo va a hacer 00:19:43
No va a meter otro elemento 00:19:48
No va a meter otro 00:19:50
Porque la clave ya existe 00:19:51
Pueden insertar 00:19:53
Claves 00:20:02
Repetidas 00:20:04
No se pueden 00:20:05
Si volvemos a ejecutar esto 00:20:07
Pues efectivamente 00:20:09
uno y uno 00:20:11
no se pueden insertar claves repetidas 00:20:14
está claro, ¿vale? 00:20:18
no te dice nada, simplemente no inserta 00:20:20
porque ya existe uno con esta clave 00:20:22
lo que acabamos de hacer 00:20:24
no te dice nada, simplemente no te lo inserta 00:20:29
vale, entonces 00:20:33
ahora, ¿cuál es la ventaja 00:20:36
de esto? que yo ahora 00:20:37
si quiero el alumno 00:20:40
de NIF, el que sea 00:20:42
Lo obtengo directamente a la primera 00:20:43
En una lista no, en una lista tenía que recorrerla 00:20:45
Hasta encontrar el alumno con ese NIF 00:20:48
¿Vale? Aquí no 00:20:50
Por ejemplo, voy a meter otro con otro NIF 00:20:52
5, 6, 7, 8 00:20:54
Tengo otro alumno 00:21:02
Este ya sí lo va a meter 00:21:04
Si yo hago aquí el system out 00:21:06
Este tercer put ya sí que sí 00:21:10
Este ya sí 00:21:14
Vale 00:21:15
vale 00:21:16
lo sustituye, en este caso 00:21:17
te crea este otro alumno nuevo vacío 00:21:24
lo sustituye 00:21:27
vale 00:21:28
entonces 00:21:30
ahora, ¿qué ventaja tiene esto? 00:21:32
yo quiero al alumno 00:21:35
de NIF 5678 00:21:36
para hacer algo con él 00:21:39
para ponerle por ejemplo una nota 00:21:40
pues ¿cómo saco yo 00:21:43
el alumno por clave? 00:21:45
pues muy sencillo 00:21:52
alumnos.get 00:21:53
y la clave que yo quiera. 00:21:58
5, 6, 7, 8. 00:22:00
¡Hala! 00:22:02
Ya tengo el alumno asociado a esta clave. 00:22:03
Ya lo tengo. 00:22:06
Y yo aquí ya le pongo el nombre que me dé la gana. 00:22:08
¿Esta primera clave no es una propiedad del alumno? 00:22:29
No. 00:22:32
No es una propiedad del alumno. 00:22:33
Es un dato del alumno, 00:22:35
pero lo tienes tú en el map 00:22:36
sacado, o sea, no lo tienes dentro de la clave 00:22:38
claro 00:22:40
este puede ser 00:22:43
este podría ser un diseño 00:22:46
¿vale? pero 00:22:48
ahora volvemos con eso 00:22:50
¿vale? este podría ser un diseño y toda la aplicación 00:22:52
podría tirar así 00:22:54
¿vale? entonces, ahora 00:22:55
luego habría que volver con eso, pero 00:22:58
entonces, esta es la principal 00:23:00
ventaja, ¿qué ocurriría 00:23:02
si yo hubiera decidido un diseño 00:23:04
en el cual mis alumnos van a una lista? 00:23:06
Pues si yo decido mi diseño 00:23:11
con un modelo que mis alumnos vayan a una lista, 00:23:13
tendría que meter, entonces, ahora ya sí, 00:23:17
el NIF aquí dentro, ¿vale? 00:23:20
O sea, imaginaos una aplicación 00:23:24
que es para ponerle nombres y notas a alumnos, 00:23:25
donde los alumnos se caracterizan por su NIF. 00:23:28
Yo decido hacerla como me dé la gana, ¿vale? 00:23:31
una posible decisión 00:23:34
mis alumnos van a un map 00:23:36
la clave el nif 00:23:37
y en el alumno por tanto ya no es obligatorio 00:23:39
que ponga el nif, no es obligatorio 00:23:42
entonces yo ya tiro así 00:23:44
cada vez que meta el alumno le meto con su nif 00:23:46
porque el alumno siempre va a llevar su clave 00:23:48
asociada, van en par 00:23:50
todo el rato, van en par, en un map van en par 00:23:52
la va a llevar asociada 00:23:54
con lo cual el alumno nunca va a perder su nif 00:23:56
no hace falta que esté aquí dentro 00:23:57
¿vale? pero porque 00:23:59
mis datos están solo en ese map 00:24:02
están solo en ese map, no hay problema 00:24:05
puedo tirar así con la aplicación, tranquilamente 00:24:07
ventaja que me he encontrado 00:24:09
que para buscar un alumno por 00:24:11
NIF, tengo el GET, facilísimo 00:24:13
si yo hiciera 00:24:15
esto con una lista 00:24:17
si yo hiciera esto con una lista 00:24:18
aquí no hay pares 00:24:21
clave valor, luego el NIF 00:24:23
tendría que ir en el alumno, por ejemplo 00:24:25
me voy a hacer el modelo 2 00:24:27
donde el alumno si tiene el NIF 00:24:28
me voy a hacer aquí el package 00:24:30
modelo 2 00:24:33
y voy a hacer mi alumno 00:24:35
¿vale? 00:24:39
a ver 00:24:45
repito 00:24:45
cuanto más tenga que repetir más tarde no vamos a ir 00:24:47
así que enteraos a la primera 00:24:50
porque si no 00:24:52
repito, vale 00:24:53
aplicación que tiene que trabajar con 00:24:56
alumnos que se caracterizan por 00:24:58
nombre nota y sunif 00:25:00
yo sé que es único 00:25:01
y lo que voy a hacer con la aplicación es ponerles 00:25:03
notas y nombres y luego recorrerlos 00:25:06
lo que yo quiera, vale 00:25:08
modelos posibles, diseños posibles 00:25:09
tropecientos mil 00:25:12
uno posible, mira 00:25:13
mis datos van a ir a un map 00:25:16
luego en mi clase 00:25:18
alumno, como en el map 00:25:20
va siempre clave, valor 00:25:22
clave, valor, la clave 00:25:24
que sea el nif, con lo cual 00:25:26
en alumno no hace falta que vaya al nif 00:25:28
como el alumno, el objeto alumno 00:25:30
con su nombre y nota, va a ir siempre pegadito 00:25:32
a la clave, siempre pegadito 00:25:34
pues no va a perder su clave nunca, ahí va 00:25:36
en el mapa, vale, pues con ese diseño 00:25:38
ya tiro, me hago mi alumno así 00:25:40
en mi main me hago yo mi map 00:25:42
de string 00:25:44
que es el nif, alumno que es el valor 00:25:46
y aquí ya meto los alumnos 00:25:48
los recupero por clave, etc 00:25:50
vale, hasta ahí está claro 00:25:52
diseño 2, no voy a usar 00:25:53
un map, diseño 2, para que veamos 00:25:57
la ventaja de usar un map 00:26:00
diseño dos, no, no voy a usar un más, mis alumnos todos a una lista 00:26:01
pues entonces 00:26:04
como los alumnos se caracterizan por tres cosas 00:26:05
NIF, nombre y nota 00:26:08
y van a la lista 00:26:10
donde no hay claves, ni hay nada 00:26:11
mi alumno tiene que tener la nota 00:26:12
perdón, el NIF, por eso estoy haciendo 00:26:15
esa otra versión, modelo dos 00:26:17
pues en mi versión modelo dos 00:26:19
mi alumno tendría que tener el NIF 00:26:21
porque va a ir a una lista y la lista 00:26:23
ni tiene claves, ni tiene nada 00:26:25
vale, pues le pongo el NIF 00:26:27
Y le añado aquí su getty set 00:26:30
Vale 00:26:32
Me voy a hacer ahora el main con este modelo 00:26:37
En mi paquete main2 00:26:40
Para que quede claro en el proyecto 00:26:42
Main2 00:26:44
Me hago el main con este modelo 00:26:47
Y me hago yo ahora 00:26:49
Mi clase main 00:26:51
Y me sale más complicada 00:26:53
Vale 00:26:57
Mi clase main que ahora no va a trabajar con un map 00:26:59
De map nada 00:27:03
Va a trabajar con una lista 00:27:03
Por ejemplo, lista de alumnos 00:27:07
newArrayList, por ejemplo 00:27:09
ala, modelo2 00:27:12
lista de alumnos, el alumno tiene dentro su 00:27:17
if, ahora 00:27:19
para añadir 00:27:21
pues nada, yo añado 00:27:22
ya sabemos como 00:27:25
pues bueno, alumno 00:27:27
a igual a, como no me he 00:27:29
hecho constructor con 00:27:31
parámetros, pues me lo va a hacer 00:27:33
apunto, pues 00:27:35
cuidado 00:27:39
que es modelo2 00:27:43
vale, pues apunto 00:27:44
setNif 00:27:49
igual a 1, 2, 3, 4 00:27:50
vale 00:27:52
el nombre me da lo mismo 00:27:55
y ahora 00:27:57
yo aquí haría, pues venga 00:27:59
a mis alumnos 00:28:00
le añado mi alumno a 00:28:01
estoy trabajando con una lista como siempre 00:28:04
vale 00:28:07
todo esto que tengo aquí lo quito 00:28:08
vale, imaginaos 00:28:10
que he añadido unos cuantos más 00:28:13
vale, entonces ahora 00:28:15
yo quiero encontrar 00:28:18
al alumno 1, 2, 3 y 4 00:28:20
con clave 1, 2, 3 y 4 00:28:22
con nif, perdón, para darle una nota 00:28:24
aquí en el caso de la lista 00:28:26
pues se me complica 00:28:28
porque tengo que recorrerla 00:28:30
y tengo que recorrerla y hacer 00:28:32
para cada alumno a 00:28:34
en alumnos 00:28:37
pues ahora ya sí 00:28:39
si a.get 00:28:40
nif 00:28:43
resulta que es igual 00:28:44
al 1, 2, 3, 4 00:28:46
o al que sea que yo esté buscando 00:28:48
o al que sea que yo esté buscando 00:28:50
¡Ah! Ya lo he encontrado. 00:28:53
Entonces ahora ya ponle la nota 00:28:55
o ponle lo que quieras. 00:28:56
Venga, un 7. 00:28:58
¿Vale? Luego, si tenemos 00:29:00
una lista y yo quiero encontrar 00:29:05
al alumno con un NIF en particular 00:29:07
para 00:29:09
hacerle algo, tengo que recorrer 00:29:11
la lista. Tengo que recorrerla. 00:29:13
O tirar del 00:29:16
Index of, que es una línea muy larga, 00:29:17
un alumno index of igual a esto, 00:29:20
y ahora ya con esta posición, 00:29:22
vete a la lista y sácamelo por esta posición, 00:29:24
ese chorizo que pusimos. 00:29:26
En cualquier caso es más complicado. 00:29:28
¿Vale? 00:29:30
Para encontrar en la lista el alumno 00:29:30
cuya clave primaria es una, 00:29:33
tengo que recorrerla. 00:29:35
Tengo que recorrerla. 00:29:36
O yo o el index of, 00:29:37
pero la tengo que recorrer. 00:29:38
¿Vale? 00:29:41
Con la estructura de mapa que he hecho, 00:29:41
me he ahorrado este recorrido. 00:29:44
con la estructura de mapa me he ahorrado esto 00:29:45
con la estructura de mapa 00:29:48
que yo quiero el 1, 2, 3, 4 00:29:50
get 1, 2, 3, 4 00:29:52
que quiero el 5, 6, 7, 8 00:29:53
get 5, 6, 7, 8 00:29:55
recupero por clave automáticamente 00:29:57
y ya con ese alumno recuperado 00:29:59
hago lo que quiera hacer 00:30:01
¿vale? 00:30:03
esa es la ventaja 00:30:06
la motivación de usar un map 00:30:08
en lugar de un conjunto 00:30:10
el tenerlos identificados por una clave 00:30:11
y ya lo recupero sin tener que iterar 00:30:14
hasta encontrarlo 00:30:16
¿vale? esa es la ventaja 00:30:17
entonces, ¿significa 00:30:20
eso que yo si trabajo con un map 00:30:31
ya en mi alumno 00:30:33
¿para qué ponerle el nif ahí 00:30:35
si total ya está 00:30:37
en la clave? hombre, aún así 00:30:40
es recomendable ponerle aquí también 00:30:42
y me diríais 00:30:44
la información la tengo duplicada 00:30:45
no pasa nada 00:30:47
porque tenerla en la clave 00:30:48
es para facilitarte los borrados 00:30:52
y las recuperaciones 00:30:53
pero está muy bien que el objeto lo tenga todo dentro 00:30:54
lo que pasa es que tú además 00:30:57
lo extraes, lo duplicas en una clave 00:30:59
para facilitar el recuperar 00:31:01
y el borrar y todo eso que veremos luego 00:31:03
lo de duplicarlo 00:31:05
es para facilitarte los accesos 00:31:08
entonces repito, aún así 00:31:10
aunque en el modelo 2 que hemos visto 00:31:11
el meter la clave 00:31:14
en el alumno no haría falta 00:31:16
porque está aquí asociado en el par 00:31:17
pues hombre, no es mala idea que esté siempre aquí 00:31:19
esa información también 00:31:22
que esté siempre aquí 00:31:23
no sería mala idea que esté aquí 00:31:26
¿por qué? porque este objeto alumno 00:31:28
a lo mejor luego se usa en otros sitios 00:31:30
¿vale? a lo mejor este objeto alumno se usa en otros sitios 00:31:33
y hombre, que esté completamente identificado 00:31:40
que esté completamente identificado está muy bien 00:31:42
vete a saber quién usa este alumno en otras partes de la aplicación 00:31:45
su NIF tiene que tenerlo 00:31:48
pero a la hora de trabajar con el map 00:31:49
es verdad que se queda 00:31:51
duplicado, se queda duplicada 00:31:53
la información 00:31:56
y claro, eso sí, tengo que 00:31:56
garantizar yo por programa la coherencia 00:31:59
el alumno que yo meta 00:32:01
aquí, debo yo garantizar 00:32:03
por programa, por código, ponérselo yo 00:32:05
fijárselo que sumirse a este 00:32:07
porque es que si no, el programa ya no tiene sentido 00:32:09
no tendría sentido 00:32:12
aunque, ¿vale? 00:32:13
entonces, está bien que yo mantenga 00:32:15
por código que yo garantice 00:32:17
la coherencia de las dos 00:32:19
informaciones, que garantice la coherencia 00:32:21
de la clave del map 00:32:23
con el NIF que está aquí dentro 00:32:25
si no garantizo yo esa coherencia, luego la aplicación 00:32:27
vete a saber qué cosas, qué resultados 00:32:30
me da, que no me cuadran 00:32:31
uy, no me cuadra, qué extraño, he buscado un alumno 00:32:33
con NIF tal y resulta que me dice que tiene 00:32:35
NIF no sé cuál, si yo que buscas otro 00:32:37
bueno, yo tengo que garantizar esa coherencia 00:32:39
por código, ¿vale? 00:32:41
Entonces, que no 00:32:44
se extrañe que la información está duplicada 00:32:45
que esté duplicada, tiene sentido porque 00:32:47
esta entidad le viene bien 00:32:49
guardarlo todo dentro 00:32:51
para otros usos, para otros métodos a los que se ha 00:32:52
pasado, para lo que sea 00:32:55
lo de que esté aquí fuera 00:32:56
es para facilitar estas cosas 00:32:59
y quien dice el get, dice el delete 00:33:02
y dice otras cosas que se pueden hacer 00:33:03
¿vale? 00:33:05
bueno, ¿queréis que paremos aquí? 00:33:07
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:
2
Fecha:
3 de marzo de 2026 - 17:30
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
33′ 12″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
516.46 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid