Saltar navegación

20260211 Colecciones_Set_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 15 de febrero de 2026 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Pues efectivamente 00:00:00
Muy bien traída a colación la pregunta 00:00:03
Porque nosotros 00:00:04
Hemos usado aquí el remove 00:00:06
Alegremente 00:00:08
Asumiendo que lo que el hashed va a hacer 00:00:10
Va a ser buscar el que sea 00:00:12
Igual a este y borrarlo 00:00:14
Pero hemos dicho el igual a 00:00:16
Así 00:00:18
Muy alegremente, sobre la marcha 00:00:19
Claro, la pregunta es 00:00:22
¿Para el hashed significa igual a 00:00:24
Lo mismo que para nosotros? 00:00:26
Bueno, pues en este caso sí 00:00:28
Porque es que estamos hablando de string 00:00:30
Y el criterio de igualdad en string 00:00:32
Es que ya está 00:00:34
Entonces 00:00:36
Es decir, string 00:00:37
Ya tiene implementado lo que hashed 00:00:40
Necesita para hacer la igualdad 00:00:42
¿Y qué es lo que necesita? 00:00:44
La sucesión de hashcode e equals, las dos 00:00:46
Entonces si abrimos 00:00:48
String 00:00:50
La clase string 00:00:51
Pues tiene aquí 00:00:55
¿Veis? La clase string 00:00:57
Esta es la clase string 00:01:05
¿El qué? 00:01:07
Ah, control F 00:01:12
Y me sale la ventanita esta 00:01:13
Tiene este método 00:01:16
Sobrescrito, la clase string 00:01:18
Lo tiene aquí sobrescrito 00:01:20
Miraos que mono es 00:01:22
Lo tiene aquí, no lo hemos tenido que hacer nosotros 00:01:23
Y también tiene el equals 00:01:26
Equals 00:01:28
que no me lo 00:01:34
que que hambre 00:01:36
que quieres decir con eso 00:01:41
más 00:01:42
una pregunta 00:01:53
con código del hash 00:01:56
pero harías un código 00:01:59
identificador 00:02:00
a ver 00:02:01
bueno a saber 00:02:05
donde está el equals aquí pero a ver todos sabemos 00:02:08
que string tiene el equals 00:02:10
implementado que va por igualdad de caracteres 00:02:13
vale, pero que ocurre 00:02:15
efectivamente cuando tenemos nuestra propia clase 00:02:16
pues vamos a hacernos nuestra clase 00:02:19
nos vamos a hacer 00:02:22
nuestra clase 00:02:24
alumno, para variar 00:02:26
ahora ya 00:02:28
nuestro haset va a ser de alumnos 00:02:32
nuestro haset va a ser de alumnos que tiene 00:02:34
un if 00:02:37
Y una nota 00:02:40
Por ejemplo, ya está 00:02:44
Tiene esto 00:02:46
Vale, pues ahora vamos a trabajar 00:02:47
No con string, sino con alumnos 00:02:57
¿Vale? Le voy a poner un constructor 00:02:58
Para que me sea luego más fácil 00:03:00
¡Hala! 00:03:01
Ahí tengo mi clase alumno 00:03:11
Pues venga, vamos a hacer ahora 00:03:12
Nuestro 00:03:14
Ejemplito 00:03:16
Con alumnos 00:03:21
Pues venga, nos vamos a hacer un set de alumnos 00:03:23
Ya no de stream 00:03:39
De alumnos 00:03:41
No, en el mismo main 00:03:45
Me estoy haciendo otro 00:03:50
Método para hacer 00:03:51
Para llamarlo en el 00:03:53
Para 00:03:54
Sí, alumno 00:03:55
He hecho esta clase que acabo de crear 00:03:57
Y ahora en mi mismo main voy a hacer las pruebas ahora con alumnos 00:04:00
En otro método 00:04:03
Vale, aquí tenía este, pues en otro método voy a hacer las pruebas 00:04:04
Con alumno 00:04:07
Vale 00:04:08
Ala 00:04:09
Pues venga, vamos a añadir un nuevo alumno 00:04:12
Alumnos.ad 00:04:15
Un new alumno 00:04:16
Con nifun234 00:04:19
Y nota 7 00:04:23
Y vamos a añadir otro más 00:04:25
5, 6, 7, 8 00:04:30
Y nota 7 00:04:40
También 00:04:42
Bien, vale. Voy a poner un toString en alumno para que a la hora de recorrerlo no sea más fácil ver lo que tiene. 00:04:42
Vale, le voy a añadir un toString aquí con nif y nota. 00:04:50
Ahora, ya tengo ahí el toString. 00:04:58
Vale, pues entonces vamos a recorrer a ver lo que tiene. 00:05:01
No, nif y nota. Y ya está, nif y nota. 00:05:14
vale, pues que he hecho 00:05:23
he metido dos alumnos 00:05:25
y voy a mostrar a ver si en la colección 00:05:27
están realmente o no están 00:05:29
bueno, voy ahora a llamar este 00:05:30
que es en el que tengo las pruebas, desde mi main 00:05:32
y este anterior 00:05:34
en el que he hecho las pruebas de antes 00:05:39
lo comento, para no estar ahí 00:05:40
volviéndome loca 00:05:42
vale, y si me había olvidado el static, seguro 00:05:44
vale, pues venga 00:05:47
vamos a ejecutar esto 00:05:52
aquí tengo yo 00:05:53
los dos alumnos, estupendamente 00:05:56
Bueno, pues ahora 00:05:58
El de secretaría 00:06:00
Que está ahí metiendo los alumnos 00:06:02
Cargándolos para luego pasar en lista 00:06:04
A los profes o para hacer lo que sea 00:06:06
Pues como le han llamado y le han distraído 00:06:08
Vuelve a meter al mismo alumno otra vez 00:06:10
Y vuelve a meter 00:06:13
Otra vez a este 00:06:17
Vale, pues vamos a volver a recorrer la colección 00:06:17
A ver después de su error 00:06:29
De haberlo metido por segunda vez 00:06:30
En una aplicación 00:06:32
En la que yo tengo claro que no quiero duplicados 00:06:33
Por eso he elegido esta colección 00:06:36
Etcétera, etcétera 00:06:38
Pues a ver qué pasa 00:06:39
Vale 00:06:41
Lo ejecutamos 00:06:43
Ah, bueno, este es el primer for 00:06:46
Y este es el segundo for 00:06:52
Entonces mi primer for es este 00:06:54
Los dos primeros alumnos 00:06:56
Y ahora 00:06:58
He metido el otro alumno 00:07:00
Y me aparece aquí tan ricamente 00:07:03
Vale 00:07:05
entonces, mal 00:07:07
¿vale? que mal diseñada 00:07:09
está esta aplicación, que si yo me echo 00:07:11
todo este compendio 00:07:13
de lecciones 00:07:15
para asegurarme de que no hay duplicados 00:07:16
pues me está metiendo los duplicados 00:07:19
claro, pero es que ya sabemos como funciona 00:07:20
el hashSet por dentro 00:07:23
para él, ser igual 00:07:24
significa que la sucesión 00:07:27
de hashCode e equals 00:07:29
te dé true 00:07:31
¿vale? entonces 00:07:32
newAlumno12347 00:07:35
y newAlumno12347 00:07:37
¿qué hashCodeEquals 00:07:39
utiliza? el de object 00:07:43
porque alumno yo no le he hecho hashCodeEquals 00:07:45
no le he hecho hashCode 00:07:47
entonces como alumno yo no le he hecho hashCodeEquals 00:07:48
hashSet utiliza el de object 00:07:51
y el de object te dice 00:07:53
que dos objetos son iguales 00:07:55
única y exclusivamente 00:07:57
es decir, te va a devolver 00:07:58
true la sucesión de hashCodeEquals 00:08:01
solo si son la misma 00:08:03
una dirección de memoria solo. 00:08:05
Y es evidente que este es un objeto 00:08:07
que se habrá colocado en la dirección de memoria que sea. 00:08:09
No nos da igual, lo hemos perdido. 00:08:12
No es que lo hayamos perdido, 00:08:14
se ha metido ahí en la colección. 00:08:15
Y este es otra instancia 00:08:17
con las mismas propiedades, sí, 00:08:18
pero es otra instancia. 00:08:21
Esto es una instancia y esto es otra instancia. 00:08:22
Dos objetos distintos, en diferentes posiciones, 00:08:24
una instancia y otra. 00:08:27
Los mismos valores por dentro, por supuesto, 00:08:29
los mismos valores, pero dos instancias. 00:08:32
con lo cual el hashCodeEquals 00:08:33
de object me va a decir que son distintos 00:08:36
luego para mi set 00:08:38
dice que quieres añadirlo 00:08:40
no pasa nada si es distinto al anterior 00:08:42
lo añade 00:08:44
pero claro, esto no tiene sentido real 00:08:45
esto no tiene sentido 00:08:48
las aplicaciones son para 00:08:50
ayudarnos en la vida 00:08:51
no para hacer cosas por libre 00:08:53
por su cuenta 00:08:55
claro, porque lo que nos ha faltado es 00:08:56
perdona, que yo voy a usar un hashSet 00:08:59
pues entonces que no se me olvide 00:09:02
por nada del mundo si voy a hacer un hash set 00:09:04
irme a 00:09:06
alumno y poner el hash code 00:09:08
e equals, por el parámetro 00:09:10
que yo quiera o por los que yo quiera 00:09:12
en alumno que me marca 00:09:14
la igualdad, nif 00:09:16
pues entonces si en alumno 00:09:18
me marca la igualdad nif 00:09:20
yo ahora me hago un hash code 00:09:22
e equals, por nif 00:09:24
podría ser por varios campos 00:09:28
si es que la igualdad entre dos objetos 00:09:32
implicara la igualdad de varios campos 00:09:34
simultáneamente 00:09:36
pero en este caso es solo el NIF 00:09:37
pues ya tengo mi Haskell 00:09:39
generado 00:09:44
que luego yo lo puedo cambiar 00:09:46
pero no lo cambiamos, este nos gusta 00:09:48
si entráramos aquí dentro veríamos que bueno 00:09:50
que esto de aquí nos gusta 00:09:52
que hace esto de aquí 00:09:54
y esto de aquí nos gusta y al final me acaba saliendo 00:09:56
un 31 00:09:58
un número mágico que alguna explicación tendrá 00:10:00
podéis entrar a 00:10:02
a indagar 00:10:04
lo que tiene su interés 00:10:07
vale, pero bueno 00:10:08
nosotros 00:10:11
ahora ya sí, hemos hecho un hashCode 00:10:13
equals por nif, pues ahora 00:10:14
ya mi aplicación main, ahora ya 00:10:17
no va a meter a este 00:10:19
no, de nif 00:10:20
solamente, porque la igualdad entre objetos 00:10:27
es igualdad de nif 00:10:29
vale, entonces ahora 00:10:30
si ejecutamos esto 00:10:39
Por ejemplo, voy a ponerle yo aquí 00:10:40
Con otra nota, con un 6 00:10:43
¿Vale? Este se ha equivocado 00:10:44
El de Secretaría se ha equivocado 00:10:47
Porque la ha llamado, se ha distraído 00:10:48
Y ha vuelto a meter a este alumno con este NIF 00:10:49
Dos veces, luego es el mismo 00:10:52
Pues vamos a ejecutar esto 00:10:54
¿Vale? 00:10:57
Pues como veis 00:10:59
Lo ha ignorado 00:11:01
No lo ha metido 00:11:02
Directamente lo ha ignorado 00:11:03
Y no lo ha metido 00:11:07
Porque ha visto que ya había uno igual a este 00:11:08
El otro campo ni lo ha mirado 00:11:11
Ha visto que había uno igual a este 00:11:12
Entonces ha comparado a ese nuevo alumno 00:11:14
De esa línea, la 79 00:11:17
Ha comparado el hashcode 00:11:18
Con el hashcode 00:11:21
Claro, lo que ha hecho es 00:11:22
Ha hecho primero hashcode 00:11:25
Y luego equals 00:11:27
De este 00:11:28
Luego hashcode equals de este 00:11:33
Que le da true, son iguales 00:11:35
entonces a ti lo único que tiene que preocupar 00:11:37
a la hora de usarlo es 00:11:46
que en la clase 00:11:47
a la que pertenecen los objetos 00:11:49
de la colección tenga los dos 00:11:52
métodos vuestros, hashCode e equals 00:11:54
y ambos basados 00:11:55
en el parámetro que marca la igualdad 00:11:57
él o los, que podrían ser varios 00:12:00
imaginaos que queremos 00:12:02
que por alguna razón 00:12:04
que no tendría ningún sentido 00:12:05
pero que por alguna razón queremos 00:12:07
que dos alumnos sean iguales 00:12:10
solo si comparten NIF y NOTA 00:12:12
si yo tengo un alumno que se llama Pepe con un 7 00:12:14
y otro Pepe con un 8 00:12:16
mi aplicación tiene que asumir que son distintos 00:12:17
no tendría mucho sentido 00:12:20
pero bueno, imaginaos que queremos eso 00:12:22
por los requisitos de nuestra aplicación 00:12:24
por lo que sea Dios, que esté definida 00:12:26
pues yo podría hacer un hashcode 00:12:28
de equals basado en los dos 00:12:30
basado en los dos, en NIF y NOTA 00:12:31
ala, ya está basado en los dos 00:12:38
el hashcode 00:12:41
está basado en los dos 00:12:42
Y el equals también 00:12:44
Ahora ya 00:12:45
Este sí que lo insertaría 00:12:47
Este sí, porque no es distinta 00:12:49
Entonces ahora este sí lo insertaría 00:12:51
Porque es diferente a este 00:12:54
Si lo ejecutamos 00:12:56
Efectivamente 00:12:58
Lo ha insertado 00:13:02
Porque es distinto al anterior 00:13:03
Bueno, si tú vas entrando dentro 00:13:05
Se acaba generando con esta fórmula 00:13:13
¿Vale? 00:13:15
A ver hay ciertas 00:13:17
Todo esto de los hash 00:13:19
Tiene una teoría muy grande por debajo 00:13:21
Se supone que se hace para 00:13:23
Hacer clusters 00:13:25
Separar objetos y manejarlos 00:13:28
Tiene un rollo muy grande por debajo 00:13:30
Que uno se puede meter 00:13:32
A jugar con ello 00:13:34
A ver como funciona 00:13:35
Porque es una cosa interesante 00:13:36
Pero nosotros no tenemos tiempo 00:13:37
Y nos interesa el uso de esto 00:13:39
Vale 00:13:42
Vale, entonces bueno 00:13:42
El remove 00:13:51
Pues el remove funciona por igualdad 00:13:55
El contains por igualdad 00:13:57
Vale 00:13:58
Por ejemplo aquí 00:13:59
Si yo hago 00:14:02
Alumnos.contains 00:14:04
NewAlumno 00:14:12
NewAlumno 00:14:17
5, 6, 7, 8 00:14:24
Nota 8 00:14:27
Vale 00:14:33
Contents 00:14:34
Contents 00:14:36
A ver 00:14:44
Ah, perdón 00:14:45
El 8 va aquí 00:14:48
Vale 00:14:49
Por ejemplo 00:14:52
Y aquí 00:14:55
Ah, vale, que me falta uno 00:14:57
Ya está, vale 00:15:11
Por ejemplo 00:15:13
Pues si yo hago contains 00:15:15
Esto funciona igual que listas 00:15:17
Este 00:15:18
Con la aplicación que hemos 00:15:20
Hecho, con el add que hemos hecho arriba 00:15:23
5, 6, 7, 8 00:15:25
Este que me daría, true o false 00:15:26
al final se quedó con los dos 00:15:29
luego si se quedó con los dos 00:15:36
este me daría falso 00:15:38
porque no existe 00:15:39
no hay un alumno igual a este 00:15:41
en la colección, porque la igualdad 00:15:44
es por los dos 00:15:46
el que yo había metido era un 7 00:15:46
entonces esto me daría un falso 00:15:49
lógicamente 00:15:52
no hay un alumno igual a ese 00:15:53
pero si yo hago mi 00:15:54
jasco de equals con un poco más 00:15:57
de sentido real 00:15:59
con un poco más de sentido real 00:16:00
y lo hago solo con nif 00:16:03
que sería el sentido real 00:16:12
pues ahora lógicamente 00:16:13
ahora este 00:16:16
me va a dar true 00:16:18
me va a decir sí, hay un alumno 00:16:20
igual a este en la colección 00:16:22
porque hay un alumno con DNI 00:16:24
5, 6, 7, 8 00:16:26
vale, ahora me da true porque sí 00:16:28
efectivamente hay un alumno igual a ese 00:16:30
con ese DNI 00:16:31
y no hay más 00:16:32
manejar los métodos de añadir 00:16:37
con la particularidad de que 00:16:40
no te va a añadir un duplicado, te lo va a ignorar 00:16:42
al menos te devuelve 00:16:44
false si tú lo quieres comprobar 00:16:46
el método add te devuelve 00:16:47
false o true si 00:16:48
insertó o no, por ejemplo 00:16:51
si yo cada inserción se la paso a un 00:16:53
system out, pues aquí al menos 00:16:55
tengo esa realimentación 00:17:01
en el list, esa realimentación 00:17:02
no la usamos, porque por qué no va a añadir 00:17:05
a una lista, por qué no lo va a añadir 00:17:07
ahí le da igual que haya duplicados, que no haya 00:17:08
pero aquí esa realimentación 00:17:11
si nos importa más, porque si me dice 00:17:13
falso, oye, ¿por qué no añadió? 00:17:14
ah, es que ya tenía uno igual, pues igual 00:17:17
es que he metido mal la nota 00:17:18
¿vale? 00:17:21
si yo hago esto, ¿veis? 00:17:22
las dos primeras inserciones las pudo hacer 00:17:26
pero la siguiente inserción 00:17:28
no pudo hacerla, no pudo hacerla 00:17:30
porque ya había uno igual 00:17:32
¿vale? pues el valor de vuelta 00:17:33
nos vale, pues el add no tiene 00:17:38
Más que esto y el add all igual, remove lo mismo 00:17:40
Podemos recorrer con iterador 00:17:42
Para borrar por un criterio 00:17:44
Que no sea la clave primaria 00:17:47
Porque para borrar por clave primaria 00:17:48
Pues me hago yo el remove y tan ricamente 00:17:50
¿Vale? 00:17:52
¿Que quiero borrar al alumno este 5, 6, 7, 8? 00:17:53
Pues me hago esto 00:17:57
Y ya está 00:18:00
¿Vale? 00:18:02
Esto me eliminaría de la colección 00:18:16
El alumno que sea igual a este 00:18:18
Si es que hay alguno igual, si no, no 00:18:20
¿Vale? 00:18:23
Funciona exactamente igual que en listas 00:18:24
Ya está 00:18:27
Que quiero borrar todos los alumnos 00:18:28
Que han suspendido 00:18:34
Eso no lo puedo hacer con el remove 00:18:36
Así a palo seco 00:18:38
Porque no estoy borrando por criterio de igualdad 00:18:39
El remove si borro por criterio de igualdad 00:18:41
Paso aquí uno igual y ya está 00:18:44
Pero si quiero borrar 00:18:45
Por otro criterio 00:18:47
Borrar suspensos 00:18:49
Pues entonces aquí 00:18:52
Tengo que hacer un iterador 00:18:54
iterator de alumno 00:18:55
alumnos.iterator 00:19:00
y ahora ya el bucle 00:19:06
mientras tenga siguiente 00:19:08
mientras tenga siguiente 00:19:13
me voy a coger aquí al alumno 00:19:18
vale, y ahora 00:19:19
si este alumno resulta que su nota 00:19:26
es menor que 5 00:19:29
pues ala 00:19:32
suspenso, o sea, borrado 00:19:34
vale, pues esto lo haría así 00:19:37
vale 00:19:42
aquí no me queda más remedio 00:19:43
como no puedo, no estoy borrando 00:19:47
por clave primaria, por igualdad 00:19:48
pues tengo que recorrer para encontrar 00:19:50
el que cumple la condición 00:19:52
y el que lo cumpla borro 00:19:54
si en lugar de comiterador pongo un for each 00:19:56
pues ya sabemos que me podría salir el concurren 00:19:57
modificación excepción, pues no 00:20:00
pues lo hacemos así 00:20:01
te dice 00:20:03
si ese iterador 00:20:10
tiene un siguiente al que podría 00:20:12
apuntar. ¿Te devuelve true o false? 00:20:14
Como el link del link. 00:20:16
No, no, no, no. 00:20:18
A ver, tú tienes tu set, que tu set 00:20:20
son un montón de cositas. Este, este 00:20:22
y este y este. Y tú quieres 00:20:24
recorrerlas para ver cosas en ellas. 00:20:26
Pues llamas a un tío y te lo 00:20:29
cuento. Ese tío es el iterador. 00:20:30
Entonces, el iterador 00:20:33
lo primero que hace es ponerse 00:20:34
antes del primero de todos. 00:20:36
entonces el hasnest 00:20:38
te devuelve true o false en función 00:20:41
de si hay un siguiente al que puedo 00:20:43
avanzar 00:20:45
pero no mueve al tío, no mueve al iterador 00:20:46
vale, pues si el hasnest es true 00:20:49
o lo que es lo mismo, hay un siguiente al que puede avanzar 00:20:51
pues avanza 00:20:53
pues el tío ya avanza y se queda 00:20:55
colocado en el primero al que va a mirar 00:20:57
eso lo hace el next, el avanzar 00:20:59
una vez colocado en el que 00:21:01
va a mirar, pues ya te lo devuelve 00:21:03
como retorno o te lo 00:21:05
borra, si tú quieres, le da el empujón y lo tira 00:21:07
lo que tú quieras 00:21:09
ahora 00:21:11
vuelves a llamar al hash net, el hash net te dice 00:21:12
oye, tienes un siguiente al que avanzar, pero no lo avanzas 00:21:15
solamente tienes un siguiente 00:21:17
si es que true tienes un siguiente, si es que false 00:21:19
no, este es el último, no tengo más a los que avanzar 00:21:21
entonces el bucle va a estar ahí 00:21:23
mientras tengas un siguiente 00:21:25
avanzas, te colocas en él 00:21:26
no miras, lo borras, lo que sea 00:21:29
¿vale? 00:21:31
¿es una lista limpiada de la propiedad next 00:21:33
que sea diferente del new? 00:21:41
a recorrer una lista linkeada 00:21:43
bueno, sí, pero eso luego 00:21:45
bueno, pero en dos contextos distintos 00:21:48
o sea, en 00:21:50
una linked list 00:21:51
cuando tú la recorres, internamente 00:21:54
él mira si el siguiente es null 00:21:56
pero para ti es transparente 00:21:57
tú la recorres y ella separará 00:21:59
¿vale? pues aquí igual 00:22:01
bueno 00:22:03
bueno, tú si lo haces tú 00:22:08
claro, lógico 00:22:10
claro, pero es que una lista de algo va a un operador 00:22:12
claro, o sea 00:22:14
Literador es para colecciones en general, ¿vale? 00:22:16
Para colecciones, independientemente de que sean 00:22:18
ArrayList, LinkedList. 00:22:20
Él ya se encarga de ver qué tiene que hacer en cada momento. 00:22:23
Si el literador está asociado a una LinkedList, 00:22:25
pues, lógicamente, Hasnest será ver 00:22:27
si el nodo siguiente apunta a todo o no apunta. 00:22:29
Si el literador está asociado a una ArrayList, 00:22:32
su Hasnest será ver si soy el último del Array. 00:22:35
En cada uno, la lógica del Hasnest será una u otra 00:22:37
en función de si el literador está asociado a un LinkedList, 00:22:40
a un ArrayList, a un set. 00:22:43
vale, pues pocos más 00:22:44
matices tiene el hash set que esto 00:22:50
ya está 00:22:52
ser consciente 00:22:54
de que al no tener elementos iguales 00:22:58
eso tiene unas implicaciones 00:23:00
en el funcionamiento, al no admitirlos 00:23:02
como que puedas no estar insertando 00:23:04
lo que crees que estás insertando, nada más 00:23:06
y que para que ese funcionamiento 00:23:08
sea coherente, tiene que estar el hash code 00:23:10
de equals, vale 00:23:12
ya está, si hacemos un set de integer 00:23:13
como un integer ya tiene hash code de equals 00:23:16
Pues no hay que hacer nada 00:23:17
Bueno, pues entonces los ejercicios 00:23:18
Linked has set y tree set 00:23:24
Meten algunas cosas más 00:23:28
Pero bueno, que ya 00:23:31
Bueno, linked has set, ¿no? 00:23:32
Que vemos el próximo día 00:23:34
Entonces en los ejercicios 00:23:35
Pues uno puede usar indistintamente 00:23:37
Set o list 00:23:39
Depende 00:23:41
Si valen para lo mismo 00:23:42
Para guardar un montón de cosas 00:23:43
Un set 00:23:44
Siempre es una opción natural 00:23:46
Si yo no necesito 00:23:48
La posición 00:23:50
Si no la necesito, un set y ya está 00:23:51
Y si no, pues una lista 00:23:53
¿Vale? 00:23:54
Bueno, pues entonces seguís haciendo 00:24:01
Los ejercicios y ya está 00:24:03
¿Vale? 00:24:05
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:
1
Fecha:
15 de febrero de 2026 - 17:59
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
24′ 11″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
102.30 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid