Saltar navegación

20250213 Colecciones_IterarMap_2 - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 13 de febrero de 2025 por Raquel G.

13 visualizaciones

Más información Transcripción

Descargar la transcripción

vamos a recorrer el map 00:00:00
de otra manera 00:00:02
¿vale? 00:00:06
de otra manera 00:00:08
que en realidad es más habitual 00:00:10
¿eh? 00:00:11
no es un iterador 00:00:14
un iterador lo puedes sacar de colecciones 00:00:17
entonces si te haces un keyset 00:00:22
pues sí, un iterador sobre las claves 00:00:23
pero un iterador en sí sobre el map 00:00:25
Pero para el lugar de literador tienes esta otra cosa 00:00:28
Vale, a ver 00:00:31
¡Silencio! 00:00:33
Eso no gusta más 00:00:39
Oye 00:00:40
Venga, a ver, bueno, pues vamos a ver otra forma 00:00:40
De recorrer el map 00:00:43
Este es nuestro map de personas 00:00:44
Que que sea trimap 00:00:47
Lo único que ha implicado es esto de aquí 00:00:49
¿Vale? 00:00:51
Vale 00:00:54
Bueno, pues entonces 00:00:54
fijaos que al ser un trimap 00:00:56
las claves se guardan en un triset 00:00:58
entonces 00:01:01
¿qué era un triset? 00:01:02
un conjunto de elementos 00:01:04
guardaditos en un árbol 00:01:06
y el triset por dentro 00:01:10
los ha guardado siguiendo un criterio 00:01:12
de orden 00:01:15
el criterio de orden del comparable 00:01:15
entonces 00:01:17
si nosotros iteramos por el map 00:01:18
vamos a ver que nos 00:01:22
va a ir sacando 00:01:24
en orden de 00:01:26
clave. 00:01:28
¿Vale? Porque 00:01:30
esto es un trimap. Luego él ha metido 00:01:32
las claves en un 00:01:34
triset. 00:01:36
Está en un triset. Cuando iteramos en un 00:01:38
triset, con un for each, 00:01:40
por ejemplo, cuando iteramos 00:01:43
en un triset, como estamos iterando 00:01:44
aquí, ¿verdad? Estamos iterando 00:01:46
por el set de claves, pues el 00:01:48
triset 00:01:50
te los va mostrando ordenaditos 00:01:51
según el orden del comparable. 00:01:54
Ya está como anécdota, me refiero. 00:01:56
La única implicación que tiene elegir un triset respecto a un 00:01:58
haset es, primera, que estás obligado a que la clase a la 00:02:01
que pertenece en los elementos del conjunto implemente el 00:02:06
comparable y que luego cuando iteras te van a aparecer 00:02:11
ordenados por ese orden. 00:02:14
Ya está, nada más. 00:02:15
Bueno, pues, entonces, otra manera de iterar por el mapa 00:02:17
de personas, por el mapa de personas. 00:02:20
Vale. 00:02:23
Pues entonces, si nosotros mirábamos los métodos que tenía el map, miramos aquí en personas los métodos que tiene el map, pues hemos llegado a uno que era entry set, así que me lo he pasado. 00:02:23
aquí, este 00:02:47
vale, el entry set 00:02:49
¿para qué sirve? 00:02:52
el entry set su objetivo es 00:02:54
oye, no puedes operar en un mapa 00:02:55
porque son pares 00:02:58
entonces tú solamente puedes operar en colecciones 00:02:59
de elementos sencillos 00:03:02
en listas o en set que tiene elementos sencillos 00:03:03
en un map no está 00:03:06
pensado el for each 00:03:08
no puedes tirar con un for each porque son pares 00:03:10
entonces el for each ¿por dónde iría? 00:03:12
¿por las claves? ¿por los valores? 00:03:13
no se puede tirar en un for each 00:03:15
en un conjunto de pares 00:03:16
vale, pues ¿qué es lo que hace 00:03:19
el entry set? coge cada par 00:03:21
y te lo mete 00:03:23
en un objeto 00:03:24
que tiene dentro 00:03:26
la clave y el valor 00:03:28
entonces eso es lo que hace el entry set 00:03:29
te genera un conjunto de objetos 00:03:32
ahora ya de objetos únicos 00:03:34
donde cada objeto 00:03:36
tiene dentro la clave y el valor 00:03:38
es decir, te hace un envolvente 00:03:41
del par 00:03:43
te hace un envolvente del par 00:03:43
en un objeto 00:03:45
y ahora tú ya como eso ya es una colección 00:03:46
de objetos sencillos 00:03:49
vas recorriendo 00:03:50
y de cada objeto ya sacas lo que tiene dentro 00:03:52
que es la clave y el valor 00:03:55
pues eso es el objetivo de este método 00:03:56
y ese 00:03:59
ese objeto que te saca 00:04:01
ese objeto envolvente del par 00:04:03
¿de qué clase es? 00:04:05
pues es de esta clase 00:04:07
de una clase 00:04:08
que se llama entry 00:04:11
entonces te devuelve 00:04:12
un conjunto 00:04:16
de objetos 00:04:18
de clase entry 00:04:20
y cada uno de estos objetos tiene dentro 00:04:22
la clave y el valor 00:04:24
entonces como ahora ya sí que tienes un conjunto de objetos simples 00:04:25
aunque tengan dentro todo lo que tengan 00:04:29
pero ya son objetos simples 00:04:30
ya puedes iterar, lo hemos iterado por toda la vida 00:04:31
pues venga, vamos a hacerlo 00:04:34
de esta manera 00:04:37
entonces 00:04:37
Pues sí, porque además tiene otra particularidad 00:04:39
Interesante 00:04:43
Vamos a sacar el entry set 00:04:43
No te precipites 00:04:45
El entry set 00:04:47
Que nos devuelve 00:04:50
Un objeto de este tipo 00:04:51
Integer 00:04:56
Porque en nuestro caso 00:04:59
Integer 00:05:00
No, era string 00:05:01
Perdón 00:05:03
String 00:05:04
persona 00:05:07
¿cómo lo podemos llamar? 00:05:10
Personas 00:05:19
Personas entry 00:05:20
yo que sé, para decir que estas son las personas 00:05:22
pero metidas en esto 00:05:24
Personas entry 00:05:26
y ahora entry, pues claro 00:05:27
habrá que importarlo 00:05:29
¿y la clase entry dónde está? 00:05:31
En java útil map 00:05:33
está, vale 00:05:34
perdona, y de un set de estos 00:05:36
claro, te devuelve un set, no una única 00:05:56
claro 00:05:58
te devuelve un conjunto de varias de estas 00:05:59
claro 00:06:01
vale, en triset 00:06:03
te devuelve el conjunto 00:06:06
de todas estas, cada una de ellas 00:06:08
cada una de ellas 00:06:10
es el objeto que tiene dentro 00:06:12
la clave y el valor 00:06:14
¿vale? 00:06:14
dime 00:06:17
a ver 00:06:17
esto tiene que ver con las clases genéricas 00:06:25
que te ibas a ver estudiado 00:06:28
en el vídeo que pone clases genéricas 00:06:30
no es el funcionamiento de los signos 00:06:32
no es signo menor y menor 00:06:34
las clases a las que acompañan 00:06:35
significa que son clases 00:06:38
a las que tú le puedes 00:06:40
particularizar el tipo de dato con el que van a 00:06:42
trabajar. Y tú solo particularizas 00:06:44
poniendo el tipo de dato entre esos símbolos. 00:06:46
Justo. Entry es un objeto 00:06:54
entry que tiene dentro 00:06:56
un string y una persona. 00:06:58
Y luego a su vez, set 00:07:01
está trabajando con ese objeto entry. 00:07:02
Eso. Con un conjunto 00:07:05
de entry. 00:07:07
Vale. Pues ahora ya como 00:07:08
esto es un conjunto, 00:07:12
de objetos de este tipo 00:07:13
ahora ya lo podemos iterar 00:07:15
entonces 00:07:18
pues para cada uno de estos 00:07:19
para cada uno 00:07:22
de estos 00:07:25
como lo queramos llamar 00:07:26
que está en este de aquí 00:07:31
pues ahora ya para cada uno de estos 00:07:32
podemos sacar 00:07:40
la clave 00:07:42
y el valor 00:07:45
porque lo tienen dentro 00:07:49
¿vale? luego es la forma más general 00:07:50
de recorrer el mapa 00:08:04
metes cada entrada 00:08:06
del mapa, o sea, cada par 00:08:08
lo metes en un objeto de este estilo 00:08:09
y ahora ya recorres ese conjunto 00:08:11
de objetos y 00:08:14
sacas lo que te interese, la clave, el valor 00:08:16
del valor, pues 00:08:18
le cambias una propiedad, lo que tú quieras 00:08:20
¿vale? 00:08:22
Entonces 00:08:26
Entry 00:08:27
lo que le ocurre es que 00:08:32
luego además tiene métodos 00:08:34
para modificar 00:08:36
incluso las cosas del mapa a través de él 00:08:41
Entry, pues el objeto Entry 00:08:43
Tiene estos dos métodos que hemos dicho 00:08:46
Get para recoger la clave que tiene dentro 00:08:47
Y esto para recoger el valor 00:08:49
Pero es que tiene también 00:08:51
Un setValue 00:08:54
Y el setValue 00:08:55
Te fija en ese objeto 00:08:57
El valor lo cambia a otra persona 00:09:00
En este caso 00:09:02
Pero es que ese objeto 00:09:03
Está sincronizado con el propio mapa 00:09:06
Entonces si yo lo cambio ahí 00:09:07
En el map personas también se cambia 00:09:09
Que esa es la ventaja que tengo, porque diríamos, jolines, vale, esta forma de recorrerlo, uy, qué susto, hola, uno podría decir, con todo el sentido del mundo, esta forma de recorrerlo está estupenda, pero yo no estoy recorriendo el propio mapa, no estoy recorriendo los pares. 00:09:12
estoy recorriendo un conjunto 00:09:35
aparte que tiene 00:09:38
estos valores aquí copiados 00:09:39
dentro, claro, entonces yo diría 00:09:41
ya para consultar bien, pero si cambio 00:09:43
el valor que está aquí dentro la persona 00:09:45
porque la clave no debería, pues entonces se pierde la esencia 00:09:47
de todo, pues el mapa no 00:09:49
¿cómo hago modificaciones en el mapa? 00:09:51
bueno, pues puedes, porque si tú 00:09:53
actualizas el value desde el propio 00:09:55
entry con set value, en el mapa 00:09:57
al que está conectado también se va a cambiar 00:09:59
¿vale? 00:10:01
es la particularidad que tiene 00:10:02
por ejemplo, vamos a hacer 00:10:05
claro, este bucle 00:10:07
vamos a hacer lo que ya tenemos aquí 00:10:08
un montón de 00:10:10
vamos a cambiar el nombre 00:10:11
de la persona que se llame con un DNI cualquiera 00:10:15
cambia nombre 00:10:17
entonces 00:10:25
la persona que tiene este NIF 00:10:26
le vamos a poner 00:10:29
este nuevo nombre 00:10:32
Y dentro de qué conjunto de datos 00:10:34
Pues de un map de personas 00:10:39
Que le vamos a pasar 00:10:41
Dentro de un map de personas 00:10:42
Que le vamos a pasar 00:10:46
También, sí 00:10:47
String 00:10:53
Persona 00:10:55
Personas 00:11:00
Vale, pues entonces 00:11:02
Tenemos que recorrer el mapa 00:11:08
Para cambiar 00:11:12
Pues nada 00:11:13
Vamos a recorrerlo 00:11:15
Como ya hemos visto 00:11:16
Lo recorremos así 00:11:19
Ahora 00:11:25
Recorremos este y decimos 00:11:29
Venga, para cada entrada de este mapa mío 00:11:33
Dentro de este de aquí 00:11:37
Ahora ya haríamos 00:11:45
Vamos a ver 00:11:49
Sí 00:11:50
Sí 00:11:50
Entry.get 00:11:54
key, entry.get 00:11:57
key resulta que es 00:12:00
igual al need 00:12:02
que me han pedido 00:12:04
de búsqueda 00:12:06
pues entonces a esta misma 00:12:07
entrada le vamos a poner 00:12:10
hay que poner una persona con otro nombre 00:12:12
entonces pues tendríamos que 00:12:16
como la persona 00:12:17
es un valor, vamos a construir 00:12:23
una persona 00:12:25
con ese nombre 00:12:26
y se la 00:12:30
y se la fijamos 00:12:32
vale 00:12:34
persona p 00:12:36
igual a new persona 00:12:39
p set nombre 00:12:42
el que me han dado, nuevo nombre 00:12:45
y p set edad 00:12:47
el que tenía 00:12:49
que el que tenía va a ser 00:12:50
entry get value 00:12:53
punto get edad 00:12:54
solo le cambio el nombre 00:12:59
vale, me he construido 00:13:00
una persona 00:13:02
persona, ¿qué pasa? 00:13:05
que no tenía constructor sin parámetros 00:13:06
bueno 00:13:08
lo acabo de crear así que 00:13:12
ahora ya lo tiene 00:13:14
vale, pues entonces 00:13:15
¿qué me he hecho? me he construido una persona nueva 00:13:18
con el nuevo nombre que me han dado 00:13:20
y la edad he dejado la que tenía 00:13:23
para eso he cogido la persona 00:13:25
antigua que estaba en el value 00:13:26
y he cogido su edad 00:13:28
¿vale? 00:13:29
Y ahora ya voy a fijar aquí que el nuevo valor sea esta persona. 00:13:34
Entonces, esto debería haber modificado el propio mapa al que está enganchado, 00:13:46
que es este. 00:13:51
Dime. 00:13:53
¿Y la otra persona no se está cambiando? 00:13:53
¿No se está eliminando? 00:13:56
¿O cuando se elimina? 00:13:57
No, se le está cambiando el valor persona. 00:13:58
O sea, la está sustituyendo por otra. 00:14:01
O sea, esta entrada tiene una clave y ahora al fijarle tú el valor, 00:14:03
el valor que tenía se queda sobre escrito 00:14:07
se queda sobre escrito 00:14:09
por eso he recuperado su edad 00:14:11
para que el cambio sea solo en el nombre 00:14:14
vale 00:14:16
entonces este valor 00:14:17
se va a tener que ver reflejado 00:14:19
aquí en personas 00:14:22
que a su vez es el que he pasado aquí 00:14:24
vamos a 00:14:26
comprobarlo 00:14:28
vale pues tenemos cambiar nombre 00:14:29
entonces me voy a hacer 00:14:31
este me voy a llamar 00:14:34
main2 para que la máquina virtual no lo 00:14:36
arranque y voy a hacer un main 00:14:38
normalito solo con esto 00:14:40
solo con esto 00:14:42
y me copio lo de 00:14:54
las personas 00:14:56
vale pues mi main ahora tiene solamente 00:14:57
un map de personas 00:15:04
con tres 00:15:05
que me voy a crear aquí con estos 00:15:06
y ahora 00:15:09
vamos a cambiar el nombre 00:15:12
esto 00:15:13
se llamaba cambia nombre 00:15:17
si a la persona 00:15:19
con el nif 00:15:28
1, 2, 3, 4, guión 0 00:15:28
que esa sé que existe seguro 00:15:34
porque existen la 0, la 1 y la 2 00:15:35
le vamos a poner como nuevo nombre 00:15:37
el que me den por aquí 00:15:40
dentro de este map 00:15:42
vale 00:15:46
le vamos a poner 00:15:48
nuevo nombre 00:15:51
para esta 00:15:55
nuevo nombre para esa 00:15:57
le damos un nuevo nombre 00:16:01
a la primera y ahora vamos a recorrer el map 00:16:03
para asegurarnos de que 00:16:05
realmente ha cambiado el nombre 00:16:06
vale, vamos a hacer el recorrido antes y después 00:16:08
y copiamos y pegamos 00:16:13
efectivamente, porque map tiene un 00:16:15
toString muy apañado 00:16:21
que el array no tiene, por ejemplo 00:16:22
el map tiene un toString 00:16:24
muy apañado 00:16:27
vale, pues vamos a ver 00:16:28
A ver si después del cambio de nombre 00:16:43
Realmente ha cambiado 00:16:45
Venga, la primera persona 00:16:46
Luis 00:16:51
Edad 2 00:16:54
La segunda persona 00:16:55
Javi, edad 3 00:16:58
La tercera persona 00:17:00
Eva, edad 6 00:17:03
Vale 00:17:05
Claro, como no tengo en tu stream en persona 00:17:06
Pues solo nos sirve para ver los nifs 00:17:09
Y no para ver si me ha cambiado el nombre 00:17:12
¿No te dice el nombre? 00:17:15
No, porque aquí me llama el toString de persona 00:17:15
Y el toString de persona 00:17:18
No lo tengo creado 00:17:20
Claro, no lo tengo creado 00:17:22
Entonces 00:17:23
No lo vamos a ver 00:17:24
Si lo ha cambiado o no lo ha cambiado 00:17:28
Pero bueno, introduzca 00:17:29
Vale, no sabemos si lo ha cambiado 00:17:30
Habría que entrar aquí 00:17:33
Entonces vamos a 00:17:34
Claro, ha cambiado el hash 00:17:35
Es que no me ha dado tiempo a verlo 00:17:41
Vamos a ponerle un toString a persona 00:17:42
Y ahora ya sí 00:17:45
Dos 00:17:59
Eva que tiene tres 00:18:00
Y Juan que tiene cuatro 00:18:03
Vale 00:18:05
Al primero de todos que se llamaba 00:18:07
Ana 00:18:09
Le vamos a llamar ahora 00:18:10
Javi 00:18:13
Vale 00:18:14
Entonces efectivamente 00:18:17
Se llamaba Ana y ahora se llama Javi 00:18:18
Vale 00:18:21
Y hemos hecho lo que tienen 00:18:22
ha cambiado y es lo que vale entonces eso nos lo ha permitido no ha permitido hacer pues este 00:18:24
objeto entry que está conectado está conectado a ese mapa entonces nos permite recorrer el 00:18:32
map para ver lo que tiene dentro cambiar las propiedades cambiar el propio objeto valor entero 00:18:41
Bueno, pues estas son 00:18:48
Todas las historietas 00:19:02
Del map 00:19:04
Y en general de las colecciones 00:19:06
Así un poquito 00:19:09
A ver, dudas, problemas 00:19:09
¿Tú tienes una duda o...? 00:19:11
Dime 00:19:14
bueno a ver 00:19:14
es que estamos recorriendo 00:19:21
o sea para recorrer un map 00:19:22
lo necesitas sí o sí 00:19:25
o sea el map no lo puedes recorrer con un 00:19:26
for each como recorremos una colección 00:19:29
tienes que recorrerlo o bien sacándote las claves 00:19:30
con el keyset o con esto 00:19:33
y esta la ventaja que tiene 00:19:34
es que además tú puedes 00:19:37
a través de él modificarlo 00:19:39
pero efectivamente si tú quieres modificar 00:19:41
el de NIF tal, pues haces 00:19:43
put, ¿vale? 00:19:45
Entonces, efectivamente, tienes toda la razón 00:19:47
que aquí hemos hecho una tontería. 00:19:50
O sea, hemos matado moscas a cañonazos. 00:19:52
Tienes toda la razón. Aquí 00:19:54
podríamos hacer directamente 00:19:55
segundinito. Podríamos hacer 00:20:00
personas.put 00:20:02
el NIF 00:20:06
que me han dado y la persona 00:20:07
P nueva. 00:20:10
claro, hemos hecho una tontería 00:20:10
y a la persona con este NIF 00:20:13
le dará este nuevo valor 00:20:15
¿vale? luego hemos hecho aquí 00:20:17
un rollo muy largo 00:20:19
¿no se supone que se 00:20:20
sobreescribe? 00:20:22
claro, es que es lo que queremos 00:20:26
pues para 00:20:27
a ver, lo hicimos 00:20:31
para verificar y confirmar 00:20:33
primero para aprender a recorrer 00:20:35
porque aquí hemos recorrido solamente para encontrar 00:20:37
el del NIF, pero es una tontería, por eso luego 00:20:39
encontramos o con GET o luego aquí con PUT. 00:20:41
Pero, 00:20:44
para ver que si yo tengo que recorrer 00:20:44
para consultar, para lo que sea, 00:20:47
pues tú puedes 00:20:50
recorrer a través de este conjunto de entries. 00:20:51
Y luego, para ver que a través 00:20:54
de este entry, tú puedes 00:20:55
modificar el valor. Si estás dentro 00:20:57
de un recorrido, ¿vale? 00:20:59
Pero, efectivamente, las funcionalidades 00:21:01
que tiran de clave, 00:21:03
es que ahí no hay que recorrer, porque la que tiran 00:21:05
de clave, pues tú ya con put 00:21:07
sobrescribes, con get la recuperas 00:21:09
las propiedades que tiran de clave 00:21:12
las que tiran de otras propiedades no 00:21:13
entonces este ejemplo que hemos puesto 00:21:15
cambiar nombre al de nif tal 00:21:17
es un poco tonto, pero si hubiéramos 00:21:19
que no nos hubiera hecho falta 00:21:21
vamos a 00:21:23
pero si hubiéramos hecho otro, que lo vamos a hacer ahora 00:21:24
de una forma más fácil 00:21:27
pues de una forma más fácil 00:21:29
habría sido esta misma 00:21:31
persona de aquí 00:21:33
nos hacemos 00:21:35
una nueva persona 00:21:38
ah no, porque tengo que localizar 00:21:40
igualmente la edad que tiene 00:21:45
no, no, no, no lo podríamos haber hecho de forma más fácil 00:21:46
porque la edad de la persona 00:21:48
ah no, no, que tontería, claro, que sí, que se me está viendo la pinza 00:21:50
vale, podríamos 00:21:52
recuperar la persona 00:21:54
porque ya tengo una p 00:22:00
la persona p1 sería en personas 00:22:01
la recupero con el 00:22:04
nif que me han dado. 00:22:07
Vale. Ahora 00:22:09
a esta persona le cambio el nombre. 00:22:11
P1.setNombre 00:22:13
y le pongo el nuevo nombre. 00:22:15
Y ahora me hago personas.put 00:22:17
nif 00:22:20
y la persona 1 00:22:21
y ya está. 00:22:24
Es lo nuestro de arriba. 00:22:27
Me cojo la persona que tiene ese nif. 00:22:29
Le cambio a esa persona el nombre 00:22:31
y la vuelvo a meter en el map 00:22:33
bajo esa clave, con lo cual 00:22:35
estaré sobrescribiendo la que estaba 00:22:37
antes. La edad es la misma 00:22:39
porque en P1 solo he retocado 00:22:41
el nombre, ¿vale? 00:22:43
Dime. 00:22:45
Porque tengo que modificar la que había. 00:22:49
La que había ya no me vale. 00:22:55
Tengo que hacer una con otro nombre. 00:22:57
¿Vale? 00:22:59
Claro, para mantener la edad de la persona que estaba 00:22:59
¿Vale? 00:23:09
Sí, de hecho 00:23:16
Más fácil todavía 00:23:17
No, guapo, no 00:23:19
Más fácil todavía 00:23:28
personas.getnif.setNombreNuevoNombre. 00:23:29
Ya está. 00:23:42
Una sola línea. 00:23:43
Claro. 00:23:45
Una sola línea. 00:23:46
A la persona con este nif, esto es la dirección de esa persona. 00:23:48
Es una referencia. 00:23:51
Pues a esa le cambio el nombre. 00:23:52
Pues se la estaré cambiando a esa misma persona. 00:23:54
Vale, vamos a hacer otro método 00:24:02
Que ahora ya sí que vamos a tener que usar el 00:24:11
Que este método es para 00:24:13
Explicarte eso 00:24:15
No, no basta 00:24:16
Vamos a hacer otro método 00:24:21
En el que vamos a tener que usar el map 00:24:27
En el entry set sí o sí 00:24:29
porque aquí realmente 00:24:30
cállate 00:24:32
hombre, pesado, que eres muy pesado 00:24:35
relájate un poco, respira 00:24:37
que no, que luego el pasillo 00:24:39
sufre, le oiríamos igual 00:24:45
venga, silencio 00:24:47
vale 00:24:53
venga, vale 00:24:58
vale, pues a ver 00:24:59
aquí hemos recorrido 00:25:02
repito, en este método 00:25:03
hemos recorrido para localizar 00:25:05
por clave, pero realmente es estúpido 00:25:08
porque para localizar por clave es que ya tengo 00:25:10
el get, localizo por clave, vale, pues vamos a hacer 00:25:12
un método en el que ahora 00:25:14
yo quiero cambiar la edad 00:25:15
de todos los que se llamen 00:25:18
Pepito, ahí no puedo hacer 00:25:20
un get por Pepito, porque Pepito no es la 00:25:22
clave, entonces ahí sí que tenemos que recorrer 00:25:24
sí o sí, vale 00:25:26
entonces voy a ponerlo aquí 00:25:27
ahora cuando lo subamos 00:25:29
no habría hecho 00:25:31
falta recorrer 00:25:33
¿puedes cambiar la clave con un getNipSet? 00:25:36
no, la clave no deberías cambiarla 00:25:41
lo que puedes es eliminar un elemento 00:25:44
con esa clave, haces un remove 00:25:48
lo eliminas y la clave también desaparece 00:25:50
se aparece el par completo 00:25:51
y luego ya te metes otra 00:25:52
Claro, pero hay que recorrer. 00:25:54
Es lo que estoy diciendo, que ahí sí que hay que recorrer. 00:26:00
Aquí hemos podido hacerlo sin recorridos. 00:26:02
Bien así o todavía más fácil. 00:26:04
Pero este otro método que voy a poner, no puedes evitar recorrer. 00:26:06
Va a tener que recorrer, porque tienes que localizar por nombre. 00:26:09
En este localizar por NIT tienes el GET. 00:26:11
Vale, pues vamos a hacer un método ahora que cumple años. 00:26:14
Venga. 00:26:23
¿Quién cumple años? 00:26:26
pues cumpleaños 00:26:27
quien se llame así 00:26:29
que pueden ser muchos 00:26:30
los que cumplen años 00:26:32
todos los que se llaman así cumplen años 00:26:33
y en qué fecha 00:26:35
pues mira 00:26:38
qué buena idea para el examen 00:26:39
que no 00:26:41
que no 00:26:44
que no 00:26:45
tranquilos 00:26:48
que rencorosos 00:26:49
Sí, porque ninguno lo habéis descargado 00:26:52
Eso seguro 00:27:00
Vale, pues a ver 00:27:01
Vamos a ver cumpleaños 00:27:04
¿Qué indica cumplir años? 00:27:06
Que hay que sumarle uno 00:27:08
A todos los que se llamen así 00:27:10
Entonces, yo aquí no puedo hacer 00:27:11
Personas 00:27:13
Y sácame 00:27:15
Todos los que se llamen así 00:27:16
No, yo aquí solamente puedo 00:27:19
sacar por clave 00:27:21
solamente puedo sacar por clave, la clave es el 00:27:22
con lo cual no puedo sacar todos los que se 00:27:25
llamen Pepito, no puedo 00:27:27
con lo cual, si el parámetro 00:27:28
de búsqueda no es la clave 00:27:31
tengo que recorrer el 00:27:33
map sí o sí, ahora aquí ya sé que no me queda 00:27:35
más remedio, vale 00:27:37
efectivamente, pues lo vamos a escribir 00:27:39
enterito para que se nos vaya quedando 00:27:41
pues me saco un set 00:27:42
de entry 00:27:44
persona 00:27:46
y ahora aquí tengo yo 00:27:52
pues mis personas 00:27:54
pero ahora ya en entry 00:27:57
y esto lo he sacado 00:27:58
de personas 00:28:01
punto entry set 00:28:02
ahora 00:28:07
como esto ya es un set 00:28:09
lo recorremos 00:28:11
pues para cada entry 00:28:12
llamémosle 00:28:15
de todos 00:28:20
mis entries 00:28:23
que son todos estos 00:28:24
¿Qué vamos a hacer? 00:28:26
¿Esta persona es la que toca cambiar la edad? 00:28:32
Vamos a ver 00:28:35
Si e.getValue 00:28:35
Que es la persona enterita 00:28:40
Muy bien 00:28:42
.getNombre 00:28:44
Equals 00:28:45
El que le toca cumplir añitos 00:28:46
Pues entonces 00:28:48
e.getValue 00:28:52
.set 00:28:56
Edad 00:28:58
Igual a la que tenía de antes 00:29:00
Más uno 00:29:03
E.getValue.getEdad 00:29:03
Más uno 00:29:09
A la 00:29:10
Más más 00:29:11
No, porque esto es una 00:29:13
Aquí tengo que pasarle un valor 00:29:18
Y más más es una sentencia 00:29:21
Bueno, aunque 00:29:22
No te devuelve 00:29:24
No, más uno 00:29:25
Vale 00:29:28
Vale, pues ya está 00:29:29
aquí hemos tenido que recorrer, porque aquí hay varios 00:29:32
y me irán 00:29:34
apareciendo por el recorrido, hay varios 00:29:36
que se llaman así, pues los tengo que ir sacando 00:29:38
y para irlos sacando tengo que recorrer 00:29:40
ahí sí que no tengo alternativa 00:29:42
si me dijeran cumpleaños el de Niftal 00:29:43
facilísimo, le saco con get 00:29:46
y le seteo su valor 00:29:48
bueno, pues 00:29:51
la persona cuyo nombre sea igual 00:29:54
a este, pues su nueva edad 00:29:56
la que tenía más uno 00:29:58
¿hemos entendido algo más? 00:30:00
bueno 00:30:09
¿Qué no entendéis a nivel completo del map? 00:30:09
No vale que me digáis, no entiendo nada del map 00:30:15
Algo concreto 00:30:17
El entry, exactamente 00:30:19
¿Qué te parece? 00:30:20
Un conjunto de objetos que quieras 00:30:22
Y que la clave 00:30:25
Entonces, te lo guardan en un conjunto 00:30:26
Y tú te cortas el conjunto 00:30:29
Y ahí tienes la clave del objeto en el mismo 00:30:30
¿Te has enterado? 00:30:33
Oye, este 00:30:36
Dime 00:30:37
No vayas a lo fácil 00:30:38
No, no lo concateno 00:30:44
Esta es la persona 00:30:49
En la que estoy parada 00:30:51
Entonces, de la persona que estoy parada 00:30:52
A ver, igual te es más fácil 00:30:55
Si nos lo planteáramos así 00:30:56
Hacemos 00:30:57
Persona P 00:30:58
Claro 00:31:00
Así se ve más claro 00:31:04
De todas maneras 00:31:07
así se ve más clarito 00:31:08
y queda más corto 00:31:11
vale 00:31:14
así es más fácil 00:31:16
a veces entenderlo y que uno no se líe 00:31:17
así es más fácil para recorrer 00:31:20
yo estoy recorriendo estos objetos 00:31:22
que tienen dentro, la clave y el valor 00:31:24
me quedo con el valor 00:31:26
que lo guardo aquí, me quedo con el valor 00:31:27
y ya está, ya ha ido el valor 00:31:30
oye, estoy parada en esta persona 00:31:31
o sea, esta persona P va tomando todas las personas 00:31:34
de mi mapa, han tomado todos 00:31:36
Esta persona P, su nombre es esta 00:31:37
Pues su edad, que sea la edad que tenía de antes 00:31:40
Más una 00:31:43
Ya está, es más fácil quizá que ir arrastrando esto todo el rato 00:31:43
¿Vale? 00:31:47
Más cosas concretas 00:31:49
Que no entendáis 00:31:50
¿Entendéis todo? 00:31:51
No, dila, dila 00:31:58
Porque os quiero demasiado 00:31:59
Y quiero que seáis los mejores 00:32:04
Dime 00:32:05
el iterator 00:32:06
claro que sí 00:32:11
pues a ver 00:32:17
el iterator estaba 00:32:18
en este main 00:32:20
en este método 00:32:22
igual es una respuesta mejor 00:32:25
vale, a ver 00:32:31
el iterator lo hemos usado 00:32:33
aquí para recorrer 00:32:35
la colección esta a GetDiscos, ¿vale? 00:32:37
GetDiscos es una colección. Vamos a hacerlo 00:32:40
en un ejemplo aparte. 00:32:41
Por ejemplo, 00:32:43
pues, 00:32:45
en este mismo ejercicio, 00:32:47
venga, no, no, vamos a hacer 00:32:51
un paquete, ejemplo iterador. 00:32:52
Vale. 00:32:53
Ejemplo, 00:32:57
sí, este proyecto 00:32:58
lo subo entero, claro, con los servicios que tenemos. 00:32:59
Vale, pues venga, vamos a hacernos 00:33:02
aquí la misma clase persona para iterar 00:33:03
en personas, esta misma 00:33:05
clase la copio 00:33:07
y la pego aquí 00:33:08
vale, tenemos aquí 00:33:10
personas 00:33:13
vale, ahora vamos a hacernos un main 00:33:15
aquí dentro de ejemplo iterador 00:33:17
vamos a hacernos 00:33:20
un main y ahora 00:33:23
vamos a trabajar con un conjunto 00:33:27
de personas 00:33:31
pues venga 00:33:32
set persona 00:33:34
y vamos a hacer que sea un triset 00:33:39
pues porque nos da 00:33:42
lo mismo la que sea, pues para variar 00:33:45
no, porque 00:33:47
como siempre se os hace raro, pues para que no 00:33:49
se os haga raro 00:33:51
venga 00:33:52
vale 00:33:55
pues ya está, tengo mi set de personas 00:33:57
vale, entonces automáticamente 00:33:59
como es un triset 00:34:01
cuidado, se me enciende la alarma de que 00:34:03
la clase persona tiene que tener un 00:34:05
método para compararse 00:34:07
entre sí, un método de orden 00:34:09
vale, pues entonces ya 00:34:11
me adelanto y pongo en mi clase 00:34:13
persona, que era esta 00:34:15
esta de aquí 00:34:17
pongo que implemente 00:34:18
comparable 00:34:22
de persona 00:34:24
al implementar comparable de persona 00:34:26
tiene que implementar 00:34:29
este compare tú 00:34:31
¿cómo los ordenamos? ¿por orden alfabético o de menor a mayor? 00:34:34
orden alfabético 00:34:39
pues venga, para ordenar por orden alfabético 00:34:41
retun nombre 00:34:43
punto compare tu 00:34:45
o punto nombre 00:34:47
ya está 00:34:49
ya está ordenado por orden alfabético de nombre 00:34:51
si fuera pues retun 00:34:53
edad menos o punto edad 00:34:56
como todo el rato 00:34:59
a ver, todo depende de tu aplicación 00:35:03
Para que la uses, para que te sirva 00:35:08
Claro, y con los números también 00:35:10
Lo tienes fácil, pero si quieres ordenar 00:35:15
Con otro parámetro extraño 00:35:17
Tienes que construir 00:35:18
Vale, pues ya está 00:35:19
Tenemos aquí nuestro main con personas 00:35:21
Y ahora ya no nos va a dar ningún problema 00:35:24
Porque las personas son ordenables 00:35:26
Luego el triset las puede ordenar 00:35:27
Y a partir de aquí ya 00:35:28
Nos da igual que sea un triset, que un haset 00:35:30
Nos da igual, todo funciona igual 00:35:32
Pues venga, vamos a meterle varias personas 00:35:34
Vamos a reutilizar este for en el que metíamos personas. 00:35:36
Ah, no, que eso estaba en un modo. 00:35:39
Sí, vamos a meter tres personas. 00:35:42
Voy a reutilizar este for, cambiando el put por el add. 00:35:44
Vamos a meter tres personas. 00:35:51
Add new persona. 00:35:55
Venga, con nombre y edad. 00:36:00
Vale, pues ya está. 00:36:02
Tengo un set con tres personas. 00:36:03
con nombre y edad las que me den por teclado 00:36:04
y ahora 00:36:07
vamos a recorrer esta colección 00:36:09
de personas, con el for each está claro 00:36:12
facilísimo, pero para variar 00:36:14
vamos a recorrerla con un iterador 00:36:16
un iterador es un objeto aparte 00:36:17
que se convierte en una especie de puntero 00:36:19
señalador de los otros 00:36:22
y yo le puedo coger para a través de él ir cogiendo 00:36:23
tú este, este, este, este 00:36:26
pues venga, el iterador es un objeto aparte 00:36:27
de esta clase 00:36:30
que yo le digo, oye tú iterador 00:36:30
¿qué tipo de objeto vas a apuntar? 00:36:33
voy a apuntar personas porque voy a ser un iterador 00:36:36
de esta colección personas 00:36:38
vale, pues llámale al iterador 00:36:39
como te dé la gana 00:36:42
y ahora vamos a instanciar 00:36:43
un operador que apunte aquí 00:36:46
porque cada iterador 00:36:47
apunta a una colección 00:36:50
un iterador apunta 00:36:52
a una colección concreta 00:36:54
puedo tener muchos iteradores, cada uno apuntando 00:36:55
a una colección distinta 00:36:58
¿a qué colección queremos que apunte? 00:36:59
a personas 00:37:01
pues lo extraigo entonces con este método 00:37:02
bueno pues ya he construido 00:37:06
un objeto iterador 00:37:09
que importo dejaba útil 00:37:12
si si si para cualquier colección 00:37:13
sento iterator 00:37:22
ah es que he puesto iterador 00:37:23
vale vale 00:37:24
vale pues este objeto que he creado aquí 00:37:25
me vale para recorrer la colección. 00:37:34
Bueno, pues 00:37:37
¿cómo recorremos la conexión? Pues con un while. 00:37:38
Y ahora, 00:37:41
iterador. 00:37:42
¿Tienes todavía un siguiente 00:37:44
al que apuntar? Porque el iterador 00:37:46
inicialmente se queda apuntando 00:37:48
antes que el primero 00:37:50
de cualquiera de ellos. 00:37:52
El iterador es como si los pusiera en fila, aunque sea un conjunto. 00:37:54
Da igual, los pone en fila. 00:37:56
Esa fila es al azar. 00:37:58
Bueno, no es al azar, pero como si lo fuera para nosotros. 00:38:00
es como si los pusiera en fila 00:38:02
y el iterador se queda apuntando antes del primero 00:38:04
y el hashness me dice 00:38:06
si tiene uno 00:38:08
por delante todavía el que apuntar 00:38:09
si, tienes uno por delante 00:38:12
vale, pues venga, voy a apuntar a él 00:38:14
¿cómo avanzamos el iterador para que vaya apuntando? 00:38:16
pues con ese 00:38:19
it.next 00:38:20
me devuelve el objeto persona 00:38:22
y yo pues lo guardo por ejemplo 00:38:24
aquí 00:38:26
vale, entonces 00:38:27
cada iteración de este bucle 00:38:30
P se va quedando 00:38:33
con una persona distinta 00:38:35
entonces este bucle es idéntico 00:38:36
a haber hecho esto 00:38:38
idéntico 00:38:40
este P aquí 00:38:47
es el mismo que el P de aquí 00:38:49
igual, este P es cada uno 00:38:51
de los de mi set 00:38:54
y este P es cada uno de los de mi set 00:38:55
luego esto 00:38:58
y esto es lo mismo 00:38:59
entonces hago lo que sea 00:39:00
con P y aquí lo mismo. 00:39:04
Hago lo que sea 00:39:09
con P. Cambiarle su 00:39:10
valor, mostrarlo, lo que yo 00:39:13
quiera. Me da lo mismo esto 00:39:15
que esto. Voy obteniendo 00:39:17
los sucesivos P. 00:39:19
¿Vale? 00:39:21
¿Por qué hemos 00:39:23
planteado esta manera de recorrer? 00:39:25
Porque si tú lo que quieres 00:39:27
hacer aquí dentro resulta que es 00:39:29
borrar este P y sólo 00:39:30
en ese caso quieres borrar este P, 00:39:33
como lo hagas aquí la has liado 00:39:34
si tú quieres borrar 00:39:37
si resulta que ese lo que sea 00:39:38
es borrar ese p 00:39:40
pues tú harías personas remove 00:39:41
harías eso 00:39:45
y te quedaría tan ancho 00:39:47
lo que yo quiero hacer con este p es remove p 00:39:49
esto es lo que nos da 00:39:52
un error de concurrencia 00:39:54
yo no puedo 00:39:56
plantearme borrar objetos 00:39:58
que están recorriéndose dentro del for each 00:40:00
entonces 00:40:02
esto 00:40:04
menos 00:40:05
eliminar. 00:40:08
Esto da una excepción 00:40:13
concurrent bla bla bla. 00:40:15
Esto no. 00:40:20
Vale. 00:40:22
Entonces, para este caso concreto 00:40:23
recurrimos a este bucle. 00:40:25
Recurrimos a este bucle. 00:40:28
Recurrimos a este bucle. 00:40:30
Y claro, aquí lo que no haríamos sería esto. 00:40:31
Porque entonces no hemos ganado nada. 00:40:33
No haríamos 00:40:35
personas.remove p 00:40:36
si vuelvo a hacer esto 00:40:39
estoy en las mismas, no, aquí lo que hacemos 00:40:41
es borrar a través de it 00:40:43
entonces para borrar este p 00:40:44
como este p está enganchado, apuntado 00:40:48
a través de it, como está enganchado 00:40:51
pues puedo aprovecharlo y decir 00:40:53
tu it.remove 00:40:54
y esto ya no me da ningún problema 00:40:59
esta persona p habrá quedado borrada 00:41:03
pero la he borrado a través de it 00:41:04
la he borrado a través de it, no la he borrado 00:41:06
a través de esto 00:41:08
Sí, en este bulgo estáis borrando todas 00:41:09
Pero bueno, es para poner un ejemplo 00:41:12
Si lo metiéramos en un if, pues borraríamos solo a GQP 00:41:14
En cierta condición, lo que sea 00:41:16
Pues depende de la condición 00:41:18
Si tú quieres borrar solo 00:41:21
Claro 00:41:23
Pues si p. 00:41:25
Voy a, vamos a borrar 00:41:27
Vamos a borrar 00:41:29
A todos los jubilados 00:41:31
Porque no valen para nada 00:41:32
Según vosotros 00:41:34
Claro 00:41:37
Pues ya está 00:41:39
Puedes poner lo que te dé la gana 00:41:40
Depende de lo que te pida la aplicación 00:41:52
Entonces esto 00:41:55
Te daría problemas gordos 00:41:56
Tú no puedes borrar con un remove 00:41:59
Dentro de un for each 00:42:01
Salvo porque coincida de la puñetera casualidad 00:42:02
De que la única 00:42:05
que vas a borrar es la última 00:42:07
en ese caso 00:42:09
solo en ese caso el for ya ha soltado 00:42:11
el recurso, no hay problema 00:42:13
pero no sabemos si 00:42:14
es solo la última la que hay que eliminar 00:42:17
con lo cual nunca lo haríamos así 00:42:19
esto mal, esto bien 00:42:20
eso 00:42:23
esto bien 00:42:25
podemos borrar a través de it 00:42:27
bueno pues este es 00:42:29
el interés que tiene 00:42:31
recorrer por un iterador 00:42:33
si además quieres borrar 00:42:34
Si no, con un for each 00:42:36
Pues vas haciendo lo que te dé la gana 00:42:39
¿Vale? 00:42:41
Más dudas 00:42:46
Concretas 00:42:47
Vale, pues 00:42:50
Mañana más 00:43:02
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:
13
Fecha:
13 de febrero de 2025 - 13:15
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
43′ 09″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
192.42 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid