Saltar navegación

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

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

10 visualizaciones

Más información Transcripción

Descargar la transcripción

Venga, vamos a completar esto, vale, pues podemos recorrer así, o también podemos recorrer, vamos, silencio, vamos a verlo por completitud, no quiero que os liéis, porque en realidad esto, en esencia es todo lo mismo. 00:00:00
decidir una colección 00:00:15
la que se adapta a mi situación 00:00:18
y una vez que la he decidido 00:00:19
usarla para meter 00:00:21
cosas en ella, iterar por 00:00:23
ella, eliminar cosas de ella 00:00:26
y usarla obviamente 00:00:27
con los requisitos que cada uno necesita 00:00:30
pero siempre es lo mismo 00:00:32
bueno, vamos a incorporar otro método de recorrer 00:00:33
el mapa para que no suene a chino 00:00:36
hacedme caso 00:00:37
vamos a incorporar otro método de recorrer el mapa 00:00:39
para que no suene a chino si lo ves por ahí 00:00:41
bueno, pues dentro de los métodos que hemos visto 00:00:43
vale, dentro de los métodos 00:00:48
que hemos visto 00:00:55
vale, dentro de los 00:00:55
métodos que hemos visto, pues 00:01:06
a ver, venga ya 00:01:08
no quiero ruido 00:01:12
de fondo 00:01:14
vale, dentro de los métodos de map, había uno también por aquí 00:01:15
que es 00:01:20
este 00:01:23
ah, pues así no veis nada 00:01:24
obviamente 00:01:29
ahora si veis 00:01:29
vale, pues había otro 00:01:33
este 00:01:42
que también parece que convierte 00:01:42
en set y al convertir en set 00:01:46
ya podemos iterar, el problema nuestro del map 00:01:48
es que al ser pares 00:01:50
no había un for each por el que iterar 00:01:51
ni un iterador, porque son pares, ¿cómo haremos eso? 00:01:54
entonces tenemos que convertir a set 00:01:56
pues dijimos, vale, sacamos un set 00:01:57
de las claves e iteramos 00:02:00
por las claves recuperando luego por clave 00:02:02
que es lo que acabamos de hacer 00:02:04
pues hay este otro método 00:02:05
que también te devuelve un set 00:02:07
por el que ya podemos iterar 00:02:08
pero un set de qué 00:02:10
de objetos entry de este tipo 00:02:12
que son como objetos envolvente del map 00:02:14
entonces este objeto 00:02:16
te envuelve el map 00:02:18
en un objeto único, ya no en un par 00:02:20
y el entry set te devuelve 00:02:22
un conjunto de esos 00:02:25
envolventes del map, del par 00:02:26
bueno, pues nos facilita el recorrido 00:02:29
nos lo facilita 00:02:31
¿cómo lo usaríamos? por ejemplo 00:02:32
¿cómo lo usaríamos? pues por ejemplo así 00:02:34
pues entonces 00:02:37
yo me hago un set 00:02:46
de este tipo raro 00:02:53
set alumno 00:02:54
por ejemplo así 00:03:06
punto y coma 00:03:15
entonces fijaos 00:03:19
que es esto 00:03:29
¿vale? no, tenéis que iros acostumbrando 00:03:29
no os volváis locos por ver con las escritas 00:03:32
podéis ver una aplicación 00:03:34
y veis escrito 200.000 cosas 00:03:36
aquí que se abren, que se cierran, que parametrizan 00:03:38
Da igual, es lo de siempre, pero ya lo conocéis. 00:03:41
Vale, pues, ¿esto qué es? 00:03:43
Un conjunto de este tipo de datos. 00:03:44
Muy bien. 00:03:47
¿Y este tipo de datos cuál es? 00:03:48
Pues, es un tipo entry que a su vez depende de string y alumno. 00:03:51
¿Este tipo entry qué es? 00:03:59
Es un tipo que envuelve el par. 00:04:01
Envuelve el par de clave string, valor alumno. 00:04:03
Bueno, pues, ya tengo un conjunto que he sacado. 00:04:08
paso aquí debajo lo del igual 00:04:11
para que se vea mejor 00:04:13
que he sacado a través del entry set 00:04:14
entonces el entry set me saca 00:04:17
un conjunto de este tipo 00:04:19
de datos tan raro 00:04:21
y ahora como esto es un conjunto ya puedo iterar 00:04:22
por él 00:04:25
y dentro de cada uno de los objetos 00:04:26
de este conjunto tengo un objeto 00:04:29
que me envuelve el par 00:04:31
y lo saco, por ejemplo así 00:04:32
vamos a iterar 00:04:35
por él por ejemplo con un for each 00:04:37
para que sea más fácil 00:04:39
Pues para cada objeto de este tipo 00:04:40
Para cada objeto de este tipo 00:04:42
Dentro de 00:04:48
Este set 00:04:50
De alums 00:04:52
¿E qué tiene? 00:04:53
Pues E tiene un get key 00:04:56
Para sacar la clave 00:04:58
Y un get value para sacar el valor 00:04:59
Pues ya está, ya tengo lo que quería 00:05:01
Lo vamos a escribir y ahora repetimos otra vez lo que es esto 00:05:02
Sí, por eso 00:05:06
Lo escribo y lo volvemos a repetir 00:05:08
Lo paso aquí debajo, lo del system out para que... punto get value. Vale, a ver, pues repetimos otra vez desde el principio. 00:05:10
A ver, el problema que tenemos para iterar por un map es que son pares, no es un conjunto de objetos sencillos ni una lista. 00:05:35
Entonces el for each no nos vale porque el for each solo vale para recorrer colecciones de objetos sencillos, no de pares. 00:05:44
y el iterator igual 00:05:51
eso no nos vale para iterar por set 00:05:54
por colecciones, por set o por list 00:05:56
¿vale? entonces 00:05:58
tenemos que conseguir 00:06:00
algo aquí para el forEach 00:06:02
que sea una colección de objetos sencillos 00:06:04
no de pares 00:06:06
bueno, pues para eso tenemos el método 00:06:07
entrySet, que se lo aplicamos a un map 00:06:10
este ya es el conjunto de pares 00:06:12
el map, el conjunto de pares, clave, valor 00:06:14
stream, alumno, stream, alumno 00:06:16
pues se lo aplicamos al map 00:06:18
y ese ya me devuelve un conjunto 00:06:20
un set 00:06:22
ya me devuelve un conjunto de valores sencillos 00:06:23
pero ¿de qué tipo de valor? 00:06:26
¿de qué tipo de valor? 00:06:28
pues de un tipo de dato que se llama entry 00:06:29
que es un envolvente del par 00:06:31
es como si fuera un objeto 00:06:33
en el que se meten dentro 00:06:36
como si fueran dos propiedades suyas 00:06:37
los dos elementos del par 00:06:39
entonces el par que es así 00:06:41
se mete dentro de un objeto entry 00:06:43
como dos propiedades internas 00:06:46
se mete un objeto entry 00:06:47
y ya tengo un set 00:06:49
de esos objetos entre 00:06:52
que tienen cada uno de ellos dentro 00:06:54
en la clave y el valor 00:06:56
la clave y el valor 00:06:58
pues este objeto set 00:06:59
ya lo puedo recorrer 00:07:02
ya lo recorro 00:07:03
y cada objeto de estos C hemos dicho que tiene dentro 00:07:05
la clave y el valor, la tiene dentro 00:07:08
¿cómo la sacamos? 00:07:09
pues con getKey sacamos la clave 00:07:11
y con getValue sacamos el valor 00:07:13
entonces 00:07:16
esta sería una forma alternativa de recorrer 00:07:18
mi conjunto de pares 00:07:20
lo transformo 00:07:22
a un conjunto de objetos sencillos 00:07:24
donde cada objeto sencillo 00:07:26
es de este tipo 00:07:28
que es un objeto sencillo que tiene dentro 00:07:29
como propiedades suyas 00:07:32
la clave y el valor del mapa 00:07:33
lo han vuelto dentro 00:07:35
y ahora ya recorro ese conjunto 00:07:37
y saco de cada uno 00:07:40
de esos elementos 00:07:42
su propiedad clave, su propiedad valor 00:07:43
y claro 00:07:46
este tipo entry 00:07:49
es genérico también porque lo que envuelve 00:07:51
dependerá del tipo 00:07:54
de dato que sea en la clave y el valor 00:07:55
en este caso la clave y el valor 00:07:57
en string alumno, por eso este entry 00:07:59
es string alumno, pero si 00:08:01
quisiéramos recorrer de esta manera 00:08:07
esa otra colección que hemos hecho 00:08:09
¿vale? por ejemplo esta otra colección 00:08:10
que hicimos 00:08:13
que era la colección 00:08:14
esta asignación 00:08:16
vamos a recorrerla ahora 00:08:18
esta es de 00:08:20
un map de alumno stream 00:08:22
pues para recorrerla haríamos esto mismo 00:08:23
pero de esta otra manera 00:08:26
haríamos, primero 00:08:27
sacamos el entry set 00:08:34
de esa colección 00:08:41
que era asignaciones 00:08:43
creo que se llamaba 00:08:44
asignación 00:08:46
se llamaba el map 00:08:48
asignación 00:08:49
vale, pero claro 00:08:51
el objeto entry que envuelve 00:08:54
a cada par de asignaciones 00:08:56
ese objeto entry 00:08:58
a lo que envuelve es 00:08:59
a una clave de tipo alumno 00:09:01
y a un valor de tipo string. 00:09:03
Entonces tenemos que ponerlo correctamente. 00:09:09
¿Vale? 00:09:11
Asignación era un map 00:09:13
de clave alumno 00:09:14
valor string. 00:09:16
Pues el objeto entry 00:09:18
que envuelve ese par 00:09:20
ese objeto entry 00:09:21
entonces su tipo será 00:09:23
alumno para la clave, string para el valor 00:09:25
¿vale? y ahora ya 00:09:28
pues lo recorremos 00:09:30
así 00:09:31
ah, es que no he puesto esto bien 00:09:37
¿vale? así 00:09:42
esto aquí, y ya está 00:09:42
y con eso estaremos recorriendo el otro 00:09:47
bueno, entonces es 00:09:50
para recorrer el map, ya está 00:09:53
recorremos el map si queremos recorrerlo 00:09:55
pero normalmente un map no se usa 00:09:57
para recorrerlo, un map se usa 00:09:59
por la maravilla de la ventaja 00:10:01
que tiene la clave, tú metes los pares 00:10:03
y luego recuperas por clave 00:10:05
eliminas por clave 00:10:07
para eso se hace, más que para recorrerlo 00:10:09
bueno, vamos a ejecutar 00:10:12
por si acaso hemos escrito algo mal y nos salen cosas raras 00:10:18
pero 00:10:20
nos sale bien, ¿vale? este es 00:10:23
el recorrido 00:10:25
del primero 00:10:28
y este es el recorrido 00:10:29
de la segunda colección 00:10:32
¿veis? me ha mostrado la clave 00:10:33
que es esta, y el valor 00:10:35
solo tenía un elemento, ese mapa 00:10:37
este es el primer mapa 00:10:40
clave, valor, clave, valor 00:10:44
este es el segundo mapa 00:10:46
clave 00:10:47
valor 00:10:50
¿vale? 00:10:52
solo tenía dos, si le metemos 00:10:54
otro más para ver que 00:10:56
solo tenía uno, perdón 00:10:58
así, era esta 00:10:59
así, vale 00:11:03
solo tenía uno porque Carlos al ser duplicado 00:11:11
lo había metido 00:11:14
Vamos a meterle dos 00:11:14
Si le metemos dos 00:11:16
Estos dos 00:11:19
Que ahora ya al no ser duplicados los meterá 00:11:20
Si le metemos dos 00:11:23
Pues aquí están 00:11:25
Este es el segundo mapa 00:11:26
Su clave, su valor 00:11:29
Su clave, su valor 00:11:33
Estos alumnos ya son distintos 00:11:35
Por eso los hemos metido los dos, etc 00:11:37
Bueno, esos son los intríngulis del mapa 00:11:38
Pero no me habéis preguntado 00:11:45
Por 00:11:48
Ay, he perdido 00:11:50
Mi esta de 00:11:55
Mapas, que pena 00:11:57
Ay, que torpe soy 00:11:58
Para ver las imágenes, de verdad 00:12:29
Ahí está 00:12:30
Vale 00:12:34
¿No me habéis preguntado por esta? 00:12:35
¿Estáis ansiosos? 00:12:44
Por preguntarme por esta, como no me da tiempo 00:12:46
Si son las 2 y 3 00:12:47
Digo que no ha dado tiempo a preguntarte 00:12:48
Ah, vale 00:12:50
Me he preguntado por esto 00:12:52
Bueno, pues a ver 00:12:54
Si HashMap y LinkedHashMap 00:12:56
Guardaban las claves 00:12:59
En un HashSet interno 00:13:01
Y por eso la clase 00:13:03
En la que pertenecían las claves 00:13:05
Tenía que tener HashCodeEquals 00:13:06
Tremap 00:13:08
¿En qué estructura creéis que guardaba las claves? 00:13:10
Su clave, su valor 00:13:17
Y la clave del tipo 00:13:18
¿Pero en qué tipo de colección guardará TRIMAP las claves? 00:13:20
O sea, HASHMAP guarda las claves en un HASHET. 00:13:24
Pues TRIMAP guarda las claves en un TRISET, efectivamente. 00:13:27
Entonces, TRIMAP guarda las claves en un TRISET. 00:13:34
Eso es lo que tenemos que saber. 00:13:37
¿Qué implica eso? 00:13:38
Que la clase a la que pertenecen las claves tiene que tener entonces el qué? 00:13:40
El COMPARABLE. 00:13:45
Y si no tiene el comparable, 00:13:46
la clase le repite las claves, 00:13:49
cuando instanciemos TRIMAP, 00:13:51
hay que darle un comparejo. 00:13:53
¿Vale? Por ejemplo, aquí. 00:13:57
En nuestro ejemplito de aquí. 00:14:00
Si a mí me diera la gana, 00:14:03
de repente digo, 00:14:06
oye, mis alumnos estos, 00:14:07
en lugar de meterlos en un HASHMAP, 00:14:10
voy a meterlos en un TRIMAP. 00:14:12
Cállate, Miguel. 00:14:15
ya los de atrás me cuento 00:14:16
de repente a mí me da la gana 00:14:18
cambiar un trimap 00:14:23
pues nada, no ha cambiado nada, he cambiado la implementación 00:14:24
sigue siendo un mapa igual, he cambiado un trimap 00:14:30
porque es más bonito, más efectivo y más todo 00:14:32
vale 00:14:34
¿pasaría algo? 00:14:35
¿mi aplicación que trabaja con alumnos 00:14:38
se rompería? 00:14:40
¿tendría yo algún problema con trimap? 00:14:42
¿sí o no? 00:14:46
no, ¿por qué no? 00:14:48
ya, ¿por qué funciona? 00:14:49
¿por qué no se ha enterado y sigue funcionando perfectamente? 00:14:55
porque string 00:15:00
que es la clase a la que pertenecen las claves 00:15:01
string esa clase ya implementa 00:15:03
comparable, tiene el compare to y todo 00:15:05
string es una clase 00:15:07
que nos hemos hecho nosotros, que ya está hecha 00:15:08
y ya está, y es estupendísima 00:15:11
tiene su equals 00:15:13
tiene su implements de comparable 00:15:15
los strings de hecho se pueden ordenar 00:15:17
alfabéticamente con el compare tool 00:15:20
con lo cual aquí el cambio 00:15:22
ha sido estupendo, muy bien 00:15:24
yo cambio al trimap y no pasa nada 00:15:26
todo funciona igual, porque la clase 00:15:28
a la que pertenecen las claves 00:15:31
implementa el compare tool 00:15:32
el comparable, con lo cual 00:15:35
el trimap 00:15:37
la va a manejar sin problema 00:15:37
y además 00:15:40
¿qué ocurre? pues ocurre 00:15:42
que si ahora iteramos 00:15:44
por el HashMap, además nos va a dar la ventaja 00:15:46
añadida de que 00:15:48
nos lo va a mostrar por orden alfabético 00:15:50
de clave, si es que eso nos 00:15:52
interesa, porque así funciona el tríceps 00:15:54
vale, pero ¿qué ocurre? 00:15:56
ahora nos vamos a esta otra 00:16:00
a esta otra colección de aquí 00:16:02
abajo 00:16:06
a esta 00:16:07
aquí yo decido 00:16:11
uy, el HashMap no me gusta, me han dicho que 00:16:14
el Trimap es mucho más eficiente y más estupendo 00:16:16
cambiamos 00:16:18
Trimap. Aquí ya pasan cosas raras. Sí pasan cosas raras. ¿Por qué? Ojo, la clave ahora es de tipo alumno. 00:16:20
Entonces, Trimap necesita que las claves sean comparables porque las guarda internamente en un triset. 00:16:32
Entonces, alumno tiene que implementar comparables. Si alumno no implementa comparables, Trimap no va a saber trabajar con las claves. 00:16:41
no va a saber trabajar 00:16:47
igual que hashMap 00:16:49
necesita que alumno implementara 00:16:51
hashCodeEqual, ahí daba 00:16:53
porque hashMap 00:16:55
guardaba las claves en un hashSet 00:16:56
pues treeMap guarda en un triset 00:16:59
con lo cual treeMap 00:17:01
necesita que alumno implemente comparable 00:17:03
si no, esto no va a funcionar 00:17:05
que no podemos hacer 00:17:07
que alumno implemente comparable 00:17:09
¿qué hacemos? 00:17:11
pues al treeMap le pasamos un criterio de comparación 00:17:13
específico aquí, igual que para 00:17:15
el tris, idéntico todo 00:17:17
¿vale? 00:17:19
entonces ahora mismo 00:17:22
mi clase alumno que no implementa nada 00:17:23
pues 00:17:25
¿vale? si ejecutamos 00:17:27
esto, la primera parte la he hecho 00:17:32
bien, la del trimap del principio de stream 00:17:34
pero cuando he llegado al otro lado 00:17:36
me dice, alumno, lo siento, no puede 00:17:38
ser comparable, no funciona 00:17:40
entonces, que queremos 00:17:42
que la aplicación siga funcionando igual 00:17:44
con trimap 00:17:46
Vale, no pasa nada, pues entonces le ponemos a este el criterio de comparación que queramos. 00:17:48
Vale, ¿qué criterio le ponemos? Pues ordenamos por nombre, mejor que por nota, porque no nos olvidemos que cuando el comparable lo hacemos para trabajar con un triseto o un trimar, ese comparable se vuelve automáticamente en criterio de igualdad. 00:18:06
entonces no tiene sentido que elegamos 00:18:22
el nota para comparar unos con otros 00:18:25
porque misma nota 00:18:27
no significa mismos alumnos 00:18:29
entonces aquí tendría sentido por nombre 00:18:30
la igualdad 00:18:33
entonces aquí 00:18:34
tendríamos que hacer 00:18:39
ah bueno, espera, el compare tú 00:18:40
así 00:18:42
y ahora para comparar 00:18:45
por nombre 00:18:49
pues nos aprovechamos 00:18:50
dis.nombre 00:18:53
el compare to del equals 00:18:58
perdón, del string 00:19:00
o.nombre 00:19:01
vale, este sería nuestro compare to 00:19:05
basado en el nombre 00:19:12
el nombre del objeto dis 00:19:12
el nombre del objeto o 00:19:14
ahora ya sí que tenemos un compare to 00:19:15
ahora ya hacemos este main 00:19:19
y este main ya funciona perfectamente 00:19:20
porque ya alumno 00:19:23
tiene un criterio de 00:19:26
¿vale? esto ya ha funcionado 00:19:28
exactamente igual que antes 00:19:34
la aplicación ha funcionado igual 00:19:36
me ha dado igual hash map que tree map 00:19:38
ha funcionado igual, son mapas igual 00:19:40
son mapas, ha funcionado igual 00:19:41
lo único es que si uso hash map 00:19:43
no me tengo que olvidar del hash code del equals 00:19:45
en la clase de las claves 00:19:47
y si uso tree map no me tengo que olvidar 00:19:49
del comparable en la clase de las claves 00:19:51
si no hago eso 00:19:54
me da igual el mapa que elija, va a funcionar igual 00:19:56
La única variante es que si he usado 00:19:58
TRIMAP 00:20:01
A la hora de iterar 00:20:01
Me salen ordenados 00:20:04
Pues bueno, pues sí, vale, me salen ordenados 00:20:05
¿Vale? 00:20:08
Alfabéticamente, es extraordinario alfabéticamente 00:20:10
Y es extraordinario alfabéticamente 00:20:12
Uno va antes que el cinco 00:20:14
Es extraordinario alfabéticamente por claves 00:20:15
Orden alfabético aquí 00:20:18
Y orden alfabético aquí 00:20:20
Aunque yo lo haya insertado de la otra manera 00:20:21
Aunque lo haya insertado de la otra manera 00:20:24
me lo pasa por orden alfabético 00:20:26
vale 00:20:28
y lo mismo que el triset 00:20:30
que no podemos alterar 00:20:32
la clase alumno 00:20:34
que no hay forma de poner el comparable 00:20:36
aquí, que no hay manera 00:20:38
bueno, pues le hacemos el comparator y se lo damos al trimap 00:20:39
por ejemplo, voy a copiar 00:20:43
el comparator del ejemplo triset 00:20:44
que nos vale 00:20:46
orden ciudades 00:20:47
luego lo cambio 00:20:51
con orden alumnos 00:20:55
Paste, vale 00:20:56
Orden ciudades, orden alumnos 00:20:59
Orden alumnos 00:21:03
Con un comparator de alumno 00:21:09
Y ahora esto será alumno 00:21:13
Alumno y alumno 00:21:17
Vale 00:21:26
Y tengo que cambiar este nombre 00:21:31
Esperad, lo repetimos todo 00:21:35
Vale 00:21:40
Alumno 1 o 2 00:21:48
¿Por qué me dice que no encuentra nombre? 00:21:50
¿Alumno no tiene nombre? 00:21:52
Ah, bueno, porque es privado 00:21:55
Vale, ordena alumnos 00:21:57
Pues no pasa nada, le ponemos 00:21:59
GetNombre 00:22:01
Y GetNombre 00:22:07
Vale, pues entonces 00:22:12
Este es un criterio de ordenación de alumnos 00:22:14
Me dice 00:22:17
¿Te doy dos alumnos o uno o dos? 00:22:18
y el criterio de ordenación que tú quieras, por nombre, criterio de ordenación, vale, 00:22:21
pues resulta que a alumno no le podemos poner el comparable, 00:22:26
porque no nos dejan, porque no podemos alterar esa clase, 00:22:30
no podemos ponérsela, no podemos ponerle el comparable, 00:22:33
con lo cual esto de aquí tampoco estaría, esto de aquí no estaría, 00:22:38
entonces como no le puedo poner el comparable, 00:22:50
efectivamente aquí me va a salir, cuando trate de ejecutar esto, 00:22:52
me va a decir al TRIMAP, eh, alumno no puedo. 00:22:55
¿Vale? Es lo que me está diciendo. 00:23:00
Lo siento, alumno no puedo. 00:23:02
Me dice, no puedo, alumno no puedo. 00:23:04
No puedes trabajar con un TRIMAP con clave alumno 00:23:07
porque alumno no es comparable. 00:23:11
No puedo tocar alumno, no puedo ponerle comparable. 00:23:14
No pasa nada. 00:23:17
Le pasas a TRIMAP un criterio de ordenación específico 00:23:19
para ese uso tuyo. 00:23:22
pues venga 00:23:23
le pasamos 00:23:25
uno de estos 00:23:27
y ya está, ya el trimap ya se queda tranquilo 00:23:33
me dice, vale, pues para trabajar 00:23:36
con las claves alumno en este 00:23:38
map mío, voy a usar este criterio 00:23:40
de orden, voy a usar este, que me estás pasando 00:23:42
y ya está 00:23:44
y ahora ya nos vuelve a funcionar esto 00:23:45
pues bien 00:23:48
exactamente igual que nos estaba funcionando 00:23:49
bueno, pues esta es más o menos 00:23:52
toda la historia y todo lo que está 00:24:06
en relación a las colecciones 00:24:08
de nuevo no es tanto su uso 00:24:10
es sencillo, si es que es llamar a tres métodos 00:24:13
declarar cuatro cosas 00:24:17
de nuevo la complejidad de la programación no es escribir el código 00:24:18
es entender bien la aplicación 00:24:23
con la que queremos trabajar 00:24:26
y tomar las decisiones correctas 00:24:28
para diseñarla, tomar las decisiones correctas 00:24:30
y luego ya usamos esos recursos que hemos seleccionado 00:24:32
y esos requisitos de uso 00:24:36
esas formas de uso pues son las que hemos estado un poco viendo 00:24:38
vale 00:24:41
vale, pues venga 00:24:43
lo dejamos aquí 00:24:47
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
10
Fecha:
3 de abril de 2024 - 18:44
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
24′ 49″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
129.41 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid