Estructuras dinámicas 1 | Mediateca de EducaMadrid

Voy a grabar esta clase, si habláis me dais el permiso de grabar vuestras voces 00:00:00

Entonces, hoy vamos a empezar a ver, bueno, repasar porque empezamos a verla otra vez 00:00:04

Las estructuras dinámicas, ¿vale? 00:00:10

La diferencia con lo que hemos visto antes es que nosotros para almacenar datos 00:00:13

Hemos siempre utilizado los arrays que son estáticos en el sentido que tienes que darle un tamaño inicial 00:00:18

Y ese tamaño es el que tiene el array, luego puedes rellenarlo un poco o rellenarlo entero 00:00:23

eso no pasa nada, pero el tamaño del array 00:00:29

es siempre el mismo 00:00:31

y que a la hora de 00:00:32

rellenar un array y tengo que añadir un dato nuevo 00:00:34

lo que tenía que hacer es crearme un nuevo 00:00:37

array con más espacio 00:00:39

y luego borrar 00:00:41

o sea, destruir el anterior 00:00:43

después de haber copiado todos los valores 00:00:44

que quería copiar 00:00:47

pero en sustancia 00:00:48

un array no se modifica 00:00:49

no varía de su tamaño 00:00:52

lo que puedo hacer yo es construirme un array más grande 00:00:54

y copiar lo que tenía antes 00:00:57

Las estructuras dinámicas en vez quieren ser una colección de datos que puede cambiar su tamaño en tiempo de ejecución, o sea que cuando yo la estoy compilando no sé cuántos datos contendrán estas colecciones, luego en tiempo de ejecución lo iré llenando, llenando, llenando y estas colecciones, estas estructuras dinámicas podrán hacerse más grandes a medida que yo añado nuevos datos. 00:00:59

Eso no implica que yo no pueda utilizar Array por debajo y hacer lo que hemos hecho siempre de extender Array 00:01:28

Si yo la implementación, como implemento esta estructura dinámica es a través de un Array 00:01:34

Pues tendré que hacer lo que hemos hecho hasta ahora 00:01:40

Pero hemos visto por ejemplo en el caso de la lista enlazada 00:01:41

Que hay otras alternativas que puedo utilizar para implementar estas estructuras dinámicas 00:01:45

Vale, entonces, estructuras dinámicas básicas que veremos son las listas, las colas, las pilas y los árboles 00:01:52

Las listas ya las hemos visto, es sustancialmente una estructura dinámica que permite almacenar objetos 00:01:59

Y sustancialmente yo voy añadiendo a esta lista los objetos que se ponen unos detrás de otros 00:02:07

En un cierto sentido, el orden con el que introduzco los objetos tiene un valor, tiene un sentido, porque independientemente de si los añado delante o detrás, cuando voy añadiendo los objetos, estos se van ordenando según el orden de inserción. 00:02:15

inserción. Veremos que hay otras colecciones, otras estructuras dinámicas en el que el orden no se mantiene, en el sentido que yo añado objetos pero no se me almacenan con el orden de inserción, sino se me almacenan de otra forma. 00:02:35

La lista se puede insertar objetos 00:02:54

En realidad la lista me permite también insertar objetos al fondo, al principio o a mitad de la lista 00:03:00

Así como me permite recorrer la lista 00:03:06

Que normalmente se hace desde un inicio y saltando a los otros elementos de la lista 00:03:11

Me permite quitar un elemento, etc. 00:03:19

En principio en la lista yo puedo hacer 00:03:22

Un acceso aleatorio 00:03:25

A los elementos 00:03:27

Que están ahí dentro 00:03:29

Me puede costar más o menos dependiendo de la implementación 00:03:31

Pero yo puedo decir 00:03:34

Acceda al tercer objeto 00:03:35

¿Vale? Sin embargo hay otras 00:03:36

Lo veremos ahora, otras estructuras dinámicas 00:03:39

En que yo no puedo acceder al tercer objeto 00:03:41

¿Si? 00:03:44

Esto es un poco lo que decías tú también 00:03:46

La lista si permite 00:03:48

Decir, oye, remuéveme este objeto de aquí 00:03:50

Como lista, la cola no debería 00:03:52

Pero como la cola muchas veces deriva de la lista 00:03:55

Implementa también list 00:03:58

Pues entonces es como 00:03:59

La función la hay 00:04:00

Pero luego no la usas 00:04:03

Si la quieres utilizar como 00:04:05

La cola es parecida a una lista 00:04:06

Pero tiene un comportamiento más definido 00:04:12

Es decir que vamos a utilizar 00:04:16

El concepto de FIFO 00:04:18

O sea, first in, first out 00:04:20

Es decir que cuando yo añado un objeto pues eso se va poniéndose en la cola 00:04:22

Al principio pongamos y cuando yo voy a sacar un objeto no puedo sacar uno cualquiera 00:04:29

Tengo que sacar el primero de la cola 00:04:37

Entonces en esta estructura de datos cuando yo utilizo una cola 00:04:39

Es porque quiero que el orden de inserción en un cierto sentido 00:04:43

Sea importante a la hora de recuperar estos datos 00:04:48

No puedo recuperar el dato que me da la gana 00:04:52

Si yo he puesto tres objetos 00:04:54

Los tengo que recuperar en orden 00:04:56

Según como los he insertado 00:04:58

¿Sí? 00:05:00

Entonces el primero que he metido 00:05:01

Será el primero que puedo utilizar 00:05:03

Si quiero utilizar el tercer objeto 00:05:05

Tendré que sacar antes los primeros dos 00:05:07

Y llegar al tercero 00:05:10

¿Sí? 00:05:11

Una pila en vez utiliza 00:05:16

LIFO, o sea Last In First Out 00:05:19

Es siempre parecido 00:05:22

A una lista 00:05:24

Pero su comportamiento es que 00:05:24

El último elemento que he insertado 00:05:27

Es el primero que puedo sacar 00:05:29

¿Vale? 00:05:32

Si yo inserto tres elementos 00:05:33

El primero 00:05:35

Que puedo sacar es el tercero 00:05:38

¿Vale? 00:05:40

Si quiero volver a pillar el primer elemento que he insertado 00:05:41

Pues tendré antes que 00:05:44

Quitar el tercero, quitar el segundo 00:05:46

Y ese punto tendrá a disposición el primero 00:05:48

Se van acumulando uno encima del otro 00:05:50

Pensadlo como una pila de cajas 00:05:53

Y voy poniendo una caja encima de otra 00:05:57

Entonces la última caja que meto encima 00:05:59

Es la primera que puedo pillar 00:06:02

No puedo pillar la caja que está a la base de la columna de cajas 00:06:03

El árbol en vez es una estructura que no es lineal 00:06:07

Las listas hasta ahora en un cierto sentido 00:06:15

Son una línea uno detrás de otro 00:06:18

Sin embargo, el árbol obtiene una forma como la de la figura 00:06:19

El nodo principal, el de arriba, se llama nodo raíz 00:06:27

Este es un árbol al revés 00:06:31

La raíz está arriba y las hojas están abajo 00:06:33

El nodo primero, el primer nodo de acceso que no tiene padre 00:06:36

Pues ese es el nodo raíz 00:06:43

A partir de allí, cuelgan uno o varios hijos 00:06:45

Y puede haber alguna lógica de cómo organizo estos hijos 00:06:49

Si lo pongo por un lado o por el otro o cosa por el estilo 00:06:56

Veremos por ejemplo que hay algunas estructuras como los árboles binarios de búsqueda 00:07:00

En el que estos nodos son organizados de tal forma 00:07:08

Que si el nodo que quiero insertar es mayor del nodo padre 00:07:13

Pues lo pondré a su derecha 00:07:19

Y si es menor lo pondré a su izquierda 00:07:20

Y esto me permite luego de hacer búsquedas mucho más eficientes 00:07:23

Hablaremos de ellos más adelante 00:07:26

Los nodos que no tienen hijos se llaman hojas 00:07:27

¿Vale? 00:07:33

Y son los últimos aquí abajo 00:07:34

Y luego, bueno, un nodo interior es un nodo que no es hoja 00:07:36

El nivel del árbol es cuantas generaciones tiene un árbol 00:07:41

O sea, en este caso, esto tendría 1, 2, 3, 4 generaciones 00:07:46

El nivel sería 4 00:07:53

El grado de un nodo es cuantos hijos tiene 00:07:55

Por ejemplo, esto tiene grado 3 00:07:58

Esto tiene grado 1 00:08:02

Y el grado de un árbol es el máximo grado de los nodos 00:08:04

O sea, si yo miro este árbol de aquí 00:08:12

El grado de este árbol es 3 00:08:15

Porque ya hay este nodo con 3 hijos 00:08:17

Que es el máximo 00:08:19

¿Sí? 00:08:21

Un árbol de búsqueda, por ejemplo 00:08:24

Es de grado 2 00:08:27

Siempre los hijos máximos son 2 00:08:28

O mayor o menor 00:08:32

Entonces 00:08:33

Estos son conceptos muy genéricos 00:08:38

Nosotros ya con las herramientas que tenemos 00:08:42

Lo que hemos hecho hasta ahora 00:08:44

Podríamos implementar estas cosas 00:08:46

Hacer nuestra propia implementación 00:08:47

De colas, pilas, listas, etc 00:08:49

De hecho 00:08:52

Hemos hecho una implementación de lista 00:08:53

Tanto con array como con 00:08:56

Nodos enlazados entre ellos 00:08:58

Y os dije 00:09:02

Lo que podéis intentar es modificar una de estas 00:09:04

Para que hagáis una cola 00:09:07

En vez de poder elegir lo que me da la gana 00:09:08

Es elegir siempre el primero de la lista 00:09:11

Y insertar siempre al fondo de la lista 00:09:14

Entonces modificar los métodos 00:09:16

Para que cuando añado algo 00:09:18

Se añada al final 00:09:19

Y que cuando pillo algo 00:09:20

Pues pille siempre el primero 00:09:23

Lo podéis ya hacer 00:09:24

Vamos a ver un poco en Java 00:09:26

Estas cosas de las que hemos hablado 00:09:29

Cómo se llaman 00:09:31

Qué implementaciones hay 00:09:33

Que diferenciar entre ellas 00:09:34

Vamos a ver algunas de ellas 00:09:36

Primero empezar 00:09:38

Por el hecho que está 00:09:40

Una interfaz que se llama Collection 00:09:42

Que es sustancialmente 00:09:44

La abstracción más alta 00:09:46

De este tipo de 00:09:48

Estructuras dinámicas 00:09:50

Es una colección de datos 00:09:52

Representa lo que se puede 00:09:54

Hacer en una colección de datos 00:09:56

La interfaz Collection 00:09:58

Acordaros que la interfaz me define 00:10:00

Un comportamiento, me define una serie de métodos 00:10:02

Que luego yo tendré que implementar 00:10:04

Cuando estoy hablando de una colección en general 00:10:06

Pues habrá un conjunto de métodos 00:10:09

Que ahora veremos 00:10:11

Que son los métodos básicos 00:10:11

Que valen para cualquier colección 00:10:13

Como por ejemplo añadir un objeto 00:10:15

Quitar un objeto 00:10:17

Preguntarme el tamaño de un objeto 00:10:19

Más o menos 00:10:21

Es lo que nosotros hemos hecho 00:10:22

En nuestra interfaz 00:10:26

Lista 00:10:28

Mi lista 00:10:29

Cuando nosotros hemos creado mi lista 00:10:30

Hemos dado unas informaciones básicas 00:10:32

Que eran la de colección en Java 00:10:34

¿Vale? 00:10:37

Ahora lo que digo 00:10:38

¿Colección sería como objeto en herencia? 00:10:39

¿Como objeto en herencia? 00:10:44

No, esto es un interfaz 00:10:47

No es un objeto 00:10:48

Claro, claro 00:10:50

La función es la misma, ¿no? 00:10:50

Es de donde parte todo, ¿no? 00:10:53

No es de donde parte todo 00:10:56

Porque es un interfaz 00:10:58

No es una herencia 00:10:59

No me está generando un árbol de herencia 00:11:00

Pero cuando yo estoy dentro de las estructuras dinámicas 00:11:03

Digamos que las funciones básicas de una estructura dinámica 00:11:07

Están definidas en collection 00:11:11

Eso es lo mínimo que puedes hacer para hacer una collection 00:11:12

A partir de allí, si tú quieres hacer algo más específico 00:11:15

Una cola, una stack, un árbol, una cosa por el estilo 00:11:20

Pues entonces tendrás otras interfaces que implementar 00:11:25

Otras clases que extender 00:11:28

Y ahora lo veremos un poquito 00:11:30

La colección representa un grupo de objetos denominados elementos 00:11:32

Aquí cuando se habla de elementos se habla de algo que se pone ahí dentro 00:11:36

Entonces yo tengo mi estructura dinámica y la relleno con elementos 00:11:40

Podemos encontrar distintos tipos de colecciones 00:11:45

Según si sus elementos están ordenados como las listas o no ordenados como los conjuntos 00:11:49

Lo que se llaman los sets 00:11:55

Si permitimos que los elementos se repiten 00:11:56

Si permitimos que sea null o no, etc, etc, etc 00:11:59

En base a esto hay varias implementaciones distintas 00:12:03

Y repito, yo tengo que ver qué quiero poder hacer en mi sistema 00:12:06

Y en base a eso elegir la implementación correcta 00:12:10

El tipo de estructura dinámica correcto para hacer lo que quiero decir 00:12:13

¿Vale? 00:12:18

Este es el tipo más genérico en cuanto se refiere a cualquier tipo que contenga un grupo de elementos 00:12:19

¿Vale? 00:12:24

Es una colección de elementos 00:12:24

Es muy genérico, no sabemos cómo funciona 00:12:25

Es muy muy alto nivel 00:12:28

Luego en base a cuál es el subfuncionamiento 00:12:30

¿Funciona el IFO? 00:12:32

Pues entonces buscaré stack por algún lado 00:12:34

¿Funciona como FIFO? 00:12:36

Pues entonces buscaré una cola 00:12:39

Etcétera, etcétera 00:12:41

Pero todas estas cosas al fin y al cabo 00:12:42

Implementarán 00:12:45

Collection 00:12:46

¿Sí? 00:12:48

En esta defensa tenemos 00:12:51

Métodos, vale, que son 00:12:52

Si no me equivoco, estos 00:12:54

Esta es la interfaz collection 00:12:56

Las operaciones que me da 00:12:59

Para que tu implementes 00:13:00

Collection tienes que poder 00:13:03

Añadir un elemento 00:13:05

Que será que almacena 00:13:06

Este elemento dentro de la colección 00:13:09

Preguntarme cuantos elementos 00:13:10

Has almacenado hasta ahora 00:13:13

Iterator 00:13:14

Que ahora veremos que es 00:13:16

Contains 00:13:18

Que es un programa 00:13:20

Es un método que me dice 00:13:21

Oye te doy un elemento 00:13:23

Dime si este elemento 00:13:24

Está dentro de esta colección 00:13:26

Y remove de un elemento 00:13:28

Que me dice, oye mira, pilla este elemento 00:13:30

Y quítalo, esté donde esté 00:13:32

¿Vale? 00:13:34

Y repito que todas las colecciones 00:13:35

Derivan de esto, entonces todas las colecciones 00:13:38

Sea queue, sea 00:13:41

Stack, sea lo que sea 00:13:42

Pues tendrán que tener 00:13:44

Al menos estas cinco 00:13:46

Funciones 00:13:48

¿Y terretor qué es? 00:13:50

Pues terretor es una forma 00:13:52

De 00:13:54

Poder acceder a una colección 00:13:56

Y decirme, oye, mira, yo quiero hacer algo 00:13:58

Sobre todos los 00:14:01

Objetos de esta colección 00:14:03

¿Vale? No sé cuántos son 00:14:04

¿Vale? 00:14:07

Pero yo quiero 00:14:08

Pillar cada uno de estos elementos 00:14:09

Y hacer algo sobre ello 00:14:11

Por ejemplo, que se yo 00:14:13

Compararlo con otro elemento 00:14:15

Llamar un método sobre 00:14:17

Este objeto, si es un objeto 00:14:20

De este elemento, etc, etc 00:14:21

¿Vale? Para poder hacer eso 00:14:23

Necesito un método, necesito algo 00:14:25

Que me permita 00:14:28

Iterar sobre los elementos 00:14:29

Es decir, la colección 00:14:33

Yo no sé cómo está hecho, no sé cómo está 00:14:34

Implementada, es un array 00:14:36

Pues no lo sé, porque si por debajo está 00:14:37

Implementado con un array, bien, si no está implementado con un array 00:14:40

No, pero dame tú 00:14:42

Una forma 00:14:44

De poder 00:14:45

Navegar en todos 00:14:47

Los elementos de esta colección 00:14:50

¿Vale? En base 00:14:52

a la implementación que estás haciendo 00:14:54

y al tipo de 00:14:56

colección que es 00:14:57

pues tú me dirás una forma u otra 00:14:59

si lo que tengo por debajo 00:15:01

es un array, nosotros sabemos 00:15:04

una forma de recorrer 00:15:06

un array entero 00:15:08

forra y cosas por el estilo 00:15:09

pues el iterator hará algo parecido 00:15:12

¿si? 00:15:14

en particular 00:15:16

iterator 00:15:18

viene de iterable 00:15:18

o sea, iterable es otra 00:15:22

Interfaz 00:15:24

¿Vale? 00:15:27

Donde dentro tiene sustancialmente un método 00:15:28

Para decir, oye, mira, en un determinado momento 00:15:30

Dame un objeto iterador 00:15:32

El objeto iterador 00:15:34

Lo que permite hacer es 00:15:36

Navegar en todos 00:15:38

Recorrer toda la colección 00:15:41

De alguna forma 00:15:43

¿Vale? 00:15:44

Lo más eficiente posible 00:15:45

Dependiendo de la colección en la que estoy 00:15:47

Está claro que una lista 00:15:49

La recorrerás desde principio a final 00:15:50

Un árbol como lo recorre 00:15:53

Así 00:15:55

Hay dos formas de recorrer un árbol 00:16:01

En anchura 00:16:04

O en profundidad 00:16:06

En profundidad voy lo más profundo 00:16:07

Y cuando no puedo ir más profundo 00:16:10

Vuelvo atrás y más profundo 00:16:12

Vuelvo atrás y más profundo 00:16:13

Vuelvo atrás y más profundo 00:16:15

Vuelvo atrás y más profundo 00:16:17

En anchura es 00:16:18

Nivel 1 está esto 00:16:21

Nivel 2 está esto y luego esto 00:16:23

Nivel 3 está esto, esto, esto 00:16:25

Esto, esto y así, así 00:16:27

¿Vale? Entonces dependiendo de como 00:16:29

Quiero hacerlo, pues tendré que 00:16:31

Implementarlo y tendré que hacer algo 00:16:33

En función, ¿sí? 00:16:35

Por nuestra suerte estas cosas ya están implementadas 00:16:36

Porque todas las cosas que tenemos de Java 00:16:39

Las implementaciones que tenemos de Java 00:16:41

Que son al fin y al cabo estas 00:16:43

Las verdes, ¿vale? 00:16:44

Pues tendrán ya dentro 00:16:47

Definido la posibilidad 00:16:49

De pillar un objeto iterator 00:16:51

Y el objeto iterator 00:16:53

Veremos que se utiliza para decir 00:16:55

Oye mira, dame el siguiente elemento 00:16:57

Aquí lo tienes, dame el siguiente elemento 00:16:58

Aquí lo tienes 00:17:00

Y yo puedo hacer lo que quiera con este elemento 00:17:01

¿Vale? 00:17:03

En este esquema de aquí 00:17:07

Que más o menos define 00:17:08

Un 70% de lo que es esta 00:17:10

Esta parte, ¿vale? 00:17:15

De las estructuras dinámicas 00:17:16

Porque luego hay la parte de maps 00:17:17

Que aquí no viene 00:17:19

Lo veremos más adelante 00:17:20

Los que son azules son interfaces 00:17:22

Los que son verdes son implementaciones reales 00:17:26

Entonces nunca crearéis un new collection 00:17:30

Porque collection es una interfaz 00:17:33

No se puede hacer 00:17:35

Si podréis crear collection x es igual a no se que 00:17:36

Eso si lo podéis hacer 00:17:41

Se puede hacer una referencia cuyo tipo sea una interfaz 00:17:42

Lo hemos hecho 00:17:46

Lo que no se puede hacer 00:17:47

Es 00:17:50

Implementar 00:17:51

Crear una instancia 00:17:53

De una interfaz 00:17:55

Las verdes en vez de si me permiten crear 00:17:57

Las verdes son implementaciones 00:18:00

Concretas, no tienen nada abstracto 00:18:01

No tienen métodos abstractos 00:18:04

Yo puedo crear una ArrayList 00:18:06

Puedo crear un LinkedList 00:18:07

Un Vector, Stack 00:18:09

ArrayDeck, PriorityQueue 00:18:10

HashSet 00:18:14

Linker-set 00:18:15

Y triset 00:18:16

Cada una de ellas 00:18:17

Tiene sus características propias 00:18:19

¿Dudas hasta aquí? 00:18:22

Los métodos 00:18:27

Harán siempre los mismos 00:18:28

Todas estas verdes tienen add 00:18:29

¿Vale? 00:18:32

Pero cada uno lo implementa de una forma distinta 00:18:34

Como nosotros hemos visto que el add 00:18:36

En nuestra lista de array 00:18:38

Lo que hacía era añadir una celda 00:18:40

Al array y añadir el objeto 00:18:42

Mientras si yo lo hacía como lista enlazada 00:18:44

Era crearme un nuevo objeto 00:18:47

Y enlazarlo al último de la cosa 00:18:48

¿Sí? De la lista 00:18:50

Entonces, cada uno de estos 00:18:51

Tendrá sus características 00:18:54

Y se comportará como se tiene que comportar 00:18:56

Por ejemplo 00:18:59

Si yo estoy aquí 00:18:59

Esta rama de aquí, Q, es cola en inglés 00:19:01

¿Vale? Entonces, estas son 00:19:05

Como funcionan colas 00:19:07

¿Sí? Entonces, cuando estoy aquí 00:19:08

Y tengo una Priority Q 00:19:10

Me espero que funcione como una cola 00:19:11

En el sentido que cuando inserto las cosas 00:19:14

Pues el primero insertado 00:19:17

Sea el primero 00:19:19

Que pueda pillar 00:19:21

Si me pongo 00:19:21

Por ejemplo insert que son conjuntos 00:19:25

Pues aquí tendrán las características 00:19:27

De los conjuntos 00:19:29

Todavía no los hemos empezado a ver 00:19:29

Por lo tanto estamos allí 00:19:32

Lo único que conocemos son estas dos 00:19:34

Porque estas dos nosotros hemos hecho nuestra propia implementación 00:19:36

Por lo tanto más o menos 00:19:39

Los conocemos 00:19:40

Java me da mucho más 00:19:41

Métodos, mucho más métodos 00:19:43

Con respecto a lo que hemos visto 00:19:46

Repito que esta es la interfaz collection 00:19:47

Todos los que están aquí dentro 00:19:49

Tienen estos cinco métodos 00:19:52

Lo que me garantiza 00:19:54

Que sea cual sea la implementación 00:19:57

Yo puedo añadir un objeto 00:19:59

Puedo preguntar, oye mira 00:20:00

Cuántos objetos se han insertado 00:20:02

Puedo decir, puedo encontrar 00:20:04

Un método para que tú me digas 00:20:06

Cómo recorrer esta estructura 00:20:08

Sea lo que sea esta estructura dinámica 00:20:10

Puedo preguntar si hay algo en esta estructura 00:20:12

Y puedo quitar algo de esta estructura 00:20:15

Sí 00:20:17

En una clase yo estoy obligado 00:20:18

A tener 00:20:22

A tener la interfaz colección 00:20:23

¿Puedo yo por ejemplo 00:20:25

Si en una clase particular 00:20:27

No me interesa por ejemplo el size 00:20:29

Lo puedo 00:20:31

Vamos a ver, en el momento que tú 00:20:33

Implementas collection 00:20:35

Size tiene que estar 00:20:37

Si no, no es una colección 00:20:39

Tú te quieres hacer tu propia interfaz 00:20:41

Que sea collection menos size 00:20:45

Te lo haces sin esto 00:20:47

Y luego te implementas con la collection menos size 00:20:49

Pero claro, no es lo mismo 00:20:51

Que estas 00:20:53

Ahora, otra cosa 00:20:54

Es que esto es un contrato 00:20:58

Vale, tú me aseguras 00:21:00

Que en el momento en que tú dices 00:21:03

Oye, implemento collection 00:21:05

Tú hayas sobrescrito size 00:21:07

Y implementado 00:21:09

Que luego tú size dices return 0 00:21:11

Entonces independientemente de cuantas cosas 00:21:13

Te haya puesto me devuelve siempre 0 00:21:17

Vale 00:21:19

Pero estás incumpliendo en un cierto sentido 00:21:20

El contrato 00:21:24

Otro programador del mundo 00:21:24

Cuando ve tu 00:21:26

Código, tu clase 00:21:28

Y ve que tu clase 00:21:31

Extended Collection 00:21:32

Se espera que si llama size 00:21:35

Recibirá el tamaño 00:21:38

De tu colección 00:21:40

Y tú lo has implementado mal 00:21:40

Entonces no lo deberías hacer 00:21:42

Bueno, lo puedes hacer 00:21:45

Puedes hacer lo que te haga 00:21:46

Puedes hacer que la add cuando una add 00:21:47

En vez de añadir, remueva 00:21:50

Pero es un error semántico 00:21:51

A nivel de programación 00:21:54

Estás complicando las cosas 00:21:55

¿Quieres hacer eso? 00:21:57

Pues en vez de utilizar collection 00:22:00

Create tu propia interfaz 00:22:02

Y haz lo que quieras 00:22:03

Solo que luego 00:22:05

Todas estas implementaciones 00:22:06

En cierto sentido son intercambiables 00:22:09

Allá donde alguien use collection 00:22:10

Puedes usar una cualquiera de estas 00:22:13

La tuya nueva no 00:22:15

Porque no implementa collection 00:22:16

Implementaría mi collection 00:22:18

Pero puedo saltar 00:22:19

En principio no deberías 00:22:20

Saltar 00:22:25

Claro, es obligatorio 00:22:26

Pero si me voy a la cabeza y decido saltar 00:22:28

Java no te va a decir 00:22:31

Oye mira lo has implementado mal 00:22:33

Porque Java no puede saber 00:22:35

Si lo has implementado mal o no 00:22:37

Te puede decir, oye mira 00:22:38

Te falta esto 00:22:40

Porque tú has dicho que implementas 00:22:42

Collection 00:22:44

Entonces esto tiene que estar 00:22:46

Y no lo has puesto, esto te lo puede decir 00:22:49

Pero una vez que tú lo has puesto 00:22:51

Que tú dices, devuelve siempre mi 00:22:52

Java dice 00:22:54

Será que tu colección siempre 00:22:56

Tiene solo mil objetos, no lo sé 00:22:58

Java en eso no se mete 00:23:00

Es la diferencia entre errores 00:23:03

Sintácticos 00:23:05

que Java te los puede pillar 00:23:06

a tiempo de compilación 00:23:08

que es, oye mira, falta esto 00:23:09

y yo puedo comprobarlo porque no lo has escrito 00:23:11

entonces falta y me has dicho que 00:23:14

implementabas collection y tiene que estar 00:23:16

y error semántico 00:23:18

en el que te has equivocado 00:23:20

a calcular el factorial 00:23:22

y en vez de factorial me calculas 00:23:23

la raíz cuadrada 00:23:25

pero yo Java, eso no lo puedo saber 00:23:27

y puedo utilizar el plan de clave 00:23:29

ese método y decir 00:23:31

el plan de clave es 6-2 00:23:32

Pero no está en la colección 00:23:35

Si tú haces 00:23:38

Collection x es igual a 00:23:40

New tu implementación 00:23:42

En ese collection no está size2 00:23:44

Está size 00:23:46

Para poder utilizar 00:23:48

Size2 tengo que hacer un 00:23:50

Downcasting a tu implementación 00:23:52

Y entonces ahí aparecerá 00:23:55

También size2 00:23:56

La potencia de las interfaces 00:23:57

Es que 00:24:01

Si yo por algún lado declaro 00:24:02

Oye, aquí collectionX es igual a 00:24:04

Dame uno cualquiera de estos verdes 00:24:07

Y funciona 00:24:10

Y puedo añadir, quitar 00:24:11

Contains, iterator 00:24:13

Y no sé qué 00:24:16

Pero los métodos propios de PriorityQ 00:24:17

Por ejemplo, no los tendré 00:24:20

Porque los estoy utilizando como collection 00:24:21

Repito que nadie me prohíbe 00:24:23

Si yo sé que quiero utilizar 00:24:26

Y quiero utilizar una PriorityQ 00:24:27

Pues puedo hacer PriorityQX es igual a 00:24:29

NewPriorityQ 00:24:32

Y uso los métodos de Priority Queue 00:24:32

Que incluyen los de Collection 00:24:36

Los de Queue, los de Terrible 00:24:37

¿Sí? 00:24:39

¿Dudas? 00:24:44

¿Ya no? 00:24:46

Entonces 00:24:49

Las interfaces que extienden Collection 00:24:50

Estamos aquí 00:24:55

¿Vale? 00:24:56

A partir de Collection 00:24:58

Hay tres interfaces que extienden Collection 00:24:59

O sea que además de lo que tiene Collection 00:25:03

Añado cosillas más 00:25:06

¿Qué son? 00:25:08

Set, que en inglés quiere decir conjunto 00:25:10

¿Vale? 00:25:13

Sería un saco donde dentro 00:25:14

Pongo los elementos 00:25:17

Cuidado, mientras que en una lista 00:25:18

Normalmente tienen un orden 00:25:20

Porque van uno tras de otro 00:25:22

En el conjunto no 00:25:24

El conjunto es 00:25:26

Estos son los elementos que tengo en cuenta 00:25:27

Mi colección son estos elementos 00:25:30

Pero no tienen un orden 00:25:32

Son estos, ¿vale? 00:25:34

Y la cosa particular de los conjuntos es que no se admiten elementos repetidos. 00:25:36

No puedo poner dos veces el mismo elemento en un set. 00:25:43

¿Vale? 00:25:49

Es como si vosotros pilláis el conjunto de los números naturales. 00:25:49

El conjunto de los números naturales son 1, 2, 3, 4. 00:25:54

No son 1, 2, 2, 2, 2, 2, 3 y 4. 00:25:57

2 es 1. 00:26:01

2 es un elemento. 00:26:02

Si tú intentas insertar otra vez 2, te dicen, no, mira, 2 ya está, y ya lo tenemos en el conjunto. 00:26:03

Sin embargo, en una lista, que es la lista de las edades de los alumnos, yo podría poner 1, 2, 2, 2, 3. 00:26:10

Eso quiere decir que hay 3 alumnos que tienen 2 años. 00:26:17

Se puede repetir el elemento. 00:26:20

¿Se entiende la diferencia? 00:26:23

El conjunto me puede servir para aquellos programas en el que yo lo que quiero es añadir elementos 00:26:24

Ese elemento me representa un elemento único en este tipo de problema, en este espacio del problema 00:26:36

Por ejemplo, si yo tengo el concepto de soy una tienda y lo que hago es crear un catálogo 00:26:46

Y saber cuáles son mis productos 00:26:54

¿Vale? 00:26:56

El producto ordenador con 8 kilobytes 00:26:57

¿Vale? 00:27:01

Lo puedo considerar de dos formas 00:27:01

O un objeto físico real 00:27:03

¿Vale? 00:27:06

Yo tengo tres de estos en el almacén 00:27:07

Y por lo tanto quiero tres objetos distintos 00:27:09

Entonces no me interesa el set 00:27:12

Lo debería hacer como una lista 00:27:15

O como otra cosa 00:27:16

Pero si yo lo pienso como catálogo 00:27:17

Como menú 00:27:21

Es decir, oye, alguien a mí me puede pedir un ordenador de 8 GB y luego yo se lo haré, pero hay un solo ordenador de este tipo, luego habrá otro ordenador de otra marca, luego habrá otro ordenador con 16 GB, ¿vale? Estoy haciendo un catálogo. 00:27:22

Pues entonces, esto podría ser un set 00:27:37

No existen dos ordenadores 00:27:40

Con la misma característica 00:27:44

El producto es uno solo 00:27:45

Si, si quieres verlo así 00:27:47

También cuando haces libro 00:27:58

Tienes el mismo problema 00:28:00

Libro de una biblioteca 00:28:01

Pensar que si tú tienes tres distintos 00:28:03

Copias 00:28:06

Ejemplares del mismo libro 00:28:08

Pues esto tiene que ser tres objetos distintos 00:28:09

Entonces set no te vale 00:28:12

O podrías pensar, mira, en mi biblioteca 00:28:13

Yo tengo este libro aquí, tengo 00:28:16

El señor de los anillos, vale, fenomenal, es un libro 00:28:17

Luego puedo tener seis copias 00:28:20

Pero del señor de los anillos 00:28:22

Hay uno solo, vale 00:28:24

Entonces sí que lo podría modelizar por un set 00:28:25

¿Se entiende? 00:28:28

¿Vale? 00:28:31

¿Qué es lo que interesa? 00:28:31

¿Se interesa por cantidades, no? 00:28:33

¿Me interesa más 00:28:35

La cantidad de... 00:28:36

Esto, no es que me interese 00:28:43

Si tú lo quieres hacer de esta forma 00:28:45

O sea que tu objeto libro 00:28:48

Es un objeto físico 00:28:49

Corresponde a un objeto físico concreto 00:28:52

Que luego tendrá un identificador para diferenciarlo 00:28:54

De las otras copias 00:28:56

Entonces set no lo puede usar 00:28:57

Porque cuando intentas meter dos libros distintos 00:28:58

Pues es el mismo libro 00:29:01

O repito 00:29:03

Si tú haces el objeto con dentro un identificador 00:29:06

Que en los tres libros 00:29:08

Que se llaman enseñar el renguillo 00:29:11

Tienen un identificador distinto 00:29:12

También puedes utilizar un set 00:29:13

Pero conceptualmente no tiene mucho sentido 00:29:15

Sería mejor utilizar 00:29:18

Otros tipos de cosas 00:29:20

Este de aquí es si tú quieres 00:29:21

Tú eres un editorial 00:29:23

Y tienes que hacer un programa 00:29:24

Que dice los libros que tienes como editorial 00:29:28

Tú como editorial puedes imprimir 00:29:30

Las propias que quieres 00:29:32

Pero tú tienes o no tienes 00:29:33

El señor de los anillos 00:29:36

Si tú eres editorial y no tienes los derechos 00:29:37

Para el señor de los anillos 00:29:39

No lo metes en tu sistema 00:29:41

Entonces en este caso 00:29:42

No cuenta cuantos hay 00:29:45

Si hay una línea, uno 00:29:46

O otro libro 00:29:48

Y entonces en este caso 00:29:50

Podrías trabajar con un set 00:29:53

¿Vale? 00:29:55

La clave es que no se pueden repetir los elementos 00:29:56

Oye, ¿y cuando un elemento se repite? 00:29:59

Yo tengo mi conjunto 00:30:03

Ya he metido cosas 00:30:04

Quiero añadir un nuevo elemento 00:30:06

¿Sí? 00:30:08

¿Cuando este elemento te digo 00:30:10

Oye, mira, no, no lo puedes insertar porque ya existe 00:30:12

Con el equals 00:30:14

El equals lo que hace es 00:30:24

Definirme 00:30:29

El concepto de identidad 00:30:30

Dos objetos 00:30:32

Mios son iguales 00:30:34

Cuando yo hago este objeto 00:30:36

Punto equals este otro objeto 00:30:38

Y me devuelve true 00:30:40

Soy yo que defino cuando son iguales 00:30:41

Entonces los set 00:30:44

Añaden 00:30:46

Objetos, elementos a su conjunto 00:30:48

Cuando yo añado 00:30:51

Uno nuevo, pillan este 00:30:53

Nuevo y van a llamar 00:30:55

Equals, sobre todo 00:30:57

Los objetos que ya están allí 00:30:59

Dentro y si uno de ellos 00:31:01

Da true, dice 00:31:03

No, no lo puedes añadir 00:31:05

Te dice que este elemento 00:31:07

Ya existe, no se puede añadir 00:31:11

Al conjunto, porque no tiene 00:31:12

Sentido añadir señores de 00:31:14

De los anillos cuando ya tienes el sueño de los anillos 00:31:16

¿Es una excepción o no? 00:31:19

No, no 00:31:21

No lo sé, no me acuerdo 00:31:22

Que devuelve, ahora lo miramos con el ADD 00:31:24

Pero probablemente no, o devuelve null 00:31:26

O true or false, no me acuerdo 00:31:28

Ahora lo miramos luego más específicamente 00:31:29

Porque dependerá también de la implementación 00:31:33

También en algunos casos 00:31:34

En vez de utilizar solo equals 00:31:37

También puede utilizar hashcode 00:31:41

¿Qué es hashcode? 00:31:43

Es un código hash 00:31:45

¿Vale? ¿Qué es hash? 00:31:46

Pues lo veremos dentro de un rato 00:31:49

¿Vale? Porque es un concepto 00:31:50

Un poquito 00:31:53

Raro, ¿vale? 00:31:53

Y que hay algunas implementaciones 00:31:56

Que son, por inciso 00:31:58

Las implementaciones más rápidas y más eficientes 00:32:00

Que necesitan esta cosa aquí 00:32:03

¿Vale? 00:32:05

Entonces 00:32:08

Un segundo solo 00:32:09

Por ejemplo, aquí, set 00:32:09

En hash set 00:32:12

HashSet utiliza este 00:32:14

HashCode 00:32:17

Para poder comprobar si la has metido o no 00:32:17

También el equals 00:32:21

Pero principalmente el HashSet 00:32:22

¿No sabemos que es? 00:32:24

Pues lo veremos cuando empezaremos a mirar esto 00:32:25

O el HashMap 00:32:27

O cuando hablaremos de hash 00:32:28

Pues entonces hablaremos de que es una tabla hash 00:32:30

¿Vale? 00:32:32

Por ahora 00:32:33

No es una encriptación 00:32:33

Pero se usa en encriptación 00:32:38

Alguna vez más bien como digest 00:32:42

Para comprobar que 00:32:43

Lo que sea, el objeto que tienes 00:32:45

Efectivamente es el objeto que tienes 00:32:48

Que deberías haber tenido 00:32:50

¿Vale? 00:32:52

O sea que algunas cosas 00:32:54

De la seguridad informática 00:32:56

Pues se basan sobre la 00:32:58

Ashing para poder 00:33:00

Sacar algunas propiedades, ¿vale? 00:33:02

Entonces este es el conjunto, ¿vale? 00:33:06

La lista, la lista es la más fácil y más 00:33:08

¿Cómo se dice? 00:33:10

Más intuitiva porque es una lista de objetos 00:33:12

¿Vale? 00:33:15

Entonces, la colección que es el finalista 00:33:16

Los elementos de la colección tienen un orden 00:33:18

¿Vale? 00:33:20

Este orden no siempre es el orden de inserción 00:33:21

¿Vale? Lo veremos 00:33:25

Puede que sea otro tipo de orden 00:33:26

Pero el concepto es que 00:33:28

La lista está pensada para que tenga un orden 00:33:30

Es como cuando hacéis una lista 00:33:33

Que ponéis 1, 2, 3, 4, 5 00:33:34

¿Vale? El primer elemento es este libro 00:33:36

El segundo elemento es este libro 00:33:38

Hay un orden interno 00:33:39

¿Vale? De la lista 00:33:42

Que este orden puede no ser intuitivo 00:33:43

Puede no ser el de inserción 00:33:46

Puede ser, como por ejemplo el Priority Queue 00:33:49

Una prioridad, ¿vale? 00:33:54

Definida por el mismo desarrollador 00:33:57

¿Vale? Mis objetos se ordenan según estos criterios 00:34:01

¿Vale? 00:34:05

Quien viene antes, pues tendrá más prioridad que quien viene después 00:34:05

Y no necesariamente el orden de inserción 00:34:08

Pero, inherentemente, list tiene un orden, un determinado orden dentro 00:34:11

Existen una secuencia de elementos, en ellas cada elemento estará en una determinada posición, índice de la lista 00:34:17

¿Vale? Entonces la lista tiene la posibilidad de tener un índice, como en un array 00:34:23

Pero, como cuando nosotros hemos hecho, en vez que con el array, con la lista enlazada 00:34:28

Pues también hemos podido acceder al elemento 5 y pillarlo 00:34:33

¿Vale? En una lista, la lista está ordenada 00:34:37

Entonces puedo pillar un índice 00:34:40

Y decir, vete al quinto 00:34:43

Cosa que no puedo hacer en el set 00:34:44

En el set no existe 00:34:47

El quinto elemento de un conjunto 00:34:49

No se puede 00:34:51

No es tan ordenado 00:34:53

Porque como se ordenan dentro 00:34:54

Es un problema suyo 00:34:56

No es el mismo orden de inserción 00:34:58

Ni otro 00:35:00

También en las listas 00:35:00

Típicamente se pueden 00:35:04

Duplicar 00:35:05

Los elementos que pongo dentro 00:35:07

¿Vale? Puedo poner dos, tres, cuatro veces 00:35:10

El mismo elemento, ningún problema 00:35:12

¿Sí? 00:35:13

Y luego están las que son 00:35:16

Parecidos a una lista 00:35:19

¿Vale? Pero siguen el patrón 00:35:21

FIFO 00:35:22

First in, first out 00:35:23

¿Vale? Entonces la idea es que yo cuando uso una cola 00:35:25

Me baso sobre el hecho que 00:35:28

El primer elemento se pone aquí 00:35:30

El segundo elemento se pone detrás 00:35:33

El tercer elemento se pone detrás 00:35:34

Y cuando voy a pillar uno de estos elementos 00:35:35

Tengo que empezar desde el primero 00:35:38

Oye, pero yo no quiero 00:35:40

Pues no uses una cola 00:35:42

Ningún problema, usa una lista 00:35:44

Que puedes acceder al tercero tranquilamente 00:35:45

La clave aquí 00:35:48

No es lo que puedo o no puedo hacer 00:35:50

Es lo que quiero y no quiero hacer 00:35:52

Si yo tengo que hacer un programa 00:35:54

Donde el almacenamiento de estas cosas 00:35:56

Se basa 00:36:00

Sobre el hecho que 00:36:01

Si han llegado antes unas peticiones 00:36:02

Quiero empezar desde la primera 00:36:04

Y seguir ordenadamente 00:36:06

Pues entonces lo que quiero dar es una cola 00:36:08

Si esto no me interesa 00:36:10

Pues entonces no uso una cola, uso otra cosa 00:36:11

¿Los nodos lo utilizan? 00:36:13

Los nodos 00:36:19

A ver, los nodos no es nada 00:36:20

Los nodos es una implementación 00:36:23

Es un, elija que quieres hacer 00:36:24

Y lo puedes implementar con nodos 00:36:26

Lo que pasa es que el nodo es uno de estos 00:36:28

Yo puedo hacer un conjunto usando nodos 00:36:30

Puedo hacer una lista usando nodos 00:36:33

Puedo hacer una queue usando nodos 00:36:35

Puedo hacer una stack usando nodos 00:36:37

Bienvenido al mundo de los objetos 00:36:39

Lo que cambia con el nodo no nodo 00:36:48

No es 00:36:51

Lo que estás haciendo 00:36:53

Es la implementación de lo que estás haciendo 00:36:54

O sea, yo puedo utilizar para hacer un set 00:36:57

Un array 00:36:59

O un nodo 00:37:00

O otra forma de hacer 00:37:02

Para una lista 00:37:03

Lo puedo hacer ArrayList 00:37:06

Entonces estoy usando Array 00:37:08

Lo puedo hacer LinkedList 00:37:09

Entonces estoy usando los nodos 00:37:10

Para árboles, pues es utilizar nodos 00:37:11

Cada árbol tiene sus nodos 00:37:14

Entrelazados entre ellos 00:37:16

Pero nadie me prohíbe 00:37:17

De crear un Array 00:37:20

Y interpretarlo como un árbol 00:37:22

Que la posición 0 es la raíz 00:37:24

La posición 1 es el hijo de la raíz 00:37:26

La posición 2 es el hijo derecho 00:37:28

El 3 es el hijo 00:37:30

Me creo una fórmula 00:37:33

Y lo utilizo así 00:37:35

Tip 00:37:37

Ah, no, esto no es class 00:37:38

Todas las verdes son class 00:37:47

Y fíjate que hay list 00:37:49

Y hay una, dos, tres y cuatro 00:37:51

Implementaciones de list 00:37:54

¿Vale? Estas dos 00:37:55

Son las que hemos hecho nosotros 00:37:58

Lista implementada con array 00:37:59

Y lista implementada con nodos entrelazados entre ellos 00:38:01

Y luego aquí está vector 00:38:04

Que es igual a array list 00:38:05

Solo que tiene algunas características distintas 00:38:07

En particular está sincronizado 00:38:09

Que nosotros no tenemos idea de que es 00:38:11

Si queréis saber que es 00:38:13

Pues en segundo de DAM 00:38:14

¿Vale? 00:38:16

Y de vector 00:38:19

Está la stack 00:38:20

Que es la pila 00:38:22

¿Vale? Entonces la pila en Java 00:38:23

Está implementada como una lista 00:38:26

¿Si? Y todo esto son 00:38:27

Implementaciones de esta 00:38:30

Tierra 00:38:32

De esta clase podemos crear objetos 00:38:32

Podemos extender esta clase 00:38:40

Como pasa, no pasa en ningún lado 00:38:42

Sí, aquí 00:38:45

Stack hereda de vector 00:38:50

Esto es 00:38:54

Esto es todo lo que tenemos 00:38:56

Tú te puedes crear 00:38:59

Tu propia lista 00:39:01

Y decir, mi propia lista hereda de 00:39:02

ArrayList 00:39:05

Y pilla todo ArrayList 00:39:06

Y le añade unos métodos que te interesan a ti 00:39:09

Que son importantes para tu proyecto 00:39:11

Más dudas 00:39:13

¿Por qué no puedes? 00:39:15

En el set 00:39:21

¿Por qué no puedes quitar? 00:39:27

Es el acceso 00:39:31

Que no es aleatorio 00:39:33

En el sentido de que no hay un orden 00:39:34

Prefijado 00:39:36

Como orden de inserción o cosa por el estilo 00:39:38

Entonces puedes decir, haced al tercero 00:39:40

Cuando tú insertas dentro 00:39:42

De los 00:39:44

De los sets 00:39:44

Por cómo están hechos dentro 00:39:47

No necesariamente respetan 00:39:49

El orden de inserción 00:39:51

Por ejemplo, triset 00:39:52

¿Vale? Triset es 00:39:54

Voy almacenando objetos 00:39:56

Según un árbol 00:39:58

¿Vale? La forma con que 00:39:59

Tú pones aquí o aquí 00:40:03

O aquí o aquí en los nodos 00:40:05

Depende 00:40:07

De otras cosas 00:40:08

¿Vale? Y entonces llega un momento 00:40:10

En que tú a lo mejor insertas 5 elementos 00:40:12

Y el quinto elemento te viene aquí 00:40:15

No necesariamente 00:40:16

te viene ordenado 00:40:19

entonces lo tengo más abajo 00:40:20

de los demás, o sea que el primero 00:40:22

lo ponga aquí, el segundo lo ponga aquí, el tercero lo ponga aquí 00:40:24

el cuarto lo ponga aquí, el quinto me viene a ponerlo aquí 00:40:26

entonces está más alto de niveles 00:40:28

con respecto al segundo, tercero y cuarto 00:40:30

se te mezclan dentro 00:40:32

por eso luego no puedes decir, accedeme al quinto 00:40:34

porque se ha perdido esta información 00:40:36

que a ti te interesa esa información 00:40:38

no uses un set 00:40:40

pero que a ti no te interesa 00:40:42

lo de antes, los libros 00:40:46

A mí me interesa saber los libros que tengo 00:40:48

¿Vale? 00:40:51

Me interesa saber que he añadido hoy 00:40:52

El Señor de los Anillos 00:40:54

O lo he añadido pasado mañana 00:40:56

O es el quinto que he añadido en mi cosa 00:40:58

Pues a lo mejor no 00:41:01

A mí me interesa saber que mi editorial puede editar 00:41:01

El Señor de los Anillos 00:41:04

Lo he añadido, vale, ahora lo tengo allí 00:41:05

No me interesa saber si lo he puesto antes o después de otro 00:41:07

A lo mejor me interesa otra forma 00:41:10

De organizarlo 00:41:13

En plan, el número de páginas 00:41:14

Entonces cuando busco estarán organizados 00:41:16

Por nombre de página o que se yo 00:41:19

Reset por ejemplo 00:41:21

Si que creo que se basa sobre 00:41:25

Comparable, ahora lo miramos 00:41:26

No me acuerdo 00:41:28

¿Dudas? 00:41:29

Entonces 00:41:35

Esto es, tengo collection 00:41:36

Desde collection heredan 00:41:38

Tres tipos de 00:41:40

Interfaces más que son 00:41:42

Set, list, queue 00:41:44

Cada una de ellas añade a los 5 métodos básicos de collection 00:41:45

Otros métodos adicionales 00:41:52

O modifica un poco el funcionamiento de estos 00:41:57

O sea, en una collection añadir es añadir el objeto que te han dado 00:42:02

Te han dado un elemento, añádelo 00:42:07

En un set añadir es añadir el elemento 00:42:08

Siempre y cuando no esté ya en el set 00:42:15

He pillado esto 00:42:18

Y lo he modificado un poco 00:42:21

Entonces la idea es esa 00:42:23

Yo tengo 00:42:26

Collection que me define una colección genérica 00:42:27

Y luego este collection está especificado 00:42:33

En tres posibles colecciones 00:42:36

Un poquito más concretas 00:42:38

Que son listas, colas o conjuntos 00:42:40

Y cada uno de ellos 00:42:43

O añade 00:42:45

Métodos nuevos 00:42:46

O 00:42:48

Especializa 00:42:50

Métodos que ya existían 00:42:53

En un comportamiento más 00:42:55

Concreto para ese set 00:42:57

O las dos cosas a la vez 00:42:59

Sí, porque esta hereda de esta 00:43:01

Entonces, esos cinco básicos 00:43:09

Los va a llevar 00:43:11

Pero a lo mejor el set tiene 00:43:12

Un método que no tiene sentido 00:43:15

Para todas las colecciones, pero para el set 00:43:17

En concreto sí, y lo añade 00:43:19

Y a lo mejor en collection tú puedes 00:43:20

Añadir un objeto todas las veces que quieres 00:43:23

Pero set no quiere, entonces te dice 00:43:25

Oye mira, en la especificación del set 00:43:27

Aquí te dice, como si estoy 00:43:29

Sobrescribiendo el set de collection 00:43:30

Diciendo, oye mira 00:43:33

En el set, collection 00:43:34

No puede añadir un elemento 00:43:36

Si ese elemento ya existe en la colección 00:43:38

En el set 00:43:41

Esto ya lo hemos visto 00:43:42

Esto ya lo hemos visto 00:43:49

Entonces la interfaz list 00:43:50

De estas tres 00:43:51

Empezamos por aquí 00:43:54

Que es la más fácil 00:43:56

Define una sucesión de elementos 00:43:57

Amite elementos duplicados 00:44:01

Entonces puedo poner un elemento 00:44:04

Y otra vez el mismo 00:44:05

Le da igual 00:44:06

No hace comprobación de no 00:44:08

Mira que este elemento ya estaba 00:44:10

Hago un ejemplo 00:44:11

Yo puedo tener una lista de citas para mi tutoría 00:44:13

Y si un alumno me pide dos tutorías, una hora y una próxima semana 00:44:18

Yo añado dos veces en la lista al mismo alumno, sin ningún problema 00:44:23

¿Vale? 00:44:27

Si fuera un set no lo podría hacer 00:44:28

Entonces uso la lista 00:44:30

¿Se entiende? 00:44:32

Vale 00:44:35

Aparte de los métodos heredados de collection 00:44:35

Añade métodos que permiten mejorar los siguientes puntos 00:44:40

O sea 00:44:43

Esto tiene todo lo que tiene 00:44:43

Collection, los cinco métodos 00:44:46

Pero además tiene 00:44:48

Acceso posicional al elemento 00:44:50

Un, dame el tercer elemento 00:44:52

Fijaos 00:44:55

Que aquí no está 00:44:56

Aquí no está un 00:44:59

Dame el tercer elemento 00:45:03

Aquí está el, dame el elemento 00:45:04

Este de aquí 00:45:07

En cierto sentido 00:45:08

Que esto remove también es 00:45:11

Esto yo asumiría que 00:45:12

Lo quita y te lo devuelve a ti 00:45:18

De esta forma si lo estás buscando 00:45:21

Lo puedes obtener 00:45:22

Pero independientemente 00:45:23

Aquí no pilla un entero 00:45:25

No pilla una posición 00:45:27

Pilla un elemento 00:45:28

Tú tienes esta colección 00:45:30

Y te dice me das este libro de aquí 00:45:31

Y yo voy allí 00:45:33

Lo busco y este de aquí 00:45:36

Pero no hay forma 00:45:37

Me quitas el quinto libro 00:45:39

Eso no lo puede hacer, no está 00:45:41

¿No entendéis la diferencia? 00:45:43

No, no, lo añade 00:45:47

Es un método nuevo 00:45:48

¿Sí? 00:45:49

¿Con el elemento puede ser un objeto 00:45:52

O un string o lo que sea, no? 00:45:54

¿String es un objeto? 00:45:57

Sustantemente son objetos 00:45:58

Pero hay como una idea más 00:46:00

Genera, porque si luego tú haces 00:46:02

Una, te pones 00:46:04

Como cosas que metes 00:46:06

Dentro, un tipo de interfaz 00:46:08

Que se podría hacer 00:46:10

¿Vale? Pues haces una lista de listas 00:46:11

Por ejemplo, pues entonces es un objeto 00:46:13

Pues sí, pero no, sí, pero no 00:46:15

Un elemento, más que menos 00:46:17

¿Vale? Entonces 00:46:19

Primero, hacer suposicionar un elemento 00:46:21

Manipula elementos en función de su posición 00:46:24

De la lista, ¿vale? Entonces puede decir 00:46:25

Añade 00:46:28

Dice, pues, no sé, pero añade en tercera 00:46:29

Posición, o píllame el elemento 00:46:31

Que está en tercera posición, ¿vale? 00:46:33

Cosa que un collection no puede 00:46:35

Hacer, y un list sí puede 00:46:38

Más cosas 00:46:40

Búsqueda de elementos 00:46:42

Busca un elemento concreto en la lista 00:46:43

Y devuelve su posición 00:46:45

¿Vale? 00:46:46

Cosa que no hace collection 00:46:49

Pero aquí, como la lista 00:46:51

Tiene asociado una posición 00:46:53

Un número 00:46:55

Un orden 00:46:56

¿Vale? 00:46:59

Yo le puedo decir, mira, mira este elemento de aquí 00:47:00

Dime en qué posición de la lista está 00:47:02

Y me va a leer tres 00:47:05

¿Qué es una cosa que hemos implementado nosotros? 00:47:08

Nosotros devolvíamos al objeto 00:47:09

Directamente 00:47:12

Nosotros nos hemos implementado esto 00:47:13

Le damos una posición y nos da el objeto 00:47:15

Este no 00:47:18

Literación sobre elementos 00:47:18

Mejora el iterador por defecto 00:47:22

¿Vale? 00:47:25

O sea que iterador 00:47:26

A nivel de colección es 00:47:27

Una cosa mágica 00:47:29

Que me permite iterar 00:47:31

Sobre todos los objetos de la colección 00:47:33

Ir a mirar todos los objetos 00:47:35

Que están en mi colección 00:47:37

Pues en list 00:47:38

Se mejora esto 00:47:40

Basándome sobre, ahora yo además 00:47:42

Tengo una posición, entonces es más fácil 00:47:44

Es más eficiente poder 00:47:47

Variabilizar, porque la lista está pensada 00:47:48

Por, entro aquí y lo puedo recorrer 00:47:51

De forma fácil, por lo tanto 00:47:52

Mejoro el básico 00:47:54

Que me dice collection y hago uno 00:47:56

Específico para list 00:47:58

En cierto sentido esto está sobre escribiendo 00:48:00

El iterador de arriba 00:48:02

¿Sí? 00:48:03

Y rango de operaciones, permítase realizar 00:48:05

Ciertas operaciones sobre el rango de elementos 00:48:08

Dentro de la propia lista 00:48:10

En plan, añádeme estos 5 elementos de golpe 00:48:11

En vez que uno en uno 00:48:14

O remuéveme estos 7 elementos de golpe 00:48:15

Ahí también estaría mejorando 00:48:19

No es mejorar 00:48:23

Sino añadir nuevas funcionalidades 00:48:27

Que en este contexto tienen sentido 00:48:29

En un contexto de colección 00:48:31

Que es mucho más genérico 00:48:33

A lo mejor no 00:48:35

Entonces la diferencia entre añadir y sobreescribir 00:48:35

Que cuando tú añades 00:48:38

Es una cosa que en Collection no está 00:48:40

Y ahora sí está 00:48:42

¿Vale? He añadido 00:48:44

Esto en Collection no está, lo he añadido yo 00:48:45

Sobrescribir es algo que ya 00:48:48

Existe en Collection 00:48:50

Y yo lo sobreescribo para mejorarlo 00:48:52

Con los datos y con la característica 00:48:54

Que tengo ahora, como por ejemplo 00:48:57

Iterador 00:48:58

En Iterador ya está en Collection 00:48:59

Pero yo lo que hago es lo pillo 00:49:01

Lo modifico para 00:49:03

Que sea más 00:49:04

Eficiente en el contexto 00:49:06

De la lista que estoy utilizando 00:49:09

¿Cómo? 00:49:10

Es un objeto del que tú 00:49:22

Pillas iterator y tiene dos metoditos 00:49:25

Que nos interesan 00:49:27

HasNext y Next 00:49:28

HasNext te dice si hay un elemento más 00:49:30

Y Next te da ese elemento 00:49:33

Entonces tú vas 00:49:35

En un while iterator hasNext 00:49:37

Pues dame el Next 00:49:39

Lo veremos 00:49:40

Sí, entonces 00:49:43

Lista, pilla 00:49:46

Tened en cuenta que esto no es un objeto 00:49:47

No es una clase 00:49:50

Es una interfaz 00:49:52

¿Vale? 00:49:53

Es una clase abstracta con todos sus métodos abstractos 00:49:55

Y pilla todos los métodos abstractos 00:49:58

De collection 00:50:01

Y añade 00:50:01

Estos métodos de aquí 00:50:03

Que no son cinco 00:50:05

Son más 00:50:08

La idea es que pueda hacer estas cosas 00:50:09

Y desde la interfaz list 00:50:12

En Java se conocen 00:50:16

Tres implementaciones directas 00:50:18

ArrayList, LinkedList 00:50:20

Y Vector 00:50:23

Y desde Vector hereda stack 00:50:23

Que en inglés quiere decir pila 00:50:27

O sea que si queréis hacer una pila 00:50:28

En Java es implementado como una lista 00:50:30

Y será un vector 00:50:33

Al que le habrá añadido 00:50:35

Los métodos propios 00:50:37

De la lista, de la pila 00:50:38

Y ahora lo vamos a ver si queréis 00:50:40

De uno en uno 00:50:42

ArrayList 00:50:45

ArrayList es una lista 00:50:47

Es una implementación típica 00:50:49

95% de las veces que utilizáis 00:50:50

Una lista en Java 00:50:53

Pues utilizáis ArrayList 00:50:55

Se basa en un array dinámico 00:50:56

Que aumenta su tamaño 00:51:00

Según crece la colección 00:51:01

¿Existen array dinámicos? No 00:51:02

Es un array estático que 00:51:04

Pero, automáticamente 00:51:06

Aumenta de su tamaño 00:51:08

Como hemos hecho nosotros, copiándose en otro array 00:51:09

Sin que tenga que hacerlo yo 00:51:12

¿Vale? Por eso dice array dinámico 00:51:14

¿Eh? 00:51:16

Porque 00:51:20

Es fácil 00:51:21

De utilizar, es fácil de pensar 00:51:24

¿Vale? De todas formas 00:51:26

No es que sea peor que el otro 00:51:27

Ahora lo veremos 00:51:28

Aquí 00:51:30

En la lucha directa 00:51:32

¿Vale? 00:51:35

Puede contener elementos duplicados 00:51:35

Puedo poner dos elementos que si hiciera 00:51:38

Equals entre ellos me darían true 00:51:40

Pues los puedo añadir 00:51:42

Puedes insertar al final 00:51:43

Una posición concreta, ¿vale? 00:51:46

Normalmente se inserta al final 00:51:48

Si tú haces add a secas 00:51:50

Pues te lo añade al final 00:51:52

Si haces add este elemento 00:51:53

Coma en posición 3 00:51:56

Te lo pone en posición 3 00:51:57

¿Vale? Fijaos que la lista 00:52:00

Puede hacer lo que le haga la gana 00:52:02

Si esto lo quiero hacer como cola 00:52:03

Pues entonces no lo debería 00:52:05

Poder hacer esto 00:52:08

Aún si lo hago a lo mejor lo puede hacer 00:52:09

Pero, y tened en cuenta 00:52:12

Que si voy a cola 00:52:13

No estoy aquí 00:52:14

Voy aquí 00:52:17

Que si quiero hacer una cola 00:52:18

No es una lista, es otra interfaz 00:52:21

¿Qué más? 00:52:24

Permite el acceso alatorio porque al ser implementado 00:52:29

Con un array, permite acceder a la posición 00:52:31

Usando el índice del array mismo 00:52:33

Este es super potente 00:52:35

Si yo digo accedo al elemento 5 00:52:36

Como es un array, accedo a la posición 5 00:52:39

Y ya me encuentro el objeto 00:52:41

Es muy rápido a la hora del acceso aleatorio 00:52:43

Acceso aleatorio quiere decir 00:52:46

Que yo tengo todos mis objetos 00:52:47

Y quiero este 00:52:49

La manipulación 00:52:50

De estos objetos 00:52:56

Es lenta 00:52:57

Cada vez que yo añado uno 00:52:58

O quito uno 00:53:01

Es un problema 00:53:02

Porque tengo que rehacer el array entero 00:53:04

Lo hemos visto nosotros 00:53:07

Cada vez que añadía uno tenía que copiar el array entero 00:53:08

Añadir un espacito 00:53:11

Y añadir una nueva cosa 00:53:12

Y esto es costoso 00:53:14

Entonces 00:53:15

Maravilloso 00:53:17

Para accesos directos 00:53:20

Accesos aleatorios 00:53:23

O sea, un programa 00:53:24

Que me rellena una colección 00:53:26

De datos una vez 00:53:29

Y luego la usa un millón de veces 00:53:30

Arraylist fenomenal 00:53:33

Un programa que está constantemente 00:53:35

Insertando y quitando datos 00:53:39

Desde la colección 00:53:41

Arraylist fatal 00:53:42

Pero si la colección es la misma 00:53:44

El problema no es la clase que hace 00:54:07

Es que la colección es esa 00:54:08

Si tú la colección la has implementado con Arraylist 00:54:10

Y tienes una clase que la rellena 00:54:13

Y una clase que hace de ella 00:54:15

Pero igualmente es una relis 00:54:17

El problema es de la implementación 00:54:18

Tener duplicado 00:54:20

O sea, tener los mismos datos 00:54:22

Implementados una vez como relis 00:54:24

Y una vez como linked list 00:54:26

Y cuando tengo que añadir cosas, lo añado aquí 00:54:27

Luego llega un momento que no son las mismas 00:54:30

Nunca duplicar datos 00:54:32

Esto de consistencia de datos 00:54:35

Creo que lo habéis visto en algo en base de datos 00:54:37

¿No? 00:54:39

Cuidado con la tabla 00:54:41

De poner el mismo dato en una tabla y en otra 00:54:42

Porque luego cuando actualizáis aquí 00:54:45

Si no actualizáis el otro es para todo 00:54:47

¿No? 00:54:48

¿Hay listas de Google? 00:54:50

Sí, ¿no? 00:54:52

Está con él 00:54:54

La manipulación es lenta 00:54:54

Porque es necesario realizar muchos cambios 00:54:58

Si se elimina algún elemento, ¿vale? 00:55:00

No está sincronizado 00:55:02

¿Qué es esto de sincronizar? 00:55:03

Os lo digo en pincelada rápida 00:55:05

Vosotros estáis acostumbrados a hacer 00:55:07

Programas que tienen un hilo de ejecución 00:55:09

El main 00:55:12

Empieza aquí, hace esta cosa 00:55:13

Llama otro método, hace esta cosa 00:55:16

Y se acabó 00:55:17

Pero es siempre un solo 00:55:18

Una sola secuencia 00:55:20

Una secuencia clara 00:55:24

En segundo de Damm 00:55:25

Un profesor muy bueno 00:55:27

De orígenes 00:55:30

Italianas 00:55:32

Os podría enseñar 00:55:34

Como se hacen programas 00:55:36

Que lanzan varios hilos de ejecución 00:55:38

A la vez 00:55:41

Tú lanzas un solo proceso 00:55:41

Pero ese proceso se divide 00:55:43

En varias cosas que van por separado 00:55:45

Y se hacen cosas completamente separadas 00:55:48

Para hacer un ejemplo plano 00:55:49

Cuando vosotros usáis el Word 00:55:51

Y estáis tecleando 00:55:53

Y alguien mágico os dice 00:55:54

Esta palabra está mal escrita 00:55:57

Pues ahí hay dos threads 00:55:58

Un thread que está recibiendo tus datos 00:56:00

Desde el teclado y lo está escribiendo allí 00:56:04

Y otro thread que a la vez 00:56:05

Está pillando esto de allí y lo está comprobando 00:56:07

Con la gramática española y te está diciendo 00:56:09

Esto lleva acento 00:56:11

¿Sí? 00:56:12

Pues cuando hay casos de eso 00:56:15

Cuando hay multithreading 00:56:17

Los objetos tienen que ser 00:56:19

Sincronizados 00:56:23

Porque si este intenta escribir 00:56:24

Algo en un string 00:56:27

Mientras este escribe en el mismo string 00:56:28

Puede que hagan caos 00:56:31

¿Se entiende? 00:56:33

Vale 00:56:36

ArrayList no es sincronizado 00:56:36

Hace caos 00:56:39

Si tú tienes dos threads 00:56:40

Que trabajan sobre el mismo ArrayList 00:56:42

Antes o después te cargas algo 00:56:44

Y luego está LinkedList 00:56:46

LinkedList es una lista doblemente enlazada 00:56:53

No es la implementación nuestra 00:56:57

Aquí os acordáis que os dije 00:57:00

Podría hacer que el nodo tenga un link al siguiente 00:57:02

Y también un enlace al anterior 00:57:05

Pues esta es la implementación que hace Java 00:57:07

Java es una lista doblemente enlazada 00:57:10

Desde un elemento, desde un nodo de la lista 00:57:14

Puedo ir al anterior o al siguiente 00:57:17

Tranquilamente 00:57:19

Puede contener elementos duplicados 00:57:20

Se puede insertar al final o en una posición concreta 00:57:24

Yo digo añadir una posición 3 00:57:27

Él entrará en el primer elemento 00:57:30

Va al siguiente, va al siguiente 00:57:32

Aquí es donde inserta el nuevo 00:57:34

Y lo concadena con el siguiente de la lista 00:57:36

Se puede hacer 00:57:39

La lista permite insertar en una posición aleatoria 00:57:40

Esta implementación con respecto a la lista 00:57:45

Mejora la velocidad de manipulación de los objetos 00:57:48

Lo vimos 00:57:51

Añadir o quitar nodos es mucho más rápido 00:57:51

Con respecto a copiar el entero array 00:57:55

Añadir una posición y poner allí un nuevo objeto 00:57:59

Lo que pasa es que el acceso aleatorio es mucho peor 00:58:01

Porque antes podía acceder directamente a la posición 6 de la array 00:58:06

Y ahora para llegar a la posición 6 00:58:10

Tengo que entrar en el primero 00:58:12

Desde el primero ir al segundo 00:58:14

Del segundo al tercero 00:58:16

Del tercero al cuarto 00:58:17

Y así hasta llegar al sexto 00:58:18

Es mucho más lento 00:58:20

Entonces, un sistema en que yo estoy constantemente 00:58:21

Insertando y quitando datos desde mi colección 00:58:25

LinkedList es muy bueno 00:58:28

Un sistema en el que al principio carga la colección 00:58:30

Y luego lo único que hace es acceder 00:58:34

A los datos dentro de la colección 00:58:36

Link list mal 00:58:38

Este también estaría en el set 00:58:39

No, este es un list 00:58:44

¿Cierto? No tiene que ver 00:58:45

¿List? 00:58:47

Si, si, si 00:58:52

Nosotros estamos aquí 00:58:53

Si, te lo digo 00:58:55

Si es bueno para eso 00:58:56

También sería bueno tenerlo en el set 00:58:58

Porque como ves todo 00:59:01

Sin ordenar 00:59:03

Y de hecho, linkedh set es una implementación con nodos del set 00:59:04

Pero no estamos aquí 00:59:09

Estamos implementando listas 00:59:10

¿Vale? 00:59:13

Este señor de aquí 00:59:17

Utilizado 00:59:19

Si miráis la cosa, ahora lo veremos 00:59:21

Pues se puede utilizar como lista 00:59:26

Se puede utilizar como pila 00:59:28

Y se puede utilizar como cola 00:59:30

Utilizando los métodos correctos 00:59:32

Esta misma implementación 00:59:35

Te permite usar las tres cosas 00:59:37

O sea que esta de aquí 00:59:38

Además de lo que viene en lista 00:59:43

Además de lo que viene en collection 00:59:45

Añade métodos 00:59:47

Que si tú usas los métodos correctos 00:59:49

Ahora veremos cuáles son 00:59:51

Pues te funciona como una lista 00:59:52

O te funciona como una pila 00:59:54

O te funciona como una cola 00:59:56

Comparación entre RList y LinkedList 00:59:56

Que es un poco un repaso 01:00:05

De lo que hemos dicho hasta ahora 01:00:06

Este señor por debajo usa un array dinámico 01:00:07

Este señor por debajo 01:00:11

Usa una lista doblemente enlazada 01:00:13

Los nodos estos que se conectan 01:00:14

La manipulación 01:00:16

De la array es lenta 01:00:19

Porque internamente es un array 01:00:20

Si se elimina algún elemento del array 01:00:22

Todos los bits se desplazan en la memoria 01:00:24

Se cambia todo 01:00:26

La manipulación de linked list 01:00:27

Es más rápida 01:00:31

Porque son como listas vinculadas 01:00:32

Con objetos vinculados 01:00:34

Por lo tanto si elimino uno 01:00:35

Pues el resto se queda igual 01:00:37

Una clase relist puede actuar 01:00:38

Como una lista 01:00:43

Solo porque implementa 01:00:44

Solo list 01:00:47

Sin embargo la linked list 01:00:48

Puede actuar como una lista y una cola 01:00:51

Y también como la otra 01:00:53

Ya que implementa también las otras 01:00:54

Si os fijáis 01:00:57

Linked list 01:00:58

Implementa list 01:01:02

Pero implementa también deck 01:01:03

Que es 01:01:05

La cola 01:01:08

Es por eso que esto 01:01:09

Puede funcionar como lista, puede funcionar como cola 01:01:10

Puede funcionar como 01:01:14

Pila 01:01:15

¿Sí? 01:01:16

Deriva de esto 01:01:21

En realidad la pila oficial 01:01:22

Es esta, stack 01:01:24

Pero la deck 01:01:25

Que es una double ended queue 01:01:27

No hemos llegado todavía allí 01:01:30

Es una cola 01:01:31

Que puedes añadir cosas por aquí y por aquí 01:01:33

¿Vale? 01:01:36

Entonces esto te permite utilizarla 01:01:37

Como pila o como cola 01:01:39

O como lista 01:01:41

Lo veremos más después 01:01:42

¿Vale? 01:01:46

Finalmente 01:01:49

ArrayList es mejor para almacenar 01:01:50

Y acceder a datos 01:01:52

¿Vale? Porque el acceso es muy rápido 01:01:53

LinkList es mejor para manipular datos 01:01:55

Para cambiarlos y cosas por el estilo 01:01:58

Ponerlo y quitarlo 01:02:00

base de datos ninguno de estos 01:02:03

¿vale? porque la base de datos 01:02:10

ya está a otro nivel 01:02:12

¿vale? para hacer una base de datos 01:02:13

lo que necesitas es un sistema gestor 01:02:15

de base de datos 01:02:18

entonces ya nos alejamos de esto 01:02:18

esto es más bien, tú tienes 01:02:22

un programa que al principio tiene que cargar 01:02:24

los datos y tenerlos ahí 01:02:26

a disposición y como los almacenas 01:02:28

de otra forma 01:02:30

yo accedo a la base de datos 01:02:31

me pillo todo el 01:02:33

Magollón de datos que están allí 01:02:35

Según una select 01:02:37

Asterisco, fraume, no sé qué 01:02:38

Y ahora estos datos 01:02:41

Que he recuperado 01:02:43

De la base de datos, pues los tengo que almacenar 01:02:45

En alguna colección 01:02:48

Para luego poderlo utilizar en mi programa 01:02:49

¿Vale? Porque si no estaría 01:02:52

Constantemente haciendo peticiones 01:02:53

A la base de datos, que a lo mejor están en otro servidor 01:02:55

Eso es lentísimo 01:02:57

Y ahora 01:02:59

Voy a hacer lo que tengo que hacer 01:03:09

No necesariamente clasificarlo 01:03:12

Pero necesito los alumnos porque me han pedido el listado de todos los alumnos 01:03:13

divididos por, qué sé yo, clases. 01:03:19

Voy a la base de datos, dame todos los alumnos con su clase al lado, 01:03:24

recibo esta información, la meto en una colección mía 01:03:29

y ahora empiezo a trabajar con esta colección. 01:03:32

¡Dudas! 01:03:37

Estructuras dinámicas 1 - Contenido educativo

Del mismo autor…

Festival Navidad 2025 1º Primaria

Festival Navidad 2025 5 años

Festival Navidad 2025 4 años

Festival Navidad 2025 3 años

1st TERM _ 5thB (2025.2026)

Primer trimestre

NUESTRA PRIMERA NAVIDAD