Saltar navegación

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

Clase 05-03-24 - 4 - 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 6 de marzo de 2024 por Raquel G.

11 visualizaciones

Más información Transcripción

Descargar la transcripción

vale, pues antes de 00:00:00
silencio 00:00:03
a ver, antes de 00:00:07
pasar a conjuntos 00:00:09
pues bueno 00:00:10
por completitud, no porque os perdáis 00:00:12
ni os volváis locos en esto, vos tampoco os volváis 00:00:15
locos con ninguna otra cosa, pero bueno 00:00:16
con esto menos 00:00:18
vamos a completar un poquito 00:00:19
de listas 00:00:22
para que no parezca que ni lo hemos mencionado 00:00:23
pero insisto, no quiero que 00:00:26
os volváis locos 00:00:28
A ver, cuando hemos visto la jerarquía de Collection, venga, ¿alguien me está haciendo caso? 00:00:30
que está pausado 00:00:46
como nuestros cerebros 00:00:51
que podemos esperar 00:00:53
yo creo que Miguel, como Miguel es el que se echa 00:00:59
las siestas, luego lo está súper despejado 00:01:03
llega a la una y media 00:01:05
pero se ha estado dos cabezadas 00:01:06
antes 00:01:09
bueno, llamémosle 00:01:09
me apago 00:01:13
Aunque estés dormido 00:01:17
Sí, sí, sí 00:01:19
Yo eso lo he visto en algunas series de estas de Netflix 00:01:21
Bueno, a ver, o parálisis del... 00:01:23
No, porque el que le dan arcolepsia no procesa 00:01:32
Hay otra cosa que se llama parálisis del sueño 00:01:35
Que él cree que procesa 00:01:36
Pero luego no sabe de lo que estamos hablando 00:01:39
Pero... 00:01:40
¿Qué? 00:01:42
No, parálisis del sueño 00:01:45
Es otra cosa 00:01:47
que en esa estás dormido 00:01:47
pero te estás enterando de lo que ocurre 00:01:51
está pasando algo por ahí 00:01:53
como que no, si yo me entero de lo que dice 00:01:56
bueno, la próxima vez que te da una cabezada 00:01:58
te voy a preguntar, a ver si es verdad 00:02:02
que te enteras de lo que dices 00:02:03
a ver 00:02:06
Pues que esto es tan grande 00:02:12
Que tela 00:02:23
Pues que 00:02:42
Bueno, y encima se 00:02:43
Se me cuelga el ordenador 00:02:48
Ah, aquí, vale, vale 00:02:52
Vale, esta me vale, por ejemplo 00:02:54
Vale 00:03:01
A ver, venga 00:03:13
Bueno, venga 00:03:14
a ver, cuando veíamos la jerarquía 00:03:33
de colección 00:03:37
recordad que 00:03:38
para manejar volúmenes de datos 00:03:41
pues como el array es un poquito engorroso de manejar 00:03:43
alguien decidió ponerse a hacer clases 00:03:47
basadas en lo que hay 00:03:50
que es que son objetos y arrays, no hay más 00:03:52
alguien decidió hacer clases para permitirnos de forma sencilla 00:03:54
guardar un montón de cosas bajo una misma referencia 00:03:58
y todo ese mogollón de clases lo organizó en una jerarquía 00:04:01
para que fuera más o menos organizado 00:04:04
entonces, para eso estaba la interfaz iterable 00:04:07
que lo único que dice es el que implemente iterable 00:04:11
tiene que ofrecer métodos para poder 00:04:13
ser iterado, vale 00:04:15
luego collection 00:04:17
que a su vez implemente iterable, el que implemente 00:04:18
collection tiene que 00:04:21
ofrecer métodos para poder hacer add 00:04:23
remove 00:04:25
etcétera, entonces 00:04:27
el que implemente collection tiene que implementar 00:04:29
lo de add, remove y además lo de iterar 00:04:31
vale, entonces a partir de aquí 00:04:33
ya se dijo, venga, dos filosofías de trabajo 00:04:35
las listas 00:04:37
en las cuales la posición no nos importa 00:04:39
y los conjuntos 00:04:41
en los cuales la posición no nos importa. 00:04:43
Con lo cual, 00:04:46
al no registrar 00:04:47
la posición, no podemos meter dos 00:04:49
elementos iguales, porque no se podrían distinguir. 00:04:51
Estarían navegando los dos en el conjunto. 00:04:54
Vale, list y set. 00:04:56
Una vez separadas las dos filosofías, 00:04:57
list, como, 00:05:00
venga, pues la voy a hacer con un array y la voy a hacer con 00:05:01
lista enlazada. Pues, hala. 00:05:03
Ya dos implementaciones concretas. 00:05:05
ArrayList y LinkedList 00:05:07
¿Vale? Y estas son dos 00:05:09
Muy antiguas, que eran las originales 00:05:11
Cuando no había ni tipo de marametrizados 00:05:13
Ni nada, las primeras clases 00:05:15
Que se hicieron para guardar 00:05:17
De golpe muchos datos, pero 00:05:19
Se mantienen de alguna manera 00:05:21
Por compatibilidad 00:05:23
Son código legado, de eso que se llama 00:05:25
Código 00:05:28
Cuando pone Legacy Code 00:05:29
Código legado, significa, bueno, lo seguimos teniendo 00:05:31
Pues porque nos da pena echarlo 00:05:34
No vaya a ser que haya alguien que no haya querido migrar sus aplicaciones. 00:05:36
Pues esas dos forman parte de eso. 00:05:40
Y luego, de la filosofía de conjuntos, pues hay estas tres implementaciones. 00:05:44
Esta, esta y esta. 00:05:51
Que son un poquito las que veremos cómo se usan. 00:05:53
Y luego están estas cosas de Q, en las que aparece la palabra Q por ahí, 00:05:55
que es la interfaz Q, que como bien sabéis es cola, 00:06:01
que tiene una implementación 00:06:03
que es cola con prioridad, que es esta 00:06:05
y luego 00:06:07
a su vez está esta 00:06:09
interfaz que se implementa 00:06:11
o con linked list o con array 00:06:13
o con array de aquí, con estas 00:06:15
entonces, ¿qué es eso? eso es una tontería 00:06:17
eso es una chorrada, bueno, no merece la pena 00:06:19
perderse mucho en ello, pero a ver 00:06:21
que nos suene y que sepamos de qué es 00:06:23
en algún momento cuando empezamos lo de colecciones 00:06:24
y listas dijimos que 00:06:27
hay estructuras 00:06:28
conceptos que se han manejado siempre para guardar 00:06:31
datos, uno por ejemplo 00:06:33
es el de la pila 00:06:35
y otro es el de la cola 00:06:36
entonces una pila, en cualquier 00:06:38
contexto informático ya sabéis lo que es 00:06:41
una pila es un almacén de datos, eso es una pila 00:06:43
un almacén de datos, pero 00:06:45
un almacén de datos 00:06:47
en el cual lo único que se puede hacer es 00:06:48
depositar 00:06:51
en la última posición, en la 00:06:53
cima, con lo cual solo 00:06:55
hay una sentencia que se puede hacer con la pila 00:06:57
que es PUS, la que se llama PUS 00:06:59
normalmente, PUS, que es apilar 00:07:00
push, ahí no hay recuperar 00:07:03
por posición con get y como aquí 00:07:05
en un linked list, tú recuperas la 7 00:07:07
la 2, la 5, en una lista 00:07:09
enlazada genérica, en una pila 00:07:11
solo 00:07:12
recuperas la última 00:07:14
que apilaste, entonces solamente habría 00:07:16
dos métodos en una pila, el que 00:07:19
se llama de toda la vida push 00:07:21
que es, meten la pila, o lo que es lo mismo 00:07:22
apila arriba, ponen la cima 00:07:25
y el pop 00:07:27
que significa, sácame de la pila 00:07:28
que solo puede sacarme el que está arriba 00:07:30
entonces push y pop son las dos acciones 00:07:32
que se hacen con una estructura tipo pila 00:07:34
push es ponme arriba 00:07:36
y pop es sácame el de arriba 00:07:38
y los que están abajo ahí se quedan 00:07:39
irán saliendo con los sucesivos pop 00:07:41
claro, eso no los va haciendo 00:07:44
con los sucesivos pop irán saliendo 00:07:45
es una estructura de informática de toda la vida 00:07:47
que 00:07:49
es a la que se adaptan 00:07:51
pues la gestión de procesos 00:07:54
de los sistemas operativos 00:07:56
según se van encolando los contadores de programa 00:07:57
Pues hay muchos conceptos informáticos que se manejan con estructuras de pila. Y en esas pilas hay dos acciones, push y pull. Y luego la cola es algo muy parecido. La cola es una fila, una filita, ¿vale? Una filita donde tú vas encolando y vas sacando del otro lado. 00:08:00
es un concepto en realidad 00:08:22
no es más que un concepto 00:08:24
pero responde a muchas situaciones reales 00:08:25
en informática y en cualquier tecnología 00:08:27
en cualquier disciplina tecnológica 00:08:30
responde a una situación muy habitual 00:08:32
tú vas encolando y vas sacando 00:08:33
bueno pues 00:08:36
las acciones que se hacen 00:08:38
sobre las pilas y las colas 00:08:40
este push, este pop que digo 00:08:42
para que aparezcan 00:08:43
de alguna manera reflejadas 00:08:46
en la interfaz collection 00:08:48
para que aparezcan reflejadas 00:08:49
y que esto no las ignore, no ignore 00:08:51
estas estructuras, pues 00:08:52
implementan interfaces, se hacen 00:08:54
interfaces que tienen esos métodos 00:08:56
el push, el pop, el no sé qué 00:08:58
¿vale? Se hacen interfaces que los tienen 00:09:00
y linked list 00:09:02
la implementa, entonces si uno cotillea 00:09:04
dentro de linked list, si uno cotillea 00:09:06
como veis, array list 00:09:08
array list no 00:09:12
implementa esto, pero linked list 00:09:13
sí, ¿por qué se ha elegido 00:09:16
así? Porque recordad 00:09:19
que array list es muy bueno 00:09:20
para consultar, pero 00:09:22
fatal para meter y sacar. 00:09:24
Entonces, no tiene sentido simular 00:09:27
una pila con un array, porque es una locura. 00:09:28
Una pila, lo que tú estás haciendo es todo el rato 00:09:30
meter y sacar. Y no consultas jamás 00:09:32
en una pila. Una pila no consultas porque no puedes. 00:09:34
Entonces, no tendría ningún sentido 00:09:37
simular una pila con un array list. Es matar 00:09:38
moscas a cañonazos. Entonces, 00:09:40
una pila, una estructura de pila 00:09:42
o cola, se hace con un 00:09:44
linked list, con una lista enlazada, que es mucho más 00:09:46
eficiente para meter y sacar 00:09:48
al principio. 00:09:50
¿vale? por eso 00:09:50
esto implementa 00:09:52
esta de aquí, pero esta no, porque es que es una tontería 00:09:55
hacer esa cosa tan retorcida 00:09:57
bueno, pues entonces si cotilleamos 00:09:59
en las, en los métodos 00:10:01
de linked list, tiene algunos que no 00:10:03
tiene array list y que son 00:10:05
precisamente los relacionados con 00:10:07
los funcionamientos tipo pila y tipo cola 00:10:09
entonces, por ejemplo, en un 00:10:11
main cualquiera, yo me voy a 00:10:13
hacer un linked list 00:10:15
y un array list 00:10:17
Vale, entonces 00:10:19
Ya en la declaración 00:10:33
No he puesto list genérico 00:10:41
He puesto linked list y array list 00:10:43
Porque yo ahora lo que quiero es cotillear 00:10:45
Los métodos que me ofrece 00:10:47
Y si yo aquí pongo list 00:10:48
Ya sabéis que entonces el compilador 00:10:51
Solo me deja llamar a los métodos de list 00:10:53
A los de list 00:10:56
¿Vale? Es decir, yo solamente 00:10:57
Puedo llamar a los métodos 00:10:59
De la clase tal y como 00:11:02
Está declarada, no instanciada 00:11:03
¿Vale? 00:11:05
lo que pasa es que normalmente cuando uno hace una lista 00:11:07
sea enlazada, sea ArrayList 00:11:10
los métodos que quiere usar son los que 00:11:11
están en list, los que están ahí 00:11:13
no los específicos suyos 00:11:15
los que están ahí, ¿vale? por eso yo hasta ahora 00:11:17
por comodidad declaraba como 00:11:19
list y luego instanciaba como me daba la gana 00:11:21
pero es que ahora quiero acceder a los específicos 00:11:23
de LinkedList, a los específicos 00:11:26
de LinkedList 00:11:28
los específicos que implementan estos 00:11:29
que no están en list, no están 00:11:31
aquí, no están aquí 00:11:33
porque son métodos específicos 00:11:35
que implementan los de aquí 00:11:37
entonces si quiero cotillear 00:11:38
en los métodos específicos de linked list 00:11:41
que implementan los de aquí 00:11:43
no puedo declararlo como list 00:11:44
porque entonces solo veo los de aquí 00:11:46
¿vale? recordad cómo funciona la herencia 00:11:47
las interfaces, todo eso 00:11:50
bueno, pues por eso lo he declarado 00:11:52
como linked list 00:11:54
vale, pues si ahora 00:11:56
cotilleamos en 00:11:59
los métodos que me ofrecen 00:12:02
ambas clases, hay algunos 00:12:05
que son distintos. Lista 00:12:07
1, pues tiene los de list 00:12:12
por supuesto, añadir, añadir 00:12:14
todos, añadir muchos de golpe, añadir 00:12:16
una posición, añadir al principio, 00:12:18
tiene muchos, 00:12:20
pero es que además el index of que hemos usado, 00:12:22
el iterador para sacar iterador, 00:12:24
pero es que además tiene unos muy raros 00:12:26
que empiezan por P. 00:12:28
El pick, el pull, el push, 00:12:30
el pop, ¿vale? 00:12:32
Pues estos métodos 00:12:34
son métodos que en realidad hacen 00:12:35
lo mismo, el push 00:12:38
lo que está haciendo es lo mismo que añadir 00:12:39
al final el atlas, es lo mismo 00:12:42
pero han hecho otro igual que se llama push 00:12:43
solo por compatibilidad 00:12:45
porque push es el nombre habitual 00:12:47
con el que uno se refiere 00:12:49
a la acción de apilar en una pila 00:12:52
entonces 00:12:54
con este rollo lo que estoy diciendo es que 00:12:55
linked list te ofrece métodos con nombrecitos 00:12:57
que suenan 00:13:00
al funcionamiento de pilas 00:13:01
con su terminología habitual 00:13:04
por si uno quiere trabajar con algo como 00:13:05
si fuera una pila, pues porque 00:13:07
ya está, pues porque le gusta, porque anda 00:13:09
mira, esto que voy a trabajar 00:13:11
funciona como una pila, pues uso 00:13:13
una linked list y en lugar de añadir 00:13:15
hago push y hago pop y ya está, y queda 00:13:17
más bonito, estoy haciendo lo mismo que si hago add 00:13:19
vale, pero queda más bonito si lo llamo así 00:13:21
bueno, pues estos 00:13:23
métodos de aquí 00:13:25
que uno puede ver lo que hacen 00:13:26
pues te saca el elemento en la cabecera de la lista 00:13:29
o null si no sé qué 00:13:31
o pues lo mismo 00:13:33
te devuelve 00:13:34
este método es equivalente a 00:13:37
borrame el primero, pop es equivalente 00:13:40
a este, es el mismo, es otro con otro 00:13:42
nombre, pero como ese es el nombre 00:13:44
habitual de las pilas 00:13:46
pues te hacen otro con otro 00:13:48
nombre, el push 00:13:49
pues lo mismo, es el mismo que este 00:13:51
el push es igual que este 00:13:53
lo que pasa es que este 00:13:56
es la implementación de the queue 00:13:57
y at first es la implementación de list 00:13:59
están ahí doblados 00:14:01
pero bueno, esto es una jerarquía 00:14:04
de cosas, de métodos para que uno 00:14:06
pues tenga flexibilidad, para que sus aplicaciones 00:14:07
sean bonitas, elija lo que le guste 00:14:10
etcétera, vale 00:14:12
entonces si miramos en lista 2 00:14:13
que es ArrayList, esos 00:14:15
métodos no van a estar 00:14:17
esos métodos los buscamos, los que empiezan por 00:14:19
P y no están 00:14:25
no están, porque ArrayList 00:14:26
no implementa de queue, luego 00:14:29
no tiene esos métodos 00:14:31
no los tiene, podría 00:14:32
implementar de queue y podríamos simular una 00:14:35
pila y una cola con un ArrayList, pero 00:14:37
que poco eficiente, estaríamos rompiendo el array 00:14:39
creándolo cada dos por tres 00:14:42
pues no, implementamos de queue con linked list 00:14:44
y ya está, veis 00:14:46
esta tiene los de list 00:14:47
array list tiene los de list 00:14:48
y ya está, porque no los de list 00:14:51
y yo creo que no implementa ninguna otra 00:14:53
no, array list tiene los de list 00:14:55
ya está, no implementa nadie más 00:14:58
sin embargo, linked list 00:15:00
tiene los de list 00:15:01
y tiene los de de queue, tiene los dos 00:15:03
estos y estos, porque implementa 00:15:05
las dos, recordad que una clase 00:15:07
puede implementar muchas interfaces diferentes 00:15:10
pues LinkedList implementa esta 00:15:11
y esta, luego tiene más métodos 00:15:13
que en realidad 00:15:15
hacen lo mismo, pero tienen nombres distintos 00:15:17
para simular esos funcionamientos 00:15:19
¿vale? 00:15:21
y luego hay una clase interesante 00:15:23
que tampoco nos vamos a meter en ella 00:15:25
que es esta 00:15:27
que es una lista en realidad 00:15:29
una lista para 00:15:31
encolar cosas y desencolarlas 00:15:33
una lista, llamemos encolar 00:15:35
y desencolar, a meter y sacar. Es que es lo mismo. 00:15:37
Lo único es que te incorpora un mecanismo 00:15:40
para establecer 00:15:41
prioridad entre los elementos. Tú puedes establecer 00:15:43
prioridad y cuando tú encolas, en función 00:15:45
de la prioridad, él se cuela o no se cuela. 00:15:47
Entonces, te incorpora un 00:15:50
pequeño mecanismo para que tú establezcas 00:15:51
encólame, pero este tiene prioridad tal. 00:15:53
Pues se cuela a los demás. Puedes hacer 00:15:55
una jerarquía por prioridades. 00:15:57
Bueno, pues que sepáis que 00:16:00
existe, por si uno 00:16:01
resulta que tiene una aplicación 00:16:03
en la cual el concepto de prioridad 00:16:05
en los objetos, por alguna razón 00:16:07
importa, entonces dice 00:16:09
ah, pues que bonito, lo simulo 00:16:11
con Priority View, que no hace 00:16:13
falta, uno podría simular su prioridad y 00:16:15
programarla a su manera, pero bueno 00:16:17
hay una clase que te permite 00:16:19
encolar y desencolar 00:16:21
con prioridad, si tú fijas 00:16:23
una prioridad, pues si tienes una aplicación que es 00:16:25
justo eso lo que quieres hacer 00:16:27
venga, vamos a jugar a usar esta clase 00:16:28
en lugar de programarlo yo entero, lo que sea 00:16:31
vale 00:16:33
bueno 00:16:35
pues esta es más o menos la jerarquía 00:16:39
que esto si lo veis 00:16:41
pues ya os tiene que decir algo 00:16:43
y no tiene que asustaros 00:16:44
ni volveros locos 00:16:47
esta es la jerarquía 00:16:48
esto de queue es saber lo que es 00:16:50
y ya está 00:16:52
y ArrayList, LinkedList sabemos usarlo 00:16:55
y VectorStack era 00:16:57
la primera versión de pila que se hizo 00:16:58
hace siglos mil 00:17:01
antes de que se organizara ya por 00:17:03
implementaciones, ya no, vamos a hacer una implementación 00:17:06
queue, luego una de queue 00:17:08
linked list que implemente de queue, antes de 00:17:10
reorganizarlo todo, pues stack 00:17:12
era una clase para simular una pila 00:17:14
ya está, punto pelota 00:17:16
y vector era una clase 00:17:17
para simular una colección de datos 00:17:19
y ahí estaban 00:17:21
y se acabó 00:17:24
bueno y de aquí 00:17:27
pues tenemos 00:17:28
esto ahora, verdad 00:17:30
Tenemos ahora este marroncito 00:17:31
De conjuntos 00:17:33
Por aquí, para acabar con colección 00:17:35
Pues venga 00:17:37
Vamos a ello 00:17:41
Vale, a ver 00:17:48
Bueno, pues a ver, entonces 00:17:55
Los conjuntos son 00:18:07
Otra filosofía 00:18:10
Para guardar datos todos a mogollón 00:18:11
En este caso 00:18:14
No se van a guardar 00:18:16
En una posición concreta 00:18:18
Eso es lo que lo distingue de las listas 00:18:20
y ya está, que no se van a guardar en una posición 00:18:22
luego no existe 00:18:24
el get por posición, no existe 00:18:26
los datos están todos ahí 00:18:28
pero no tienen posición, luego la implicación 00:18:30
es que no 00:18:32
puedo guardar yo dos objetos cuyo 00:18:33
equals me dé true, no puedo 00:18:36
guardar dos objetos cuyo equals me dé true 00:18:38
porque entonces 00:18:40
para la clase colección serían 00:18:41
indistinguibles, serían completamente 00:18:44
indistinguibles, porque dos objetos 00:18:46
son distinguibles por el equals 00:18:47
¿vale? 00:18:49
entonces, yo no puedo meter 00:18:50
en un set dos conjuntos 00:18:53
cuyo equals de 00:18:55
true 00:18:56
a ver, si yo tengo dos objetos 00:18:58
alumno con mismo nif y nombre 00:19:01
dos objetos alumno con mismo nif y nombre 00:19:03
pero claro, yo no he 00:19:05
implementado equals, entonces 00:19:07
tira del equals de object 00:19:09
y el equals de object, ya sabéis que 00:19:11
significa, dos objetos son iguales 00:19:13
solo si son exactamente 00:19:15
uno encima de otro, es decir 00:19:17
responde a la misma dirección 00:19:19
entonces en ese caso, claro que puedo meterlos en un set 00:19:20
porque es que el equals da false 00:19:22
¿vale? 00:19:24
luego el criterio para ver si el set admite 00:19:26
dos objetos 00:19:29
es que su equals dé false 00:19:30
sea cual sea el equals 00:19:32
que tengan ellos, el heredado de 00:19:33
object, el suyo propio, etc. 00:19:36
¿vale? 00:19:39
bueno, por ejemplo, aquí 00:19:41
para ver un poquito 00:19:42
así, para introducirlo 00:19:43
y ya nos vamos 00:19:46
Esta es la interfaz 00:19:47
De nuevo es parametrizada 00:19:49
Estáis pensando que lo vayamos ya 00:19:51
Pero es que son las 2 y 6 00:19:54
Y a mí me pagan por esto 00:19:55
Es que entonces 00:19:56
Vale, pues entonces 00:19:58
De nuevo es parametrizada 00:20:01
Entonces yo debería decir 00:20:03
Oye, en este set mete objetos 00:20:05
Es que aparte, si os pongo a hacer ejercicio 00:20:08
Os pilláis todos, con lo cual yo de 2 a 2 y media 00:20:09
Lo tengo que reservar para dar clase 00:20:11
Así que 00:20:13
Vale, pues entonces 00:20:15
vamos a hacer un set de string 00:20:18
para ver esto 00:20:26
no, en un main diferente 00:20:27
porque tengo todo lo de arriba 00:20:32
ok, me voy a hacer aquí 00:20:34
otra clase main 00:20:42
vale, pues me voy a hacer un set 00:20:43
de cadenas, si me hago un set 00:20:59
de objetos cadena 00:21:01
pues lo debería parametrizar y decir string 00:21:02
vale, venga, esto van a ser 00:21:05
nombres, que implementación 00:21:07
elijo, hay tres 00:21:11
ya el viernes 00:21:12
veremos 00:21:15
en qué se diferencian 00:21:17
y qué matices hay de usar una 00:21:18
o usar la otra. 00:21:21
Pero lo que está claro es que las tres son 00:21:23
implementaciones de un conjunto. 00:21:24
Luego las tres valen para guardar cosas ahí 00:21:26
sin posición, con lo cual 00:21:29
no se admiten duplicados. 00:21:31
Sea cual sea la que yo elija. 00:21:33
Vamos a elegir la más eficiente. 00:21:35
Bueno, eficiente. 00:21:38
El haset. 00:21:40
Ya explicaremos el viernes el haset 00:21:41
cómo está hecho por dentro, que lo programamos nosotros 00:21:42
porque es una movida. 00:21:44
Esta es una implementación concreta de un conjunto. 00:21:47
Vale. 00:21:56
Vamos a meterle ahora nombres. 00:21:57
¿Cómo se inserta en un conjunto? 00:22:00
Exactamente igual que en cualquier otra colección. 00:22:04
Con el método add. 00:22:07
Exactamente igual. 00:22:09
Eso no cambia. 00:22:10
Insertar con el método add. 00:22:11
Pues nada. 00:22:13
Ya tenemos una cadena ahí. 00:22:14
Aquí para insertar no cambia. 00:22:20
vamos a meterle 00:22:22
a este conjunto 00:22:32
esta misma cadena otra vez 00:22:35
vale, muy bien, ahí 00:22:37
y ahora vamos a recorrer 00:22:41
la colección 00:22:43
vamos a recorrer esta colección 00:22:44
para ver que tiene 00:22:47
no podemos hacer esto 00:22:48
como hacíamos con la lista 00:22:51
si yo intento hacer esto 00:22:52
uy, perdón 00:23:00
nombres.size 00:23:04
si, eso no estabais tan dormidos 00:23:05
vale, si yo intento 00:23:10
hacer esto 00:23:12
nombres.get 00:23:13
y es que 00:23:15
me dice, ¿cómo que getty? 00:23:17
¿qué es eso de getty? este método no existe 00:23:20
ese método no existe 00:23:22
luego, no podemos recorrer una colección 00:23:23
un conjunto así 00:23:25
¿vale, Daniel? 00:23:26
todavía no he terminado de hablar 00:23:30
¿vale? 00:23:31
No puedo recorrerla así 00:23:33
Bueno, o iterador o for each 00:23:34
Si vamos a consultar, solo a consultar 00:23:37
El for each es lo más cómodo 00:23:39
Para cada cadena 00:23:41
C en nombres 00:23:43
Vamos a mostrar que es lo que tiene 00:23:47
¿Vale? 00:23:50
¿Vale? Esta es cada una de las cadenas 00:23:53
Hemos hecho un conjunto 00:23:55
Le hemos metido tres cadenas 00:23:57
Y vamos a mostrar lo que tiene 00:23:59
Vale, ejecutamos este main 00:24:00
Tramposa 00:24:02
Tramposa no 00:24:06
Irresponsable 00:24:09
Vale 00:24:12
Pues efectivamente 00:24:15
El tercer ola ha pasado de él 00:24:17
¿Vale? 00:24:19
El tercer ola ha pasado de él 00:24:22
Porque ya estaba 00:24:24
Entonces a ver, ojo porque el problema 00:24:25
Aquí no es de compilación 00:24:28
Sino que es de tiempo de ejecución 00:24:30
Entonces el compilador 00:24:31
le da lo mismo, tú lo que has hecho está bien 00:24:34
que es meter 00:24:36
una cadena en un conjunto 00:24:37
de cadenas, está bien 00:24:40
y el método ha hecho lo que tenía que hacer, que es decir 00:24:41
venga, hola, voy a recorrer la colección 00:24:43
¿hay alguno 00:24:46
que sea igual que hola? sí lo hay 00:24:47
bueno, lo meto, y ya está, y no lo ha metido 00:24:49
y no te dice nada 00:24:52
entonces cuidado 00:24:54
porque a veces uno se puede perder 00:24:55
y decir, ¿por qué no me está funcionando? 00:24:57
a ver, tienes un conjunto 00:24:59
tú puedes intentar meter algo 00:25:00
Y si no puede ser, no puede ser 00:25:03
Vais a sacar un cero muy gordo, ¿eh? ¿Lo sabéis? 00:25:04
Vale 00:25:10
Vale, pues esta es 00:25:11
La principal diferencia 00:25:15
Que no tiene get 00:25:17
Y que no podemos meter duplicados 00:25:18
Ahora lo que tenemos que ver 00:25:21
Como está hecho por dentro y las implicaciones que tiene a la hora de usarlo 00:25:26
¿Vale? Venga, vamos a dejarlo aquí 00:25:30
Porque me estoy poniendo muy nerviosa 00:25:31
Lo de hablar sola 00:25:33
¡Gracias! 00:25:37
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
11
Fecha:
6 de marzo de 2024 - 12:28
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
25′ 37″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
101.63 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid