Saltar navegación

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

Clase 27-02-24 - 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 27 de febrero de 2024 por Raquel G.

7 visualizaciones

Más información Transcripción

Descargar la transcripción

Que un problema que necesitamos resolver para hacer nuestras aplicaciones es el de poder almacenar un montón de datos, muchísimos. 00:00:01
Para eso tenemos variables, pero muchísimas variables no son la solución. 00:00:13
Porque un montón de variables, así sueltas y declaradas, no es la solución. 00:00:17
Tenemos el array, estructura de cualquier lenguaje de pronunciación. 00:00:21
Por si no puede usar el array, pero es incómodo. 00:00:25
Es incómodo para insertar y recuperar porque no es dinámico, porque es estático, porque el tamaño está fijo. 00:00:29
Entonces, se idean soluciones para guardar un montón de datos bajo una misma referencia, 00:00:37
de tal manera que yo no tenga que declarar muchas variables, declaro una, 00:00:45
la de la colección de datos, declaro una y solamente bajo una referencia tengo un montón de datos 00:00:48
que puedo recorrer, puedo insertar datos nuevos, puedo recuperar, entonces se idean soluciones, ¿verdad? 00:00:55
Y entonces vimos una solución ideada que es la lista enlazada y la programamos y vimos cómo usarla, ¿vale? 00:01:01
Bueno, pues entonces efectivamente todo esto está hecho, de alguna manera todo esto está hecho 00:01:11
y hay un montón de clases para resolver este problema. 00:01:16
algunas de ellas son idénticas 00:01:18
a las dos que esbozamos ayer 00:01:21
la lista enlazada y el array list 00:01:23
ese de ahí, que era un array 00:01:25
que yo le hacía métodos 00:01:27
para hacerlo grande y pequeño 00:01:29
según me interesaba 00:01:31
pero aparte de esas dos hay muchas más clases hechas 00:01:32
porque 00:01:35
en el lenguaje de programación Java 00:01:37
y en cualquier otro 00:01:39
lo que se ha ideado es, venga pues vamos a hacer clases 00:01:42
para solucionar este problema 00:01:44
de muchas formas distintas, de muchas 00:01:45
de más formas de las que planteamos ayer 00:01:47
de muchas más, entonces hay un montón 00:01:50
de clases que ya están hechas para resolver 00:01:52
este problema, el de guardar 00:01:53
un montón de datos 00:01:55
bajo la misma referencia, bajo un mismo 00:01:57
nombre de variable, hay un montón de clases 00:01:59
bueno, pues los que se pusieron 00:02:02
a hacer estas clases 00:02:03
los que se pusieron a hacerlas 00:02:05
dijeron, venga, vamos a organizarlo 00:02:07
¿cómo organizamos este maremagnum de clases? 00:02:09
que valen todas para lo mismo 00:02:12
está claro, para guardar muchos datos juntos 00:02:13
Pero cada una lo hace de una manera distinta. ¿Cómo las organizamos? Bueno, pues efectivamente se han organizado haciendo una jerarquía, una jerarquía de interfaces y clases abstractas de las cuales una se le da en directo. 00:02:15
entonces 00:02:30
las interfaces, las clases 00:02:34
las clases abstractas, la herencia de clases 00:02:36
la implementación de interfaces 00:02:38
eso que ya entendemos y ya vemos lo que es 00:02:40
es la herramienta para diseñar 00:02:43
cualquier conjunto de clases que haga cosas 00:02:45
es la herramienta que se hace 00:02:47
tú te haces una interfaz 00:02:49
haces varias implementaciones 00:02:50
a su vez de una de ellas heredas 00:02:51
para particularizarla y hacer otra que sea un poquito distinta 00:02:53
esa es la forma de diseñar 00:02:57
con una especie de jerarquía 00:02:59
de manera que todo lo que se comparta esté junto, pero luego haya diferentes particularidades, etc. 00:03:00
Bueno, pues así se han organizado las clases relacionadas con el almacenamiento de datos. 00:03:07
Así se han organizado, tenía una jerarquía. 00:03:12
Bueno, vamos a ver un poco estas clases, entonces, cómo son, las que ya están hechas, repito, 00:03:14
y las que nosotros lo que vamos a hacer es aprender a utilizarlas bien, aprender a utilizarlas bien. 00:03:18
Pues vamos a ver estas clases que ya están hechas, cómo están organizadas y cómo usarlas, claro. 00:03:24
Vale, pues el que pensó todo este meollo de las clases para guardar datos, el que pensó todo este rollo, lo primero que pensó es el darle un nombre, darle un nombre general a todas las clases que se ocupan de eso, 00:03:30
de guardar un montón de datos 00:03:54
bajo la misma referencia 00:03:56
bueno pues el nombre que he decidido darle 00:03:57
es el nombre de 00:04:00
me he pasado de tamaño 00:04:04
es el nombre 00:04:05
de colecciones 00:04:08
por esto este tema que estamos viendo 00:04:09
se llama el tema de colecciones 00:04:12
entonces las clases 00:04:13
que sirven para guardar datos 00:04:16
bajo una misma referencia son las colecciones 00:04:18
bueno pues entonces a la hora de organizarlas 00:04:20
se dijo ah vale fenomenal 00:04:24
Pues vamos a hacer una interfaz 00:04:26
Una interfaz que se llame 00:04:27
Collection, vamos a hacer una interfaz 00:04:29
Y esta interfaz 00:04:32
Que me diga 00:04:34
Los métodos que tiene que satisfacer 00:04:35
Cualquier cosa que quiera ser una colección 00:04:38
Esa es la base 00:04:40
De una, cuando se usan interfaces para diseñar 00:04:42
Se hace así, dices, oye yo quiero hacer 00:04:44
Varias cosas 00:04:46
Que ejecuten 00:04:47
Un comportamiento, aunque cada una 00:04:50
Lo haga de una manera distinta 00:04:51
Yo quiero un montón de animalitos 00:04:53
Un perro, un gato, un ratón 00:04:57
Cada uno de ellos hace sus cosas 00:04:58
Pero todos ellos quiero que coman 00:05:00
Cada uno a su manera 00:05:02
Pues la forma de diseñar eso ya sabemos que sería 00:05:04
Me hago una interfaz única 00:05:07
Con el método comer vacío 00:05:10
Y luego ya cada animalito 00:05:13
Implementa esa interfaz 00:05:15
Y cada uno decide 00:05:17
Cómo implementa el método comer 00:05:19
Cada uno lo decide 00:05:21
Es la manera de diseñar, ¿no? Pues aquí igual, el que pensó todo esto de las clases, colecciones, dijo, vamos a hacernos una interfaz colección, con los métodos básicos que yo quiero que haga cualquier clase que sea una colección, que serán insertar, eliminar, los que se decidan, y ahora ya me hago todas las clases que yo quiera y que cada una, ese método insertar lo haga a su manera, cada una como quiera, ¿vale? 00:05:21
nosotros ya hemos visto dos de hecho distintas 00:05:49
el ArrayList y la lista enlazada 00:05:51
que las hemos hecho nosotros por libre 00:05:52
pero serían 00:05:54
dos implementaciones de lo mismo 00:05:57
de meter datos en un sitio 00:05:58
bueno, pues entonces tenemos una interfaz 00:05:59
Collection, una interfaz 00:06:03
que tiene unos métodos vacíos 00:06:04
y ahora ya 00:06:07
se pueden hacer implementaciones 00:06:08
de esa interfaz 00:06:11
y cada clase que implemente esa interfaz 00:06:12
decide como hace 00:06:15
Lo de insertar, borrar, etc 00:06:16
Entonces esta interfaz colección 00:06:19
A ver 00:06:22
Vamos a abrir el 00:06:25
Eclipse 00:06:27
Vale, me voy a hacer aquí un proyecto 00:06:30
Jerarquía colecciones 00:06:54
Para estas cositas 00:06:55
Que vamos a explicar 00:06:57
Jerarquía de colecciones 00:06:59
Pues venga 00:07:11
Venga, voy a hacer un paquete cualquiera 00:07:12
Un paquete cualquiera 00:07:20
Con un main 00:07:22
Vale 00:07:24
una clase main cualquiera 00:07:25
para poder hacer código 00:07:33
bueno pues entonces 00:07:35
dentro de las clases 00:07:38
de la máquina que nos ofrece 00:07:41
la JDK 00:07:43
esas que hemos abierto a veces aquí a la izquierda 00:07:44
esto que está aquí en la JRE 00:07:47
esto que hemos visto que nos da un montón 00:07:49
de clases ya hechas de las cuales algunas 00:07:51
ya hemos usado como string, scanner, etc 00:07:53
pues dentro de todas ellas 00:07:55
están las clases 00:07:57
que son las colecciones 00:07:59
¿Y dónde están? En Java útil 00:08:00
¿Vale? Están en Java útil 00:08:03
Bueno, pues en Java útil 00:08:05
Está esa interfaz de la que venimos hablando 00:08:07
Que es esta 00:08:10
Entonces 00:08:10
Cualquier clase que sea colección 00:08:13
Implementa esta interfaz 00:08:16
De aquí, implementa esa 00:08:18
¿Veis? Colección está en Java útil 00:08:20
Que es el paquete donde están 00:08:30
Todas las clases relacionadas 00:08:32
Con colecciones 00:08:34
Las estándares 00:08:34
Las estándares de Java 00:08:38
Luego hay colecciones específicas 00:08:39
Para usos concretos 00:08:40
Las estándares de Java están ahí 00:08:41
Vale, entonces 00:08:43
Collection no es una clase concreta 00:08:44
Collection, si entramos dentro 00:08:49
En la implementación 00:08:51
Vamos a ver cómo está hecha 00:08:53
Collection 00:08:54
Collection que está aquí 00:08:55
¿Veis? 00:08:59
Collection es una interfaz 00:09:01
Esto es Collection, una interfaz 00:09:02
y encima genérica, ya sabemos lo que es ser genérico 00:09:05
y es que depende de un tipo de dato, entonces cualquier clase 00:09:10
que implemente esta interfaz, cualquier clase que implemente esta interfaz 00:09:14
tendrá que dar contenido a los métodos que tiene 00:09:18
y los métodos que tiene, los veremos por encima, son los métodos relacionados con hacer lo que se hace con las colecciones 00:09:21
meter un dato nuevo, sacar un dato nuevo 00:09:26
entonces esta interfaz colección te dice, oye, tu clase quieres ser colección 00:09:29
quieres implementarme, pues di 00:09:34
cómo vas a hacer la inserción, di cómo vas a hacer 00:09:36
el borrado y ya está 00:09:38
y luego clases 00:09:40
implementaciones de colección 00:09:42
puede haber tropecientas, cada una 00:09:44
hará la inserción de una manera, el borrado 00:09:46
de una manera 00:09:48
ayer 00:09:48
repito, vimos dos de ejemplo 00:09:50
pues una lista enlazada hace la inserción 00:09:53
de una manera, una railis 00:09:56
lo hace de otra manera, pues todas ellas 00:09:58
son implementaciones de esta 00:10:00
entonces esta es una interfaz 00:10:02
que tiene unos métodos vacíos 00:10:04
y cualquiera que lo implemente 00:10:06
los tiene que 00:10:08
que dar cuerpo, por ejemplo 00:10:09
tiene el método size, que tú quieres ser colección 00:10:12
muy bien, pues tienes que implementar 00:10:14
un método para devolver cuántos elementos 00:10:16
tienes dentro, vale 00:10:18
pues cada colección lo implementará como sea 00:10:19
y así unos métodos básicos 00:10:22
que quieres ser colección, pues tienes que implementar un método 00:10:24
para devolver true o false 00:10:26
en función de si estás vacía o no estás vacía 00:10:27
y poquitos métodos tiene 00:10:30
que quiere ser colección 00:10:32
vale, pues tienes que tener un método 00:10:33
tienes que implementar un método contains 00:10:35
al que si se 00:10:38
pasa un objeto 00:10:40
tienes que decir true o false 00:10:41
en función de si ese objeto 00:10:44
está en tu colección, está dentro o no 00:10:45
eso es lo que 00:10:48
nos dice la interfaz colección, nos obliga 00:10:50
a implementar esto 00:10:52
el iterador, eso ya lo veremos 00:10:52
pues es devolver un elemento 00:10:55
para poder recorrerlo de forma sencilla 00:10:57
bueno 00:10:59
esto para convertirlo en un array 00:11:00
sobre todo 00:11:03
lo que más nos interesa 00:11:08
es este 00:11:10
tú quieres ser colección 00:11:11
pues tienes que implementar un método 00:11:13
que permita insertar un elemento 00:11:16
del tipo genérico 00:11:19
que sea en la colección 00:11:20
si quieres ser colección tienes que decir 00:11:21
cómo vas a hacer el app 00:11:23
colección es una interfaz vacía 00:11:25
lo único que dice es tú quieres implementar colección 00:11:27
pues dime cómo vas a hacer todo eso 00:11:30
vale 00:11:32
y así poquitos métodos 00:11:34
no tiene mucho más 00:11:37
remove, que quiere ser colección, vale 00:11:38
pues di como vas a implementar 00:11:41
si yo te paso un objeto, eliminarlo 00:11:43
si está en tu 00:11:45
dentro de tu colección 00:11:47
lo mismo, este para añadir 00:11:49
un montón de golpe 00:11:53
le pasas 00:11:55
a su vez otra colección 00:11:57
de datos, otra 00:11:59
y te los añade todos de golpe 00:12:00
bueno, pues esto tiene el método 00:12:03
la interfaz 00:12:05
collection, ¿vale? Tiene una serie de métodos 00:12:07
vacíos 00:12:10
una serie de métodos vacíos 00:12:10
y el que quiera implementar 00:12:13
las clases que quieran implementar collection 00:12:15
pues tienen que dar cuerpo 00:12:17
a esos métodos 00:12:19
entonces una forma 00:12:21
de unificar, para eso van las interfaces 00:12:23
para unificar el diseño 00:12:25
entonces aquí, esta colección 00:12:26
C, si yo aquí quiero poner 00:12:29
en esta colección tengo un montón de clientes 00:12:31
de los cuales pues quiero 00:12:34
poner 00:12:35
quiero pues eso 00:12:36
quiero meter en la colección un montón de clientes 00:12:39
no puedo 00:12:41
crear una colección directamente 00:12:44
obviamente 00:12:45
no puedo hacer esto 00:12:46
porque collection es 00:12:49
una interfaz 00:12:53
y de una interfaz no se instancian objetos 00:12:54
ni de una clase abstracta 00:12:57
se instancian objetos de clases 00:12:59
pero lo que se instanciaré es 00:13:00
cualquier clase que implemente 00:13:03
colección, de cualquiera que implemente 00:13:06
colección, de esas ya sí 00:13:08
¿y qué implementaciones 00:13:09
hay de colección? pues hay 00:13:12
un montón de implementaciones de colección 00:13:14
distintas, hay muchísimas 00:13:16
muchas, pues de nuevo 00:13:17
como hay muchas, no sólo 00:13:20
la lista enlazada y el 00:13:22
array list que vimos ayer, sino 00:13:24
muchas otras alternativas aparte de eso 00:13:25
entonces como hay muchas implementaciones 00:13:28
distintas de colección, de nuevo 00:13:30
surgió el problema de 00:13:31
vamos a organizarlas. En lugar de 00:13:33
tener una jerarquía de dos pisos 00:13:36
interfaz colección 00:13:38
y ahora aquí un montón de clases 00:13:40
implementando, dijera vamos a hacer 00:13:41
una jerarquía de tres pisos, así que 00:13:44
más organizadito. Y es vamos a hacer 00:13:45
un primer tipo de división y es 00:13:48
colecciones hay 00:13:50
de dos tipos, listas 00:13:52
y conjuntos. Esa es la primera 00:13:54
división que se hizo. Colecciones hay de dos tipos 00:13:56
listas y conjuntos. 00:13:58
Y luego ya tendré de listas unas cuantas implementaciones y de conjuntos unas cuantas implementaciones. 00:14:00
Entonces, una jerarquía de tres plantas. 00:14:09
Alguna añadida en función de lo que particularice la lista, pero esencialmente de tres plantas. 00:14:11
Vale, pues entonces, Collection, hay dos tipos. 00:14:17
Hay dos tipos de colecciones. 00:14:22
Las listas y los conjuntos. 00:14:25
vale, pues porque hay dos tipos 00:14:30
porque hay dos tipos 00:14:36
bueno, porque se decide que hay dos formas 00:14:39
de funcionar posibles, cuando yo quiero meter 00:14:41
datos de golpe en una colección 00:14:44
puede interesarme 00:14:46
que tengan 00:14:49
una posición fija 00:14:51
o me puede dar igual 00:14:53
son dos situaciones distintas 00:14:55
vale 00:14:58
yo tengo un montón de alumnos y los tengo que almacenar en clase 00:14:59
a lo mejor 00:15:02
necesito tenerlos 00:15:03
a cada uno ubicados en una posición 00:15:05
y que la posición les caracterice 00:15:07
y que sea siempre la misma 00:15:09
me puede interesar eso 00:15:11
o no, o con que estén en el aula 00:15:12
aunque estén rondando puede ser suficiente 00:15:15
son dos formas distintas 00:15:17
de guardar un montón de datos 00:15:19
cada uno en una posición que lo identifica 00:15:20
tú eres Miguel y estás en la mesa 3 00:15:24
tú eres John y estás en la mesa 4 00:15:26
o no, simplemente 00:15:28
tú eres Miguel, tú eres John y me da igual donde estés 00:15:29
son dos filosofías diferentes de almacenamiento 00:15:31
almacenar fijando una posición 00:15:34
y que esa posición te distinga 00:15:37
de los demás 00:15:39
o no fijar una posición 00:15:39
con lo cual si no fijas una posición 00:15:42
lo único que te distingue de los demás 00:15:44
son tus características, no donde estás 00:15:46
entonces son dos filosofías 00:15:48
diferentes de almacenar 00:15:51
en la de las listas 00:15:52
ahí te caracteriza tus propiedades 00:15:54
obviamente, pero también te caracteriza el sitio 00:15:56
donde estás, la posición que se llama 00:15:59
la posición 00:16:01
entonces yo puedo distinguir a Adrián y a Miguel 00:16:01
por donde están 00:16:04
este está en la mesa 2 y este en la mesa 3 00:16:06
no hace falta que les mire 00:16:08
sé que Adrián es el que está ahí y Miguel es el que está ahí 00:16:10
vale, pero en la filosofía de conjunto 00:16:13
como están todos ahí rondando 00:16:15
yo necesito conocer sus características 00:16:16
para distinguirlos, porque solo se distinguen 00:16:18
por sus características, no por donde están 00:16:20
porque no tienen sitio asignado 00:16:22
bueno, pues como hay 00:16:24
esas dos formas de plantearse el almacenamiento 00:16:26
por eso 00:16:29
hay dos tipos de colecciones 00:16:29
las listas y los conjuntos 00:16:33
en las listas la posición cuenta 00:16:34
y cada objeto tiene su posición en la lista 00:16:37
empezando desde la 0 00:16:40
la posición 0, la 1, la 2, la 3 00:16:42
en los conjuntos la posición no cuenta 00:16:45
y cada objeto está en el conjunto 00:16:48
y no tiene posición asignada 00:16:50
simplemente está o no está 00:16:53
ya está, o está o no está 00:16:55
en la lista estás 00:16:57
y estás en una posición 00:17:00
en el conjunto estás 00:17:01
¿vale? 00:17:03
entonces, es más fácil 00:17:05
manejar un conjunto 00:17:07
computacionalmente, es más eficiente 00:17:09
un conjunto, porque todo el tema 00:17:11
de la posición no tienes que llevarlo siempre 00:17:14
arrastrado, no tienes que llevar las cuentas 00:17:15
computacionalmente, es más fácil 00:17:18
computacionalmente es más 00:17:19
sencillo, pero es que hay veces 00:17:21
que hace falta tener el registro 00:17:23
de la posición 00:17:26
y por qué a veces hace falta 00:17:26
es decir 00:17:34
porque a efectos computacionales 00:17:35
uno elegiría siempre un conjunto 00:17:38
diría no, yo quiero meter un montón de datos 00:17:40
pues un montón de datos es un conjunto, ya está 00:17:41
pero hay veces que el conjunto 00:17:44
no te vale, necesitas una lista 00:17:46
y en qué situaciones no te vale 00:17:48
el conjunto, necesitas una lista 00:17:50
pues cuando 00:17:52
tú quieres tener elementos 00:17:54
duplicados 00:17:56
o repetidos 00:17:58
¿vale? 00:17:59
o sea, yo quiero guardar 00:18:01
bolas verdes y bolas rojas 00:18:03
en un conjunto 00:18:06
como no tiene una posición asignada 00:18:08
yo solo puedo distinguir 00:18:11
una bola verde y una bola roja 00:18:12
el resto es que son indistinguibles 00:18:14
porque están ahí flotando 00:18:17
no puedo distinguir las bolas verdes entre sí 00:18:18
es imposible 00:18:20
una vez que están metidas en el conjunto 00:18:20
todas las bolas verdes son indistinguibles 00:18:22
pero una lista 00:18:25
las puedo distinguir porque cada bola verde 00:18:27
tiene su sitio y una vez que yo las he metido 00:18:30
sé que esa es la primera que metí 00:18:32
y sé que esa es la segunda y sé que esa es la tercera 00:18:34
las puedo distinguir porque cada una tiene su posición 00:18:36
si yo las he hecho en un conjunto 00:18:38
una vez metidas, no sé cuál es la primera que metí 00:18:40
no sé cuál es la segunda, no tengo ni idea 00:18:42
porque no las puedo distinguir por la posición 00:18:44
luego el criterio 00:18:46
para decidir 00:18:48
qué tipo de colección usa alguien para meter sus datos 00:18:50
si lista o conjunto 00:18:52
si necesita distinguir 00:18:55
los duplicados 00:18:58
o no, es decir 00:18:59
si quiere que haya elementos duplicados 00:19:01
o si no quiere que los haya 00:19:03
porque el conjunto 00:19:05
no permite meter 00:19:07
elementos duplicados 00:19:09
yo tengo la cadena hola 00:19:10
por ejemplo, la meto en la lista 00:19:15
ahí se queda la cadena hola 00:19:17
ahora meto la cadena dios 00:19:19
muy bien, se queda en la lista, en su segunda posición 00:19:21
vale, ahora meto una cadena 00:19:23
que es hola otra vez, genial 00:19:25
aquí se queda en su tercera posición 00:19:27
perfectamente distinguible de la primera 00:19:29
son dos cadenas hola, pero esta está aquí y esta está aquí 00:19:30
y así puedo trabajar, en un conjunto 00:19:33
esto mismo, yo meto la cadena 00:19:35
hola, fenomenal, ahí se queda la cadena hola en mi conjunto 00:19:37
ahora meto la cadena dios 00:19:39
fenomenal, ahí se queda en mi conjunto 00:19:41
ahora intento meter la cadena hola 00:19:43
otra vez en el conjunto, no me deja 00:19:45
la colección no me deja 00:19:47
me dice no, ya hay una cadena 00:19:49
que se llama hola, no la puedes meter otra 00:19:51
igual porque sería indistinguible, es imposible 00:19:53
no tiene posición asignada 00:19:55
entonces a un conjunto 00:19:57
no se le pueden meter elementos repetidos 00:19:59
está hecha de tal 00:20:01
forma que no te deja, no puedes meter 00:20:03
elementos repetidos, no puedes 00:20:05
a una lista sí, porque son 00:20:07
perfectamente distinguibles por posición 00:20:09
luego eso 00:20:11
es lo que nos hace elegir si queremos 00:20:13
uno o si queremos el otro 00:20:15
si queremos que mi almacén de datos 00:20:16
haya repetidos 00:20:19
o no necesito yo que haya 00:20:20
repetidos, no lo necesito 00:20:23
si necesito que haya 00:20:25
repetidos una lista 00:20:27
y si no lo necesito, si todos los 00:20:28
elementos que yo emeta van a ser distintos 00:20:31
distinguibles 00:20:33
por sus propiedades, distinguibles por 00:20:35
propiedades, pues elegiría un conjunto 00:20:37
que es más eficiente 00:20:39
computacionalmente, porque no tiene 00:20:40
que llevar registro de posición ni de nada 00:20:43
luego eso es 00:20:44
la distinción de los dos tipos de colecciones 00:20:45
que hay, listas y conjuntos 00:20:49
vale, pues como hay dos tipos, entonces dicen 00:20:50
¿Vale? Pues vamos a hacer dos implementaciones de colección. 00:20:53
Una que se llama list y otra que se llama set. 00:20:56
List, pues de listas, obviamente. 00:21:00
Y set de conjuntos. 00:21:04
¿Vale? Son dos implementaciones distintas. 00:21:14
Entonces, si yo escribo aquí list para poder entrar en ella, 00:21:20
voy a escribir aquí list para list. 00:21:24
como veis, pues está en 00:21:33
su Java útil también 00:21:35
vale, pues si entramos en list 00:21:36
de Java útil 00:21:41
en esta 00:21:44
pues list resulta que otra vez 00:21:45
es una interfaz 00:21:49
vale 00:21:49
a través de esta 00:21:51
implementa la de arriba 00:21:58
la de colección, pero bueno, la jerarquía exacta 00:22:01
no nos importa porque esto se le han ido metiendo 00:22:03
chorraditas y es un caos 00:22:05
vale, entonces 00:22:07
quedaos con que list y set 00:22:09
son los dos tipos de implementaciones 00:22:11
que hay de las colecciones, listas y conjuntos 00:22:14
pero resulta que list 00:22:16
a su vez es otra interfaz 00:22:18
porque claro, list 00:22:19
lo que dice es vale, pero hay diferentes 00:22:22
tipos de listas, ayer vimos 00:22:24
dos, el array list 00:22:26
la lista enlazada 00:22:27
entonces list todavía 00:22:29
no puede pronunciarse 00:22:31
respecto a cómo va a hacer el add, cómo va a hacer 00:22:34
el remove, todavía no puede 00:22:36
porque hay diferentes variantes 00:22:37
lo que hace list es a los métodos 00:22:40
básicos de cualquier colección, al add, al remove 00:22:42
le añade los propios de las listas 00:22:45
que son los que usan la posición 00:22:47
los que usan la posición 00:22:48
por ejemplo 00:22:50
estos que tenía colección 00:22:51
los tiene pero los sigue dejando 00:22:55
vacíos, los sigue dejando vacíos 00:22:57
porque todavía no puede darles cuerpo 00:22:59
porque depende del tipo de lista que sea 00:23:01
si es a raíz, si es enlazada 00:23:02
y añade otros vacíos 00:23:04
que no estaban en colección 00:23:07
que son los relacionados con la posición. 00:23:08
Como 00:23:12
este ya lo añadía, 00:23:12
pero vamos a poner uno. 00:23:17
Vamos a buscar el get. 00:23:19
A ver si nos aparece por ahí. 00:23:21
Rápidamente. 00:23:23
Aquí está. 00:23:26
Por ejemplo, este método no estaba 00:23:27
en collection, porque este 00:23:29
método de list te dice, recupérame 00:23:31
el elemento de posición 00:23:33
tal. Esto solo tiene sentido 00:23:35
en una lista, porque 00:23:37
solo en una lista los elementos tienen 00:23:39
posición. Solo en la lista. 00:23:41
En los conjuntos no la tienen. 00:23:43
Y en las colecciones genéricas tampoco. 00:23:45
Una colección genérica no tiene por qué ser una lista. 00:23:46
Entonces, este método lo ha 00:23:49
incorporado a la interfaz list. 00:23:51
Lo ha incorporado a la interfaz list. 00:23:53
Porque para las listas sí tiene 00:23:55
sentido recuperar por posición. 00:23:57
Ha incorporado ese método 00:23:59
y todos los relacionados con hacer 00:24:00
cosas por posición. 00:24:03
Porque las listas 00:24:05
trabajan con posiciones. 00:24:06
Sin embargo en el set por mucho que busquemos get por posición no lo vamos a encontrar, si yo me voy aquí a la interfaz set que a su vez es otra interfaz, de esta tampoco puedo instanciar, tiene implementaciones ya concretas, si me voy a la interfaz set, pues esta por mucho que busquemos el get por posición no lo tiene, ni tiene ningún método que recurra a posiciones, porque no existen. 00:24:09
Tiene 00:24:49
Los que tienen que implementar cualquier conjunto 00:24:51
Los que ha añadido que le gustan 00:24:55
Para trabajar con conjuntos 00:24:58
Y poquita cosa 00:24:59
Ni tiene get, ni tiene nada 00:25:00
Esto ya se acaba rapidísimo 00:25:03
No tiene muchos métodos 00:25:06
Ya estamos casi al final 00:25:08
Y ni ha aparecido get, ni ha aparecido en ningún sitio 00:25:13
Ni index, ni nada 00:25:15
¿Vale? 00:25:16
Bueno, pues estos son los dos tipos de colecciones 00:25:22
Luego hay otra forma de guardar datos 00:25:25
Que es 00:25:28
Que se usa muchísimo 00:25:29
Que es el concepto de diccionario en informática 00:25:30
Muchos datos van asociados a una clave 00:25:33
Ya lo habéis visto en bases de datos 00:25:36
Y la clave 00:25:39
Nos sirve para distinguir a unos de otros 00:25:41
O sea, el concepto de clave 00:25:43
En informática es básico 00:25:44
Clave es algo que identifica de forma única 00:25:46
Cualquier cosa 00:25:49
Cualquier cosa 00:25:51
Eso es la clave 00:25:53
entonces por eso hay una estructura 00:25:53
habitual en informática que son los pares 00:25:55
clave, valor 00:25:58
esta clave, su valor 00:26:00
esta clave, su valor 00:26:02
que es el diccionario de toda la vida 00:26:04
palabra, significado, palabra, significado 00:26:05
palabra, significado 00:26:08
todas las palabras del diccionario son distintas 00:26:09
por eso son claves, aunque puedan compartir 00:26:12
significados 00:26:14
bueno, pues una forma habitual 00:26:15
de guardar datos 00:26:18
en informática es 00:26:19
pares, clave, valor, clave, valor, clave, valor. 00:26:22
Entonces, esto no nos vale para guardar pares, 00:26:25
nos vale para guardar objetos. 00:26:29
Otra cosa es que dentro de ese objeto yo decida los campos que yo quiera, 00:26:31
los que yo quiero, como si quiero que los campos sean una clave y un valor. 00:26:34
Pero esto está pensado para guardar un objeto. 00:26:37
Entonces, para adaptarnos a guardar pares, clave, valor, clave, valor, 00:26:42
o sea, pares de datos, no solo uno, como aquí, sino pares, 00:26:45
puestas a otra estructura que son los mapas 00:26:49
pero esos van por libres, esos no heredan 00:26:51
de colección, esos van por libre 00:26:53
¿vale? 00:26:55
los veremos cuando hayamos visto esto de colección 00:26:57
bueno pues entonces 00:27:00
tenemos listas y conjuntos y ahora 00:27:03
ya si, de listas 00:27:05
ahora ya si que hay implementaciones 00:27:07
concretas que ya podemos usar 00:27:10
y de conjuntos 00:27:12
hay implementaciones concretas 00:27:14
que podemos usar 00:27:15
¿Vale? Ya entendiendo, Andrés, ya entendiendo lo que es cada una y en qué situaciones me interesa a mí elegir de este tipo, elegir de este tipo, pues ya podemos usar implementaciones concretas que ya están hechas. 00:27:16
No tenemos que hacerlas nosotros, como ayer, porque ya están hechas. 00:27:32
Bueno, pues vamos a ver implementaciones concretas de list, de la clase list. 00:27:39
Vale, bueno, voy a buscar, para que veáis simplemente un pantallazo de la jerarquía de colecciones, vamos a poner internet, vale, pues vamos a ver, aquí esto nos da, vale, a ver si nos sale algo bonito. 00:27:45
vale, pues esta es un poquito 00:28:36
la jerarquía, con clases que están 00:29:00
ahí metidas, pero no os volváis 00:29:02
locos con esta jerarquía 00:29:04
lo que aquí nos tenemos 00:29:05
esta interfaz 00:29:08
colección, lo que pasa es que hay una por encima 00:29:09
que es iterable 00:29:12
que incorpora 00:29:14
el concepto de si yo tengo un montón de datos 00:29:16
un montón de datos, la idea es que yo 00:29:18
pueda iterar por ellos 00:29:20
entonces se hace una interfaz iterable que es cualquier 00:29:21
cosa por la que tu 00:29:24
por la que se pueda iterar que implemente 00:29:25
iterable, es una cosa más genérica 00:29:28
de colección, que es cualquier cosa por la que se 00:29:30
pueda iterar, bueno pues 00:29:32
una colección debería poder 00:29:34
ser iterable también, entonces 00:29:36
colección implementa de esta iterable que 00:29:38
incorpora un método iterador simplemente 00:29:40
para iterar por ella y ya está 00:29:41
y hay más clases por ahí que implementan iterable, no solo esta 00:29:43
vale, pues bueno 00:29:46
pues colección es la 00:29:47
gran super clase 00:29:49
solo tiene por encima esta 00:29:51
Que esta incorpora simplemente 00:29:53
La funcionalidad de ser iterado 00:29:56
Por dentro, ser recorrido 00:29:58
Collection 00:30:00
Y luego Collection tiene 00:30:01
Lo que pasa es que 00:30:04
Este dibujo es horrible 00:30:06
Porque no aparecen ni las estas 00:30:08
Ni nada 00:30:10
A ver si hay uno más bonito aquí 00:30:10
Bueno, este es un poco más 00:30:14
Claro 00:30:21
Este es un poquito más 00:30:21
Bueno, lo que pasa es que 00:30:30
Aquí no vienen las de abajo 00:30:31
venga, vamos a ver este 00:30:33
ah, no, este es el criterio 00:30:37
nada, esto, además esto es 00:30:48
esto es muy malo 00:30:50
set, vale 00:31:00
vale, bueno 00:31:05
esta es un poco más clara 00:31:24
vale, esta es 00:31:26
collection y collection 00:31:28
tiene list 00:31:30
y set, que a su vez son interfaces 00:31:32
vale 00:31:34
y list tiene 00:31:35
tres implementaciones 00:31:38
lo que pasa es que esta es muy 00:31:40
anticuada 00:31:42
¿qué implementaciones tiene list? 00:31:43
ArrayList, la que hicimos ayer 00:31:46
la que habéis hecho un montón de veces 00:31:48
ArrayList guarda 00:31:50
sus datos en un array 00:31:52
y añadir es romper el array 00:31:53
hacer uno más grande y copiar y pegar 00:31:56
eso es app, borrar 00:31:58
pues lo mismo, pues eso es ArrayList 00:32:00
¿y luego qué tiene? 00:32:02
y LinkedList, también 00:32:04
implementa, y LinkedList es la lista 00:32:06
enlazada que hicimos ayer 00:32:08
esa es, linked list 00:32:09
luego tiene vector porque esta es una del año 00:32:11
catapunt que 00:32:13
estas cosas no se 00:32:15
eliminan por compatibilidad 00:32:17
de código, esta la verdad es que 00:32:20
es sincronizada, entonces para hilos se sigue 00:32:21
usando algunas veces, pero bueno 00:32:23
la de vector podéis olvidarla un poco 00:32:25
porque es una versión muy antigua 00:32:27
de las listas 00:32:29
enlazadas 00:32:32
¿vale? 00:32:33
y set que tiene, set tiene tres 00:32:35
implementaciones fundamentales, tiene 00:32:37
haset 00:32:39
esta que es un caso particular 00:32:40
de haset y esta que es 00:32:43
triset, que es el arbolito 00:32:45
que dibujamos ayer 00:32:47
a través de unas interfaces que le añaden 00:32:48
cositas, pero son estas tres, esta 00:32:51
esta y esta, son las tres 00:32:53
que hay de conjuntos y de listas 00:32:55
son estas tres 00:32:57
pero que sobre todo las que nos interesan son 00:32:58
ArrayList y LinkedList, esto podéis olvidarlo 00:33:01
y esto de Q 00:33:03
es porque el concepto de colas y pilas 00:33:05
en informática se usa muchísimo 00:33:07
son formas de funcionar 00:33:09
pues una cola 00:33:12
es modela, modela cualquier sistema 00:33:14
en sistemas operativos 00:33:16
en procesos, en todo 00:33:18
entonces colas hay de muchos tipos 00:33:19
pues la lifo, el último que entra 00:33:22
es el primero que se va 00:33:24
esto es 00:33:25
ay no tengo el rotulador 00:33:27
pero 00:33:31
el concepto de pila 00:33:33
lo conocéis, es una forma 00:33:35
de almacenar en la cual tú vas guardando datos, pero como van apilados 00:33:37
unos encima de otros, cuando tienes que sacarlos 00:33:41
el que sacas siempre es el último que metiste, eso es la pila 00:33:45
una forma de almacenar datos apilados, donde tú lo único que puedes hacer es 00:33:49
meter y sacar, y cuando sacas 00:33:53
estás sacando siempre obligatoriamente el último que metiste 00:33:57
eso es una pila, un caso particular de almacenamiento 00:34:02
un caso particular de almacenamiento 00:34:06
que te dan las opciones de 00:34:07
meter, apilar o sacar 00:34:09
¿vale? 00:34:12
y cuando sacas, lo que sacas siempre 00:34:14
es el último que metiste 00:34:16
porque si están apilados es normal 00:34:18
entonces la pila es un 00:34:19
procedimiento de almacenaje muy habitual 00:34:21
en procesos 00:34:26
cuando el sistema operativo va anidando 00:34:28
procesos, pues el último que anido es el 00:34:31
primero que saca, etc. 00:34:33
Esa sería la pila 00:34:35
Luego está la cola de toda la vida 00:34:38
Que es al contrario, si van llegando por aquí 00:34:41
Meter, se mete por aquí 00:34:42
Pero sacar se saca por otro lado 00:34:44
Con lo cual el primero que sale 00:34:46
Es el primero que entró 00:34:48
Es otra forma de funcionar 00:34:49
Entonces son conceptos habituales de informática 00:34:52
Pues para simularlos 00:34:54
Simularlos está esto 00:34:56
Están las colas, esta interfaz 00:34:58
Que te ofrece los métodos 00:35:00
Típicos para estas estructuras 00:35:03
apilar, desapilar, encolar, desencolar 00:35:04
pero esto está hecho por dentro 00:35:07
igual que una lista enlazada, está hecho igual 00:35:08
¿vale? por eso esto implementa hasta de aquí 00:35:10
entonces aquí hay un conjunto de clases 00:35:12
que son las que nos interesan 00:35:16
los conjuntos 00:35:18
haset, linked haset y triset 00:35:20
que son las tres 00:35:22
implementaciones de conjunto 00:35:24
las listas, array list y linked list 00:35:26
vector 00:35:29
es igual pero más antigua 00:35:30
Y LinkedList además ofrece métodos para simular el funcionamiento de las pilas, de las colas, etc. 00:35:32
Este es más o menos el vistazo de cómo está organizada la jerarquía de colecciones de Java. 00:35:41
Este es un poco el vistazo de cómo se ha organizado. 00:35:45
Se ha organizado así. 00:35:48
Bueno, pues ahora después del cambio, vemos un poquito el uso de las listas, que no es tan trivial. 00:35:50
Vale, pues venga, vamos a parar aquí entonces 00:35:59
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
7
Fecha:
27 de febrero de 2024 - 18:30
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
36′ 04″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
148.91 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid