Saltar navegación

20250213 Colecciones_IterarMap_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 13 de febrero de 2025 por Raquel G.

14 visualizaciones

Más información Transcripción

Descargar la transcripción

Venga, ejercicio 4, ejercicio 4, finish, vale, venga que son menos 10, vale, a ver, este que es muy cortito y muy rápido de hacer, porque no hay que declarar clases ni nada, es para probar un poco como se itera por el map y ya está. 00:00:00
Realiza una aplicación que trabaje con nombres 00:00:43
Y NIF de personas 00:00:45
A ver, vamos a hacer al menos una clase persona 00:00:48
Porque es que si no 00:00:50
Esto se queda muy descafeinado 00:00:52
En lugar de que trabaje con los nombres 00:00:55
Cada NIF que esté asociado a una persona 00:00:57
Con sus datos 00:00:58
Y así ya 00:00:59
En el examen va a quedar todo muy claro 00:01:03
No, no, no 00:01:05
A ver, lo que pasa es que 00:01:09
vosotros sois más listos 00:01:12
de lo que estos ejercicios piden 00:01:15
entonces pues hombre, los modificamos 00:01:16
en el examen se pedirá exactamente lo que quiero que hagáis 00:01:18
vale, pues venga, vamos a hacer 00:01:21
el ejercicio 4 00:01:23
un pelinín tuneado 00:01:24
sí, vamos a hacer la clase 00:01:26
persona 00:01:29
la clase 00:01:29
persona que las 00:01:35
personas pues se caracterizan 00:01:36
por 00:01:39
su nombre 00:01:40
y vamos a ponerle 00:01:43
ahí dije que el anterior 00:01:48
lo íbamos a cambiar a Trisita a ver que cambiaba 00:01:50
algo, pero lo vamos a hacer aquí con Trima 00:01:52
yo creo 00:01:54
y vamos a poner 00:01:55
venga, algo para poder ordenar 00:01:58
con orden natural 00:02:02
la edad y ya está 00:02:03
el nif lo vamos a sacar porque va a ser la clave del par. 00:02:10
Entonces, siempre, hasta ahora hemos hecho siempre ejemplos. 00:02:15
La clave está dentro de, pues, lo vamos a sacar. 00:02:17
Venga. 00:02:21
Hacemos el constructor. 00:02:23
Y el get is set. 00:02:28
¡Hala! 00:02:34
Pues, esta aplicación trabaja con personas que tienen nombre y edad. 00:02:36
Vale. 00:02:40
entonces esta aplicación 00:02:40
este modelo es un poco confuso 00:02:42
pero si yo trabajo con muchas personas a mogollón 00:02:44
habrá muchas personas que se llamen igual 00:02:46
y tengan la misma edad seguramente 00:02:48
entonces si yo las meto todas a mogollón ahí 00:02:49
pues 00:02:52
¿cómo las puedo distinguir? 00:02:53
por nombre no las puedo distinguir 00:02:56
por edad no las puedo distinguir 00:02:57
por el NIF 00:02:59
pero es que resulta que el que 00:03:01
hizo esta entidad 00:03:04
no admite retoques porque esta entidad 00:03:05
ya se está usando 00:03:08
en tu aplicación no 00:03:09
tienes que solucionar el tema 00:03:14
a ver, esta clase no la puedes tocar 00:03:16
porque esta clase aparte de esto tiene muchas historias 00:03:18
y tú no tienes acceso a ella, de hecho no tienes ni el código 00:03:20
eso, muy bien 00:03:22
de hecho no tienes ni el código fuente, ni lo tienes 00:03:24
no tienes ni el código fuente 00:03:26
vale 00:03:29
pero tú tienes la restricción 00:03:29
de que tú tienes que poder distinguirlas por NIF 00:03:32
¿qué haces? 00:03:34
pues un map, no te queda más remedio 00:03:37
que decir, ah, vale, entonces en lugar de meterlas 00:03:38
en un conjunto 00:03:40
lo meto en un 00:03:41
map y en un map ahora ya 00:03:44
cada uno lo asoció a un 00:03:46
¿vale? Uno podría 00:03:48
decir, podría 00:03:50
decir también, a ver si yo 00:03:52
quiero distinguir a las personas que se 00:03:54
llaman igual y tienen la misma 00:03:56
edad, uno podría decir 00:03:58
silencio, a ver 00:04:00
si os distraéis y no os enteráis 00:04:02
luego lloráis 00:04:04
vale, entonces uno podría también 00:04:05
resolver esta situación diciendo 00:04:08
bueno, pues voy a echar una lista 00:04:09
como una lista las puedo distinguir por posición 00:04:11
pero ostras, que feo eso 00:04:14
porque entonces tienes que llevar el registro 00:04:16
de a cada persona 00:04:18
en qué posición la pusiste 00:04:20
si la pusiste en la posición 8 00:04:21
y si luego resulta que tú eliminas 00:04:23
de tu lista a la que está en la posición 3 00:04:26
la de la 8 te ha pasado a la 7 00:04:28
entonces sería un desmadre 00:04:30
el gestionar cada persona en qué posición está 00:04:32
para poder distinguirlas 00:04:34
y saber, sería un lío 00:04:36
Entonces, la solución de, como yo quiero personas de mismo nombre y misma edad que coexistan en mi colección, meterlas en una lista y distinguirlas por posición, esa solución es un galimatías, ¿vale? Entonces, ¿cuál es mejor solución? Voy a asociarles una clave a cada una de ellas y lo meto en un mapa y ya está, esa es la solución ideal, ¿vale? 00:04:37
¿Qué clave? Pues encima una clave con sentido 00:05:01
Pues el nif, por ejemplo 00:05:03
Pues venga, ahora ya nos hacemos 00:05:05
Nuestro main 00:05:07
Vale, pues yo voy a trabajar con un montón 00:05:08
De personas, ordenándolas, metiéndolas 00:05:16
Sacándolas, haciendo lo que tengan que hacer las personas 00:05:18
Pues por ejemplo, las personas 00:05:20
Van a saludar, para que puedan hacer cosas 00:05:24
En la iteración 00:05:26
Pues vamos a hacer que las personas 00:05:27
Saluden 00:05:30
pues diciendo 00:05:33
hola, soy 00:05:37
este 00:05:39
y tengo 00:05:42
años 00:05:49
vale 00:05:57
esto es como en Alcohólicos Anónimos 00:05:57
se van a ir presentando así 00:06:01
hola, soy Pepito 00:06:02
pues igual, es una aplicación 00:06:05
en Alcohólicos Anónimos han sido muchos años 00:06:07
allí 00:06:09
Ostras, pues no está mal pensado 00:06:10
A ver, entre una y otra 00:06:26
me lo pones difícil, pero casi 00:06:29
A ver, si tengo que elegir 00:06:31
me lo pones difícil 00:06:34
pero casi elijo el cristianismo 00:06:35
es difícil pero yo elijo esa 00:06:37
vale 00:06:44
venga 00:06:45
pues ya está, saludan 00:06:47
vale, pues entonces vamos a meter aquí a nuestros 00:06:49
elementos 00:06:51
entonces 00:06:52
clave, hemos dicho que el nif 00:06:54
el nif, un stream 00:06:57
valor 00:06:59
elemento, la persona 00:07:01
pues ya está 00:07:03
pues porque 00:07:04
a mi aplicación le viene bien distinguir por nif 00:07:09
porque el nif es un dato de la aplicación 00:07:12
es el dato que me va a dar el usuario 00:07:14
y el nif es un string 00:07:15
y ahora aquí es donde yo ya 00:07:17
decido que quiero que sea un hash map 00:07:20
un trimap, vamos a decirle un trimap 00:07:22
para perderle miedo a los árboles 00:07:24
no pasa nada 00:07:26
ya, ya, ya 00:07:27
que me estás regañando 00:07:34
que sí, que sí 00:07:36
que se me ha olvidado 00:07:38
se me ha olvidado 00:07:39
vamos, en un examen 00:07:41
me plantáis eso ahí sin el main en medio 00:07:47
y vamos 00:07:48
me pongo como una fiera 00:07:52
pues voy abriendo las llaves del main 00:07:54
que no se ha abierto 00:07:56
venga, pues el map lo importamos 00:07:57
vale, pues entonces 00:08:09
desde el momento en que yo he elegido 00:08:12
trimap 00:08:14
lo único que me viene a la cabeza 00:08:15
es, ojo 00:08:18
que entonces 00:08:20
¿Trimap no habría que hacer 00:08:21
como el método para...? 00:08:26
¿Pero dónde? 00:08:27
¿El comparable? 00:08:27
El comparable. 00:08:28
No. 00:08:31
Trimap significa que las claves 00:08:33
se guardan en un triset. 00:08:35
Las claves, no los valores. 00:08:38
Es verdad. 00:08:39
Y HashMap significa que las claves 00:08:40
se guardan en un hashet. 00:08:43
Luego, Trimap, si yo he seleccionado Trimap 00:08:45
porque es muy eficiente por dentro, 00:08:47
se supone, pues entonces 00:08:49
me voy corriendo a la clase de las claves 00:08:51
y digo, ¿esta es 00:08:53
comparable? Hombre, por supuesto 00:08:55
no va a ser comparable, que dice String no sería tan 00:08:57
cutre de no hacer 00:08:59
la que implementa la comparable, claro 00:09:01
implementa comparable, tiene un 00:09:03
compare to por ahí abajo en algún lado 00:09:05
pues me despreocupo 00:09:07
Claro 00:09:08
¿Qué le pasa a este? 00:09:12
alguno habrá habido 00:09:21
que haya tenido tentaciones 00:09:24
bueno pues ya está 00:09:26
y ahora 00:09:29
y ahora aquí ya 00:09:30
que me pide este que haga 00:09:32
vamos a hacer lo que nos dé la gana hacer 00:09:34
vamos a insertar 00:09:36
personas, vamos a estar en un 00:09:39
en un bucle localizando 00:09:41
personas, vamos a hacer cosas 00:09:43
porque esto que nos pide 00:09:44
bucles 00:09:46
para introducción 00:09:47
de muestra del NIF. 00:09:51
Vale, pues venga. 00:09:53
Vamos, antes que nada, a meterle personas 00:09:55
al este. Y vamos a iterar 00:09:57
para que saluden. Ahí vamos a ver la iteración. 00:09:59
Y luego ya vamos a ver la parte 00:10:02
esta de pedir nombres y que te diga 00:10:03
cuántas hay con ese nombre. 00:10:05
Pues hala, venga. 00:10:07
Vamos a añadir personas. 00:10:09
Venga, vamos a añadir 00:10:15
10 personitas. 00:10:16
pues personas 00:10:24
punto put 00:10:39
el nif lo vamos a construir 00:10:40
pues un, dos, tres, cuatro 00:10:45
concatenado con un guión 00:10:46
el i este de aquí 00:10:50
venga, vamos a construir el nif así 00:10:52
para que sea distinto 00:10:54
y las personas 00:10:55
pues yo que sé 00:10:57
una persona con cualquier 00:10:59
nombre, ya está 00:11:02
para que los nips sean distintos 00:11:03
porque las claves tienen que ser distintas 00:11:10
de todas formas vamos a 00:11:12
en lugar de 10 00:11:13
vamos a poner menos y vamos a meterlo por teclado 00:11:14
es que si no esto queda más feo que yo que sé 00:11:17
entonces 00:11:19
vamos a new persona 00:11:21
y le ponemos 00:11:23
el nombre y la edad leídas por teclado 00:11:24
leer punto cadena 00:11:27
y ahora 00:11:31
leer.edad 00:11:33
y le decimos aquí 00:11:37
que nombre y edad 00:11:42
vale, y ahora tenemos que meter 00:11:49
y persona, ¿qué pasa? que no tenía un constructor 00:11:54
nombre y edad, sí que está el constructor 00:11:56
entonces, ¿por qué no me deja? 00:12:00
new persona 00:12:02
leer cadena, leer entero 00:12:08
este punto y coma está aquí 00:12:10
muy raro 00:12:14
vale 00:12:15
pues ya está, un bucle, 10 no porque son muchas 00:12:16
vamos a poner 3 00:12:20
vale 00:12:22
y ahora ya está 00:12:23
vale, pues ya está, he metido 00:12:26
3 personas, recordad 00:12:28
el put 00:12:30
si yo repitiera una clave 00:12:31
no se metería a esa persona 00:12:34
sino que se sobreescribiría 00:12:36
en la persona con ese nif 00:12:38
el valor nuevo, ya está 00:12:40
vale, eso mismo 00:12:42
y me falta aquí una llave 00:12:45
vale, pues ahora vamos a iterar 00:12:48
vamos a iterar por el map 00:12:50
vale, aquí no hay un for each que valga 00:12:52
aquí no hay un for each porque esto no es 00:12:54
una sola, en el for each 00:12:56
siempre ponemos, para el tipo 00:12:58
que sea 00:13:00
en la colección no sé qué 00:13:01
pero claro, es que el tipo 00:13:04
aquí cuál es, es string, es persona 00:13:06
tengo dos cosas, son pares 00:13:08
entonces no puedo iterar por un for each 00:13:09
tengo que convertirlo a hacer algo 00:13:11
para que pueda ya iterar por un for each 00:13:14
en un único tipo 00:13:16
sea string, sea persona 00:13:17
bueno, pues tenemos dos posibilidades interesantes 00:13:19
que nos vienen dadas 00:13:22
a través de los métodos de map 00:13:24
entonces si miramos a ver 00:13:25
los métodos 00:13:27
de map 00:13:30
vamos a coger personas 00:13:31
y tiene, por ejemplo 00:13:34
vale, bueno 00:13:36
clear, que es borrar entero 00:13:38
contains key, me devuelve 00:13:40
true o false, si existe algún 00:13:42
par con esta clave, vale 00:13:44
contains value, me devuelve un true o false 00:13:46
si existe algún 00:13:48
valor, alguna persona igual a 00:13:50
esta, igual a esta según 00:13:52
el equals, que no tenemos puesto 00:13:54
el equals, en triset 00:13:56
ahora mismo vamos a dejarlo porque es la segunda forma de iterar 00:13:58
me devuelve una cosa rarísima 00:14:01
set entry bla bla bla, ahora la desentrañamos 00:14:02
vale, get 00:14:05
me devuelve el objeto 00:14:07
con esa clave 00:14:09
tiene métodos que están muy bien 00:14:10
isemptis y está vacía 00:14:12
key set, vale 00:14:14
key set me devuelve un conjunto 00:14:16
solo con las claves 00:14:19
vale, pues es la forma más fácil 00:14:20
cojo un conjunto por las claves 00:14:23
y ahora ya hay cero por las claves 00:14:25
Y para cada clave cojo el valor con get 00:14:27
Pues ya está 00:14:28
Esa sería una de las maneras más sencillas de iterar 00:14:31
Que sería 00:14:33
Me hago yo un conjunto con las claves 00:14:34
Eso lo puedes guardar en cualquier cosa 00:14:38
En un set 00:14:39
En un set de enteros 00:14:40
Perdón, de string 00:14:42
Porque las claves son string en este caso 00:14:43
Tiene que ser un set 00:14:45
Sí, tiene que ser un set 00:14:48
Porque xset te da el 00:14:51
Vale 00:14:52
Las claves 00:14:54
pues ya está 00:14:56
tengo un set con las claves 00:15:00
que me lo devuelve el método 00:15:04
keySet y ahora ya como esto es un set 00:15:06
ya sí que puedo iterar 00:15:09
y ahora para cada clave de tipo 00:15:10
string, para cada clave 00:15:13
que está en todas las claves 00:15:15
ahora ya 00:15:16
sí que podemos sacar el objeto con esa clave 00:15:18
entonces ¿cómo sacamos un objeto 00:15:20
de una clave determinada de un map? 00:15:22
pues con el método get 00:15:25
el método get, le pasamos la clave 00:15:26
y me devuelve 00:15:29
el objeto persona 00:15:32
y ahora con este objeto persona 00:15:33
pues en este caso, ¿qué vamos a hacer? pues saludar 00:15:36
pero podríamos hacer cualquier otra cosa 00:15:38
lo que está claro es que este es 00:15:39
mi objeto persona con esa clave 00:15:42
lo puedo guardar en una variable 00:15:43
hacer con ella lo que quiera 00:15:46
pues ya está 00:15:47
no, no, no, porque tú aquí 00:15:48
borras por clave 00:15:54
Claro, tú aquí remove y le pasas la clave 00:15:55
¿Vale? Borras por clan 00:15:57
Entonces 00:15:59
Y ya está 00:16:00
Entonces si ejecutamos 00:16:03
Esto, pues esto 00:16:04
Nos 00:16:07
Saludarán los tres 00:16:08
Vale, pues el primer nombre 00:16:10
Pepe con cuatro años 00:16:14
El segundo nombre 00:16:17
Juan con nueve 00:16:19
Y el tercero Ana con doce 00:16:20
Pues ya está 00:16:23
¿Vale? Aquí están todos 00:16:24
vale 00:16:26
vamos a dejar para después del récord la otra 00:16:39
iteración, vamos a ver 00:16:45
que queremos ver aquí por ejemplo 00:16:46
cuántas personas 00:16:48
de este set se llaman 00:16:51
Ana para que nos digan sus NIF 00:16:53
vale 00:16:54
es decir, le vamos a decir 00:16:57
en este main, dame un nombre 00:17:00
dame un nombre 00:17:01
y ahora leemos el nombre 00:17:07
de la persona 00:17:12
vale, y ahora queremos que 00:17:13
el ejercicio, ahora queremos que lo que 00:17:20
nos haga es iterar por el 00:17:22
map para encontrar todos 00:17:24
los elementos cuyo nombre 00:17:26
sea igual que este y me 00:17:27
muestre el nif de cada uno de ellos 00:17:30
a ver cuantos nifs hay para el mismo nombre 00:17:31
por ejemplo, que es justo lo que me pide 00:17:33
el ejercicio, me pide esto 00:17:36
lo que pasa es que lo único que me añade 00:17:37
es que me meta esto en un bucle que esté todo el rato 00:17:39
haciéndolo, pide nombre, pide nombre, pide nombre 00:17:41
hasta que tú le pongas fin, pero esto es lo que te pide 00:17:43
metido en un bucle 00:17:45
pues ahora ya tenemos que recorrer el map 00:17:47
pues ya tengo 00:17:49
este keyset sacado 00:17:51
pues venga, voy a recorrer 00:17:53
las claves 00:17:55
y ahora ya, pues por ejemplo 00:17:59
para dejarlo claro, vamos a sacar el objeto 00:18:01
persona con esa clave 00:18:03
mi persona 00:18:05
p va a ser igual a 00:18:07
personas.get 00:18:09
con esa clave 00:18:11
clave 00:18:12
y ahora 00:18:14
que esta persona 00:18:15
resulta 00:18:18
que p 00:18:21
su nombre 00:18:21
resulta que es 00:18:23
igual al que me han dicho 00:18:27
pues entonces 00:18:29
vale 00:18:32
entonces necesito 00:18:33
ahora la clave 00:18:35
de este 00:18:38
Vale 00:18:39
O sea, lo que necesito es que la tengo aquí 00:18:41
Lo único que tengo que mostrar es la clave 00:18:44
Vale, pues entonces de hecho aquí las llaves 00:18:45
Pues es este 00:18:48
El need 00:18:51
Y ya está 00:18:59
Clave 00:19:01
Pues esta es una forma de iterar, cojo las claves 00:19:02
E itero 00:19:08
Por todos los objetos 00:19:09
Que se corresponden a todas 00:19:11
y cada una de las claves y ya con ello 00:19:14
puedo construir o hacer lo que sea 00:19:15
vale, y si damos 00:19:17
aquí, pues 2 00:19:20
por ejemplo vamos a meter 00:19:21
a Ana que tiene 12 00:19:23
vamos a meter a Ana 00:19:28
otra vez que tiene 00:19:30
toma ya, ala 00:19:34
la has cagado 00:19:37
y ahora vamos a meter a Juan 00:19:39
que tiene 54 00:19:42
Están aquí 00:19:44
Ana 00:19:46
12, Ana 45 y Juan 54 00:19:47
Vamos ahora 00:19:50
A buscar cuantos 00:19:52
Anas hay 00:19:54
Pues hay dos anas 00:19:56
Con los dos nif 00:19:58
Este y este 00:19:59
Vale 00:20:00
Vale, pues esta forma de iterar 00:20:02
Nos puede ser útil a veces 00:20:11
Vale 00:20:12
Pero tenemos que ver la otra 00:20:15
La de ese entry set 00:20:17
y eso queda para después del recreo 00:20:19
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:
14
Fecha:
13 de febrero de 2025 - 13:14
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
20′ 27″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
92.84 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid