Saltar navegación

Collections 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 6 de febrero de 2026 por Stefano C.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Voy a grabar esta clase, por lo tanto, si habláis, me autorizáis a grabar vuestra voz, ¿vale? 00:00:00
Vale, hoy vamos a ver la parte teórica de las estructuras dinámicas. 00:00:08
En las clases anteriores lo que hemos hecho es implementar nosotros dos típicas estructuras dinámicas, 00:00:12
que son la ReList y la LinkedList, ¿vale? 00:00:21
después de haber echado un vistazo 00:00:25
a lo que nos espera 00:00:27
desde una perspectiva práctica, digamos, 00:00:28
pues vamos a ver la perspectiva, 00:00:31
el marco teórico en el que nos 00:00:33
movemos, ¿vale? 00:00:35
Estas se llaman estructuras 00:00:37
dinámicas, ¿por qué? 00:00:38
Porque puede 00:00:45
poner varios datos 00:00:45
y nos ayuda a manipularlo. 00:00:51
¿Y un array 00:00:54
no nos permite 00:00:55
guardar varios datos y nos 00:00:56
ayuda a manipularlo? 00:00:59
Si os acordáis, uno de los problemas principales del array, que era una colección de datos al fin y al cabo, de todos iguales, pero que era una colección de datos, yo puedo hacer un array de objetos y poner ahí dentro lo que me da la gana, pero tenía este problema de que es fijo. 00:01:01
A la vez que tenía que modificar el tamaño del array, tenía que construir literalmente un nuevo array, recolocar todos los punteros, todas las referencias de los objetos en el nuevo array, y a este punto tenía un array más grande o más pequeño o lo que sea. 00:01:18
Era un trabajo bastante engorroso desde la perspectiva del array, pero hay que considerar que el array existía antes, digamos, de este tipo de estructuras. 00:01:37
Efectivamente, los arrays son complejos, o sea, no son complejos, pero complican el código porque cada vez que tienes que hacer una operación pequeña, 00:01:50
tienes que ponerte allí, recorrerlo entero, hacer varias estructuras, varios problemas. 00:02:00
Y por lo tanto, en el mundo de Java, en el mundo de la programación en general, 00:02:06
la gente dijo, ¿por qué no hacemos unas estructuras dinámicas que me esconden lo que pasa detrás de un array 00:02:11
y hacen prácticamente lo mismo que un array? 00:02:17
Es decir, puedo manipular datos y almacenar ahí datos y luego recuperarlos como me da la gana. 00:02:20
y entonces se crearon estas estructuras dinámicas 00:02:25
cuya implementación puede o no depender de Arrays. 00:02:28
Lo hemos visto. 00:02:33
ArrayList depende de Array. 00:02:34
La LinkedList no hemos visto ni un Array allí dentro. 00:02:36
Una estructura dinámica es una colección de datos 00:02:42
que puede variar su tamaño en tiempo de ejecución. 00:02:45
La diferencia fundamental es que un Array 00:02:49
no puede cambiar su tamaño 00:02:52
en tiempo de ejecución, mientras que 00:02:54
en estructura dinámica sí. En tiempo de ejecución 00:02:56
quiere decir una vez que he lanzado el programa. 00:02:59
O sea, un array, yo le digo 00:03:01
tamaño 10, si añado 11 00:03:03
alumnos, tengo un problema. 00:03:04
¿Vale? O sea, tengo 00:03:07
que crear un nuevo array más grande, 00:03:08
pero el array original 00:03:11
no lo puedo aumentar del 1000. 00:03:13
Mientras que este de aquí, la idea 00:03:15
es que esta estructura dinámica, 00:03:17
yo no sé cuántos alumnos voy a añadir, 00:03:19
puedo añadir 100, puedo añadir 1000, 00:03:21
él encontrará la forma de organizar estos datos de una forma o de otra. 00:03:22
Está claro que, como todos en el mundo de la informática, hay un límite. 00:03:31
El límite me lo da mi hardware. 00:03:34
Si yo tengo un giga de RAM, yo no lo tengo. 00:03:37
Pues no puedo poner seis gigas de datos. 00:03:42
Llega el momento que dirá, oye, mirad, esta estructura de datos no cabe. 00:03:46
Pues el sistema operativo hará un swapping con el disco duro y entonces todo irá tremendamente lento, pero podrá hacerlo. 00:03:49
Lo mejor. 00:03:57
Pero aún así, si yo tengo 100 millones de datos en un programa, pues no los puedo manipular. 00:03:58
Si yo genero 100 teras de datos en un ordenador, pues llegará un momento que mi ordenador dice, 00:04:05
oye, mira, tengo espacio donde guardar estos datos, tengo que borrarlos. 00:04:11
¿Sí? 00:04:16
Para entender la idea. 00:04:17
¿Cuáles son las estructuras dinámicas más conocidas, básicas, digamos así? 00:04:19
Luego ya veremos las implementaciones que puede haber. 00:04:29
Pues listas, colas, pilas y árboles. 00:04:32
Estos son cuatro. 00:04:35
Si os habéis fijado, en esta última semana hemos hablado de las primeras tres. 00:04:36
O sea, han salido de vez en cuando. 00:04:45
Y los árboles, hemos hablado de ellos alguna vez en episodios anteriores. 00:04:47
o sea, no es la primera vez que se habla de árboles, pero bueno, ahora vamos a repasar qué es cada una de ellas para entender las diferencias. 00:04:51
Una lista es una estructura dinámica que permite almacenar un objeto y tener un modo para poder acceder al siguiente elemento de la lista, ¿vale? 00:05:01
Es decir, tú tienes un inicio o una cabeza, accedes al primer objeto de esta lista 00:05:13
y puedes desde allí, de alguna forma, acceder al siguiente. 00:05:20
Esta es una lista, es lo que llamamos comúnmente una lista, 00:05:25
una lista a la compra, una lista de peticiones, una lista... 00:05:33
Lo que me puede interesar a este nivel es el orden de inserción de los objetos. 00:05:37
O sea que normalmente cuando se inserta un elemento se inserta al final. 00:05:47
Pero en realidad en una lista yo puedo insertar los objetos donde quiera. 00:05:54
Uno de los métodos que nosotros hemos implementado es el añádeme este objeto en posición 3, por ejemplo. 00:06:01
Una lista, en teoría, podría hacerlo. Podría añadirlo delante, podría añadirlo al final. 00:06:06
La idea es que al final tenga una lista de cosas, no necesariamente ordenadas por prioridad o por cualquier orden. 00:06:11
Está claro que si yo la uso de un determinado modo, como por ejemplo siempre añado al final, 00:06:19
pues tendré el orden de inserción preservado. 00:06:24
Pero la lista por sí misma es más flexible. Puede hacer un poquito lo que le da la gana. 00:06:30
A diferencia de las otras dos que tenemos. 00:06:37
Para recorrer la lista lo haré desde el inicio al final. 00:06:40
Como tengo el inicio, pues no puedo entrar donde me da la gana, tendría que entrar en el inicio. 00:06:42
Aún así, dependiendo de la implementación, hay algunas implementaciones que sí me permiten un acceso aleatorio. 00:06:48
Por ejemplo, la ArrayList, como por debajo es un Array, 00:06:55
No tiene problema en entrar en la posición 3. 00:07:00
¿Vale? 00:07:04
Array, procedo a la posición 3 del array y llego directamente. 00:07:04
Una lista enlazada, pues llegar a la posición 3 es más complejo. 00:07:08
No puedo llegar directamente. 00:07:12
No tengo un puntero directamente a la posición 3. 00:07:14
Tengo que entrar por la cabeza y luego siguiente, siguiente, siguiente. 00:07:17
¿Dudas? 00:07:22
Ahora, una cola es, lo sabéis, también lo habéis visto antes, lo habéis dicho, 00:07:28
es parecida a una lista pero mantiene un estricto orden cifo first in first out es decir que cuando 00:07:33
tú insertas algo luego este algo que has insertado es el primero que puedes pillar entonces tú tendrás 00:07:43
dos métodos uno es añade uno es la pilla vale y al añadir siempre se añadirá al final vale y al 00:07:50
al pillar, siempre se pillará desde el principio. 00:08:01
Si yo mantengo esta función de aquí, 00:08:05
es decir, que siempre saco de la lista, 00:08:07
digamos, de esta lista especial, 00:08:13
el elemento más viejo, 00:08:15
entonces el primero que ha entrado 00:08:17
es el primero que sale, fijo, 00:08:19
pues entonces estoy haciendo una cola. 00:08:22
Es la cola que tengo a un banco, 00:08:24
o al correo, o a un cine, ¿vale? 00:08:27
El primero que ha llegado es el primero que será servido por ese servicio, 00:08:31
por mandarle su carta o que la gente se le pasa. 00:08:36
Hombre, que no sean italianos. 00:08:41
Pila, ¿vale? 00:08:44
Parecida siempre a una lista, ¿vale? 00:08:46
Pero sigue otro mecanismo. 00:08:48
En vez de first in, first out, es que el último que ha entrado es el primero que sale. 00:08:51
¿Vale? 00:08:56
Entonces yo puedo añadir cuando se añadan las cosas, 00:08:56
Entonces es como si se añadan en la cima de la pila. 00:08:59
Estoy apilando las cosas. 00:09:03
Entonces los elementos más viejos se quedan más abajo en la pila. 00:09:04
Y como están más abajo y los otros están encima, 00:09:10
no puedo alcanzar los que están abajo sin antes quitarlos de arriba. 00:09:12
Aquí los métodos se suelen llamar push y pop. 00:09:18
Push lo empujo desde arriba y pop lo saco desde arriba. 00:09:22
¿Vale? ¿Hemos visto algún ejemplo de una pila? 00:09:26
Por ejemplo, no me es que cosa, en el campo lo hemos visto cuando hemos visto el ejercicio de recursividad, sí. 00:09:36
Pero ¿qué era esa pila? ¿Qué pila era? 00:09:47
La pila de llamada de métodos. Pues eso es lo que hemos visto, ¿vale? 00:09:53
Que luego en la recursividad la hemos hecho explotar llamando siempre lo mismo. 00:09:57
sustancialmente la gestión como Java o como muchos de los programas lenguaje 00:10:02
programación gestiona las llamadas de métodos es con una pila vale porque yo 00:10:08
llamo el primer método que es el main si el main llama otro método pues ese 00:10:14
método se pondrá a la cima de la pila porque hasta que no haya acabado ese 00:10:18
método no volveré al main vale entonces cada llamada añade un nivel en la pila 00:10:24
y cada vez que acaba un método, pues, se quitará de la pila y se volverá a reanudar. 00:10:29
Eso, el método que lo había llamado, en el punto en que se había llamado, ¿vale? Entonces está 00:10:38
haciendo, si os lo pensáis bien, ¿cuál es el último método que acaba? En vuestros programas, 00:10:44
¿cuál es el último método que acaba siempre? Main. Si vosotros no tenéis threads, entonces, 00:10:55
si llamáis el main como primero, 00:11:02
luego dentro del main podéis llamar 00:11:04
un montón de otros métodos, pero al final 00:11:06
volveréis al main y el main acaba. 00:11:08
O sea, que es el main el primero que 00:11:10
ejecutáis y el último que se para. 00:11:12
Preguntas, lista, 00:11:18
colas y pilas. 00:11:19
Entiendo más o menos. 00:11:23
Un árbol. 00:11:25
Un árbol es otra estructura, un poquito más 00:11:27
distinta en vez de la lista 00:11:29
porque no es no lineal. 00:11:31
¿Vale? Mientras la lista, la cola, la pieza son todas más o menos lineales, pues este de aquí es un poquito más complejo. 00:11:34
¿Vale? Un árbol en informática es una serie de nodos conectados entre ellos. 00:11:39
¿Vale? Cada nodo suele tener un nodo progenitor y unos cuantos nodos hijos. 00:11:45
¿Vale? Entonces, aquí por ejemplo vemos que hay algunos nodos que tienen, o sea, todos, perdón, tienen un solo progenitor, 00:11:51
pero hay algunos nodos que tienen tres hijos, algunos nodos que tienen dos, algunos que tienen uno y algunos que no tienen ninguno. 00:11:59
El primer nodo arriba, que no tiene padre, o que no tiene madre, o que no tiene procedidor, es el nodo raíz. 00:12:07
Es la raíz del árbol. 00:12:15
Los nodos que no tienen hijos se llaman hojas. 00:12:17
Es un árbol, pero arriba. 00:12:22
También la profundidad al que está un nodo se llama nivel, el grado de un nodo es cuántos 00:12:23
hijos tiene, el grado de un árbol es el mayor grado de todos sus nodos, y cosas por el estilo. 00:12:36
Son cosas para, si os metéis en teoría de grados, en algorítmica más avanzada, pues salen estos conceptos para indicar algunas necesidades de algunos teoremas o cosas por el estilo. 00:12:45
Para que esto funcione el árbol tiene que ser de grado máximo 2 y bla bla bla. 00:12:59
No sé si está diciendo esta cosa, pero a nuestro nivel nos interesa relativamente poco. 00:13:06
existen árboles especiales 00:13:10
uno famoso es el árbol binario de búsqueda 00:13:15
en el que sostancialmente cada nodo tiene solo como máximo dos hijos 00:13:18
y sostancialmente es me comparo 00:13:23
cuando inserto un nuevo nodo me comparo con el nodo actual 00:13:27
si soy mayor que este nodo me pongo a la derecha 00:13:31
si soy menor que este nodo me pongo a la izquierda 00:13:35
Y entonces, sustancialmente, se crea un árbol que es bueno para las búsquedas, porque los elementos están medianamente ordenados. 00:13:39
Si lo hago bien, el árbol me permite búsquedas logarítmicas, o sea, con velocidad mucho mejor con respecto a una búsqueda lineal, simplemente buscando el elemento. 00:13:51
El precio que pago, que es insertarlo 00:14:04
Es mucho más complejo 00:14:08
Que simplemente añadirlo al fondo 00:14:10
De una lista 00:14:11
Pero es más o menos una cosa común 00:14:12
Si yo quiero una ventaja 00:14:15
Pues esa ventaja la tendré que pagar 00:14:17
Con una desventaja por otro lado 00:14:19
Si quiero inserciones rápidas 00:14:20
Posiblemente luego buscar será un infierno 00:14:23
Si quiero búsquedas rápidas 00:14:26
Posiblemente la inserción será un infierno 00:14:27
Luego existen árboles balanceados 00:14:29
en el que no hay una rama 00:14:34
mucho más profunda que la otra 00:14:36
y por ejemplo un árbol de búsqueda 00:14:38
binario de búsqueda 00:14:41
para que sea eficiente tiene que ser balanceado 00:14:42
y un montón de cosas 00:14:44
aquí hay 00:14:46
asignaturas de la universidad 00:14:47
que van sobre estas cosas, interesantes 00:14:50
pero no tenemos el tiempo 00:14:52
aquí un poco las cosas que decía antes 00:14:55
que es una hoja, que es un nodo interior 00:14:57
que es una raíz 00:14:59
el nivel del árbol 00:15:00
el grado de un nodo, el grado del árbol 00:15:02
¿vale? que son unidos 00:15:04
como hemos visto antes 00:15:06
¿sí? 00:15:08
todo esto es conceptos generales 00:15:09
de estructuras dinámicas, de estructuras 00:15:12
de datos ¿vale? estos son 00:15:14
cuatro tipos de estructuras de datos 00:15:16
bien conocidos que se usan en el mundo 00:15:17
de la informática y que 00:15:20
matemáticos se han metido a estudiarlos 00:15:21
para encontrar propiedades interesantes 00:15:24
y cosas guay que se pueden 00:15:26
utilizar, si el árbol tiene esta 00:15:28
gratis y así la cola tiene esta otra 00:15:30
gratis y así, ¿vale? 00:15:32
¿Qué pasa 00:15:35
en nuestro mundo, o sea, en Java? 00:15:36
¿Vale? En Java 00:15:39
existe una interfaz 00:15:40
que se llama la interfaz collection. 00:15:42
¿Vale? La interfaz collection 00:15:45
es como 00:15:46
una 00:15:47
una generalización, 00:15:49
una abstracción 00:15:53
de todas las que hemos visto hasta ahora. 00:15:54
¿Vale? Todas las estructuras 00:15:56
dinámicas que veremos nosotros 00:15:58
heredan o implementan mejor la interfaz collection. Entonces aquí estarán metidas los métodos, 00:16:00
el contrato de los métodos más básicos que tendrán que tener todas las posibles estructuras 00:16:11
dinámicas de Java, sean una cola, sean una pila, sean un árbol, etcétera. Principalmente cosas 00:16:19
como añadir un elemento, sacar un elemento, 00:16:26
y cosas por el estilo. 00:16:30
Lo que quiera hacer con cualquier estructura dinámica, 00:16:31
que si no hiciera eso, no tendría sentido crear una estructura dinámica. 00:16:33
Las colecciones representan grupos de objetos denominados elementos. 00:16:40
Podemos encontrar diversos tipos de colecciones 00:16:44
según si sus elementos están ordenados 00:16:47
o si permiten repeticiones de elementos o no. 00:16:50
Dos de las características fundamentales que tenemos que preguntarnos es 00:16:53
¿quiero ordenar los elementos cuando los inserto? 00:16:56
O sea, ¿me da igual que los insertos están allí 00:17:00
o quiero que mantengan un orden 00:17:02
para que sea más fácil luego organizarlos, 00:17:04
buscarlos, etcétera, etcétera? 00:17:06
Dependiendo de esta elección, 00:17:08
voy a una u otra estructura dinámica. 00:17:09
Y otra cosa es, 00:17:13
¿puedo permitir la repetición de elementos o no? 00:17:14
Si yo añado dos veces el mismo alumno, 00:17:18
añado dos veces el mismo alumno 00:17:20
o hago algo para decir, 00:17:22
No, el de alumno este aquí ya existe, entonces no lo voy a añadir otra vez. 00:17:24
Está claro que esta cosa de la repetición de elementos está muy, muy, muy relacionada con 00:17:29
que me puede afectar muchísimo la repetición de alumnos. 00:17:39
O sea, ¿cómo sé si un elemento se repite o no? 00:17:48
¿Cómo sé? 00:18:01
¿Cómo puedo saber si este objeto que ahora tengo y quiero insertar, ya existe o no? 00:18:04
¿Qué tendré que hacer para saber si ya existe o no? 00:18:11
Compararlo con los objetos que tengo. 00:18:16
Por lo tanto, saber si se repite o no se basará sobre la implementación de equals. 00:18:19
Dependiendo de mi definición de equals, yo te diré si lo puedes añadir o no. 00:18:27
dos alumnos. Si yo te digo 00:18:36
el equals es el de object, 00:18:39
pues si creo un nuevo alumno Estefan, un nuevo alumno 00:18:41
Estefan, pues pondré los dos, porque 00:18:43
son dos instancias distintas. 00:18:45
Entonces, igual, igual, da la falsa, 00:18:47
pues perfecto, se añaden los dos Estefan. 00:18:49
Pero si yo digo, no, 00:18:52
mis alumnos se comparan 00:18:53
por nombre. Si tienen el mismo nombre, 00:18:55
entonces es el mismo alumno, 00:18:57
definición distinta de igualdad 00:18:59
entre alumnos, pues ahora, cuando 00:19:01
he añadido Estefan, añado otro que sea 00:19:03
año Estefano, pero como la igualdad se basa sobre el nombre, me dice, no, el alumno Estefano 00:19:05
ya existe. Entonces no me la llevo. ¿Sí? Volveremos a hablar de esto. 00:19:09
El tipo más genérico en cuanto a que se refiere a cualquier tipo de contexto. Esto 00:19:20
es genérico, es una abstracción, ¿vale? Es cualquier colección de datos. ¿Cómo 00:19:26
funciona? Pues no lo sé todavía, ¿vale? Luego vamos a ver las implementaciones de 00:19:31
esta colección para ver qué características tiene y esto es un poco el esquema de lo que 00:19:35
tenemos aquí esta colección de colección de extender vale otra clase otra interfaz 00:19:43
porque las azules son interfaces la verde son clases para extender otra interfaz que 00:19:53
la iterable. O sea que cualquier colección tiene que tener un mecanismo mágico para decir, oye, 00:19:58
quiero recorrer la colección entera. No sé cómo está hecha la colección, pero quiero entrar en 00:20:09
todos los elementos, en todos y una vez por cada elemento. Haz algo, pónmelos en una pila, 00:20:16
ponmelos en una columna, ponmelos en un saco, pero yo lo que quiero ahora es mirar todos los 00:20:24
elementos que están en esta colección, de uno en uno, todos. ¿Entienden? Entonces, esto me lo da 00:20:31
iterable. ¿Ok? Iterable es algo que se puede iterar, es algo que se puede ciclar sobre él, 00:20:39
es algo que se puede mirar uno tras otro, ¿vale? Y mi colección es un iterable, ¿vale? Luego, 00:20:46
Aquí están las colecciones, que es lo básico. Es una colección genérica de datos, de elementos. 00:20:53
No sé bien cómo funciona, pero tendrá los mecanismos más básicos para que sea una colección. 00:20:59
Añadir un elemento, quitar un elemento. 00:21:05
A partir de aquí se crean tres distintas interfaces. 00:21:08
Las tres se heredan de colecciones, entonces son colecciones ellas también. 00:21:14
Pero asumen cosas distintas. El contrato de estas colecciones ya asume un comportamiento distinto con respecto a las colecciones en general, que son las listas, las colas y los conjuntos. 00:21:18
Ahora los tenemos en concreto, pero en la lista, sustancialmente, es la que hemos implementado nosotros, ¿vale? Una lista de elementos, de hecho aquí está ArrayList y LinkedList, que son verdes, estas son implementaciones, estas implementan List, que implementa Collection, que implementa Iterable, ¿vale? 00:21:35
Por lo tanto, una ArrayList es estas tres cosas, tiene métodos de estas tres interfaz, ¿sí? 00:22:03
Y la LinkedList lo mismo, hace lo mismo, ¿sí? La única cosa es que la LinkedList veis que 00:22:09
extiende también otra, ¿sí? Luego está la Queue, ¿vale? La Queue es en inglés, ¿se acuerdan? 00:22:16
Que, sustancialmente, lo que hace es, vale, lo mismo, siempre puedes añadir elementos y quitarlos, 00:22:22
pero la Q mantiene un first in, first out. Entonces, si tú vas a ver la interfaz de cola 00:22:29
y vas a mirar que dice sus métodos añadir, no te dice añádelos donde te da la gana, te dice está 00:22:39
forzado a añadirlo al final. Como que no seas una deck, que es la doble ended Q, que es una cola 00:22:46
que puedes añadir 00:22:56
tanto por un lado como por el otro. 00:22:59
Son, ¿para qué me sirve? 00:23:01
No lo sé. Habrá algunos 00:23:03
problemas en el que yo quiero 00:23:05
que los datos funcionen como una cola, 00:23:07
por lo tanto usaré una priority queue 00:23:09
o algo que 00:23:11
es un implement queue. Habrá otros 00:23:12
en el que me interesa una lista, 00:23:15
entonces usaré una relista o un linked list. 00:23:17
Habrá otros en que me interesa 00:23:19
una pila, pues entonces usaré 00:23:21
stack. 00:23:23
depende de mis necesidades 00:23:23
aquí tengo un conjunto de 00:23:26
todas distintas 00:23:28
posibilidades que hacen 00:23:30
cada uno un poquito distinto 00:23:33
las cosas, por ejemplo 00:23:34
quiero usar una lista, puedo usar una linked list 00:23:36
quiero usar una 00:23:39
coda doble 00:23:40
doble final 00:23:42
pues puedo usar una linked list 00:23:44
linked list me vale para las dos cosas 00:23:46
la linked list es muy flexible 00:23:48
de hecho, la doble 00:23:50
la lista doblemente enlazada que hemos implementado nosotros vale pues puede funcionar sea como cola 00:23:52
de doble doble final que como lista que como otras cosas depende de cómo la uso vale si yo 00:24:01
siempre añado de una parte y quito de la otra pues lo que está haciendo es una una cola una 00:24:08
Sí, una cola. Si en vez de pillo como me da la gana es una lista. Si yo añado siempre delante 00:24:13
y pillo siempre delante, estoy implementando una linked list en el que cuando añado, añado en la 00:24:22
cabeza, añado al principio. Y cuando saco, saco desde el principio. Esta es una exacto pila. 00:24:34
muy bien 00:24:49
y luego están los set 00:24:52
los set tienen una diferencia fundamental 00:24:55
con los otros que es que no 00:24:57
permiten 00:24:59
la duplicación 00:25:01
de los datos 00:25:03
en las listas, en las colas 00:25:04
tú puedes añadir más veces 00:25:07
el mismo dato y él dice ok 00:25:09
muy bien, lo añado 00:25:11
en el set, en el conjunto 00:25:12
no se puede añadir dos veces el mismo 00:25:14
elemento, entonces en los set 00:25:17
es muy importante la definición 00:25:19
del igual. Cuando tú 00:25:21
haces un set, tienes que definir 00:25:23
el igual. ¿Vale? Para definir 00:25:25
cuando dos objetos son el mismo objeto 00:25:27
entonces no tiene sentido ponerlo en el mismo 00:25:29
conjunto. ¿Vale? Si vosotros pensáis 00:25:31
al concepto de conjunto 00:25:33
en general, el concepto matemático 00:25:35
vosotros decís el conjunto de los 00:25:37
números naturales. ¿Vale? 00:25:39
El conjunto de los números naturales. Dos 00:25:41
está en el conjunto de números naturales. Tú no 00:25:43
añades tres veces el dos. ¿Cuáles son 00:25:45
los números naturales? Pues 2, 2, 2 y 2. 00:25:47
Pues no, una vez que has dicho 2, 00:25:50
sabes que 2 es parte del conjunto. 00:25:51
¿Sí? No se repiten los elementos. 00:25:53
¿Sí? 00:25:56
Y a partir de aquí 00:25:58
tenemos dos 00:25:59
dos implementaciones 00:26:01
de set, que son la set 00:26:04
y la link de set, ¿vale? 00:26:05
Hablaremos de funcionage, 00:26:07
y qué es una funcionage, y... 00:26:09
Os doblegará la cabeza. 00:26:12
Y también tenemos una 00:26:15
interfaz que es sorted set 00:26:17
o sea set 00:26:20
ordenado 00:26:21
del que deriva el triset 00:26:23
el triset es un set 00:26:26
entonces no puedo meter 00:26:28
dos elementos iguales 00:26:30
dentro de este set 00:26:32
pero cuando añado los elementos 00:26:33
él en automático me los ordena 00:26:35
de la forma que he dicho antes 00:26:38
por lo tanto mis datos están ordenados 00:26:40
dentro de esta estructura 00:26:42
sin que yo haga nada, ya están ordenados 00:26:44
desde el principio 00:26:46
A ver, en el contexto de la seguridad de cifrado y cosas por el estilo, se usan los hash, 00:26:47
no tanto para garantizar seguridad, cuanto para garantizar que lo que tienes es lo que 00:27:09
había. En el sentido que tú puedes 00:27:17
pillar una tira de ceros y unos, ¿vale? Aplicarle 00:27:21
una función hash que sustancialmente te da un resumen, ¿vale? 00:27:25
Es como que cada número es mapeado en otro 00:27:29
número, ¿vale? Más pequeño. Y en 00:27:33
teoría, números parecidos de origen 00:27:37
se mapean en números de destino distintos. 00:27:41
Entonces, tú mandas una cadena de unos y ceros, que al fin y al cabo es un número, 00:27:45
y al final le pegas el hash, o sea, pillo este número y miro a qué número se corresponde, 00:27:52
se le corresponde al número 20 después que he hecho esta función hash, esta función 00:27:59
más. 00:28:03
¿Vale? 00:28:04
Si ahora cuando yo te mando estos datos hay una corrupción, alguien cambia algo y cosas 00:28:05
por el estilo, cuando voy a pillar el mismo número a aplicarle la función hash, en vez 00:28:09
de darme 20, me da 27. Entonces, como el número hash no es el mismo, pues entonces puedo saber que 00:28:14
ha habido un error, que ha habido un cambio. Entonces eso es lo que se suele utilizar la 00:28:21
función hash. Luego, a nivel de cifrado, pues hay otros algoritmos y otros sistemas, que a lo mejor 00:28:27
alguno de esos se basa sobre alguna función hash, pero me parecería raro porque el problema de la 00:28:38
funcional es que hace categorización o sea que números diversos distintos pueden caer en el mismo 00:28:43
el mismo número representante y es como hacer imagínate tú pillas 20 categorías más sencillo 00:28:50
pillas dos categorías y de los números para en la categoría 1 los números imparen en la categoría 2 00:29:00
este es un funcional pero es un funcional entonces el problema que tienes es que 4 y 6 caen en la 00:29:05
misma categoría. Entonces no te permiten ser seguro porque no. Una vez que te digo la misma categoría, 00:29:12
que es pares, que no pones el 1 o es el 0, no lo sé, pues tú no sabes volver a si era 4 o si era 6. 00:29:18
Pero todavía esto es un tema reciente y complejo que veréis en segundo de DAM, 00:29:29
Programación de Servicios y Procesos, en 3DAM. Hacéis DAW segundo y luego después hacéis segundo 00:29:34
de DAM y allí lo veis. En unos seis, ocho años estáis en Roma. 00:29:44
esta es uno de los métodos en que se utilizan otro método es aquí para que sea esta es una 00:29:51
de las set es una de los de las colecciones de las estructuras dinámicas más rápida porque si 00:30:11
haces bien la funcional buscar allí dentro es súper rápido esa si la haces bien bien es a nivel 00:30:19
de una constante de tiempo que está lo que es lo mejor que puedo y dudas todo es un esquema 00:30:28
ahora lo que vamos a hacer es ver cada una de estas a ver qué pasa vale más o menos y no todas 00:30:39
hoy porque entonces que me permite hacer colección fijaros que aquí no hay 00:30:45
implementaciones es una interfaz vale aquí no se dice que se tiene que 00:30:53
implementar aquí se dice bozo este es el contrato tú quieres ser una colección 00:30:57
pues tiene que implementar esto fijaos os recuerda algo 00:31:02
a lo que hemos hecho. 00:31:07
¿Nuestra interfaz? 00:31:09
¡Qué casualidad! 00:31:11
¿No? 00:31:13
Grosso modo, nuestra interfaz 00:31:15
la que hemos hecho nosotros 00:31:17
para hacer nuestra lista 00:31:19
y nuestra lista enlazada, pues tenía 00:31:21
un añademe un elemento, 00:31:23
un dime el tamaño de la colección, 00:31:25
un quita el elemento, 00:31:27
el contains 00:31:29
nosotros lo hemos llamado busca 00:31:31
en un cierto sentido, hemos hecho algo un poquito más, 00:31:33
me diría si está o no. Nosotros hemos ido más allá. Te digo si está o no y te digo dónde está. 00:31:35
Y luego está esto de iterator, que nosotros no hemos visto, pero ¿de dónde saldrá este iterator? 00:31:41
De iterador. 00:31:49
Iterator es un mecanismo para darle un iterador. Un iterador es un bicho que yo le puedo preguntar 00:31:51
hay otro elemento y me dice así si todavía no he recurrido toda la la toda la estructura de datos 00:32:02
vale y me dirá falses y ya he mirado todos los elementos que están allí y además a este le 00:32:13
puede decir dame el siguiente pues yo no sé el cómo se ha organizado pero él ha pillado todos 00:32:20
los elementos, los han metido en un orden 00:32:26
y cada vez que yo le digo, hay otro, 00:32:28
sí, hay otro, dámelo, toma. 00:32:30
Hay otro, sí, hay otro, oh, dámelo. 00:32:32
¿Sí? Con dos métodos que son 00:32:35
next, para darme 00:32:36
el siguiente, y has 00:32:38
next, para preguntarme 00:32:40
si lo tienes o no. ¿Vale? 00:32:42
Entonces, con esto de aquí es un while. 00:32:44
While has next. 00:32:47
Next. 00:32:49
¿Sí? Porque no sé 00:32:51
cuántos son. Bueno. 00:32:52
Podría saberlo, 00:32:54
pero el iterador tiene esta ventaja de, si lo quiero recorrer todo, pues me da igual 00:32:55
cuántos son. Empieza de primero y sigue dándole. 00:33:00
Very well. Interfaces que extienden a collections, ¿vale? Set, que son conjuntos. Los 00:33:05
conjuntos son grupos de elementos en los que no se admiten elementos repetidos, ¿vale? 00:33:14
cómo se comparan los elementos con iguales y con asco vale asco de iguales son amiguitos van juntos 00:33:19
y hay que estar cuidado que tener cuidado porque cuando toco uno tengo que tocar el otro y tienen 00:33:31
que ser y funcionar bien no pueden funcionar como le da la gana vale lo veremos cuando veremos los 00:33:36
set un poquito más en detalle podemos nuestro set o lo que sea pues hablaremos un poquito de 00:33:43
nosotros simplificaremos un poquito estas cosas porque si vosotros miráis en Eclipse donde está 00:33:48
el source que nosotros ya hacemos los constructores allí o hacemos el toString también cuando me dice 00:33:58
hazme el equals en realidad si lo miráis dice hazme el equals el hashCode a la vez porque tiene que ir de la manera 00:34:05
tienen algunas restricciones entre ellos 00:34:11
que no pueden ser como le da la gana 00:34:15
dos 00:34:17
que dan true a equals 00:34:19
tienen necesariamente que dar el mismo 00:34:20
pero dos que dan el mismo 00:34:23
no necesariamente tiene que ser igual 00:34:26
dos y dos 00:34:28
en nuestro ejemplo 00:34:33
son pares 00:34:35
y entonces dos y dos que son iguales 00:34:35
tienen que dar pares igualmente 00:34:39
no pueden ser dos y dos iguales 00:34:40
y luego decir, pero tiene un hashcode distinto, pero si yo tengo el hashcode que representa el número par, 00:34:42
pues 2 y 4, que no son iguales, son pares en uso. 00:34:48
¿Tengo una pregunta? 00:34:57
No, no, no. 00:34:58
List, listas. 00:34:59
Este tipo de colecciones se refiere a listas en las que los elementos de la colección tienen un orden. 00:35:01
Existe una secuencia de elementos, ¿vale? 00:35:08
En ellas, cada elemento está en una determinada posición índice de la lista. 00:35:11
El orden normalmente es un orden de inserción. 00:35:17
O sea, cuando yo uso una lista es que vosotros hacéis la lista de la compra. 00:35:21
La lista de la compra es esto, esto, esto, esto. 00:35:24
Y tenéis un orden de los elementos que habéis puesto. 00:35:27
Cuando vais a repercorrer la lista, soleís querer que si la habéis escrito en este orden, lo leáis en este orden. 00:35:30
Esa es una lista. 00:35:41
Cosa que no pasa en el set. 00:35:42
en el set si yo añado tres elementos y ahora voy con literatura decir devuelve 00:35:46
nuestros tres elementos me lo da en el orden que le da la gama 00:35:50
y este tipo de colecciones a referencia a una lista de elementos que siguen el 00:35:58
patrón piso recién prestado entonces lo mismo en una cola yo me espero que el 00:36:04
orden que se ha mantenido desde la inserción y que se te pido no habrá un 00:36:10
un dame el elemento en posición 3, cosa que puede hacer una lista, sino que yo salga simplemente 00:36:16
un añade o dame, porque el orden con el que se añade, el orden con que se saca, pues 00:36:23
ya está definido. Yo no puedo pillar el elemento que me da la gana. Siempre que inserto lo 00:36:30
tengo que insertar al final, siempre que lo pillo tengo que pillar primero. Y esto está 00:36:36
definido en la propia interfaz. Si vosotros vais al API de Java y buscáis 00:36:43
el senso de las interfaces, cuando vais a la queue y vais a leer el contrato que estáis firmando para 00:36:52
hacer los métodos de la queue, te dirá, oye mira, cuando tú implementas la ADD, lo tienes que 00:36:59
implementar para que funcione así. Si no lo haces, te estás cargando el senso de la queue. Entonces listo, 00:37:03
en la interfaz list 00:37:14
defino su sección de elementos 00:37:16
a diferencia del set 00:37:17
si que se permiten 00:37:19
duplicados, añado dos veces el mismo elemento 00:37:21
que daría true cuando hago 00:37:24
equals, pues añado dos veces el mismo elemento 00:37:25
me da igual, que no quiero la duplicación 00:37:28
pues no uses una list, usa otra cosa 00:37:30
aparte de los métodos 00:37:32
de collection, añade métodos 00:37:35
que permitan mejorar los siguientes puntos 00:37:38
acceso a posicionar los elementos 00:37:40
la colección no permite añadir a entrar en posición 7 de colección están si a los las 00:37:41
que que los set que no tienen posicionalidad no puedes decirme dame el elemento posición 3 00:37:49
la lista así ya que esto de acceder a una cierta posición es de la interfaz list no 00:37:55
de la interfaz colección búsqueda de elementos puedo buscar un elemento que me diga dónde está 00:38:02
Esto lo puede hacer porque es una lista 00:38:10
En otros no tendría sentido 00:38:13
Porque no hay esta posicionalidad 00:38:15
Iteración sobre elementos 00:38:17
Mejora el iterador por defecto 00:38:19
Hay un iterador que viene de iterar 00:38:22
Que está implementado para colecciones 00:38:23
Para buscar cualquier colecciones 00:38:25
En la lista dice 00:38:26
Espera, te doy una implementación 00:38:28
Más orientada a como estoy hecho yo 00:38:29
Para que sea más eficiente 00:38:33
Y rango de operaciones 00:38:34
Permite realizar ciertas operaciones 00:38:37
Pero sobre rangos 00:38:39
En vez de decir, añádeme este elemento, añádeme este elemento, añádeme este elemento, te puede decir, añádeme esta colección de elementos. 00:38:40
Te da una colección de elementos, un array, otra lista, y tú me añades todos estos recorriendo esta lista y añadiendo de uno en uno. 00:38:48
Esta operación es sobre rangos, la añaden a nivel de lista. 00:38:56
Esta es la interfaz list. 00:39:05
Hijos de la interfaz list está array list, linked list y vector. 00:39:06
vale, esto son tres 00:39:10
implementaciones distintas 00:39:13
de list 00:39:15
vale, array list 00:39:17
lo hemos hecho, sabemos que es 00:39:19
es una lista que por debajo 00:39:21
tiene un array 00:39:23
muy útil para acceso 00:39:25
aleatorio, acceder 00:39:27
a posiciones cualquiera de mi 00:39:29
lista con el array list es súper rápido 00:39:31
con la linked list 00:39:33
no, pero cuando tú añades 00:39:35
o quitas en un array list 00:39:37
tienes que hacer todo ese trabajo de pillar el array, extenderlo, copiarlo, doblegarlo, etc. 00:39:39
Por lo tanto, la inserción, el quitar, en la ArrayList. 00:39:45
¿Cuándo se usa la ArrayList? 00:39:50
Cuando tengo muchos datos que cambian poco, pero que se usan mucho. 00:39:51
En una escuela, en septiembre, añado todos los alumnos, pero luego se quedan esos alumnos allí. 00:39:59
Remuevo pocos, pero los uso mucho para ir a mirar sus notas, su horario, su cosa por el estilo. 00:40:05
Pues ArrayList, por ejemplo. 00:40:12
BlinkedList, la hemos hecho, la hemos trabajado. 00:40:16
Tiene esta ventaja, es muy fácil insertar cosas, sobre todo al principio y al final. 00:40:19
Si tengo un puntero al principio y al final, insertar es súper sencillo. 00:40:25
Lo hemos visto, son tres líneas de código. 00:40:28
ahora 00:40:30
buscar algo aquí dentro 00:40:32
o mejor, pillar el elemento 5 00:40:34
es un poco infernal 00:40:37
porque no tengo una forma de llegar 00:40:38
a la posición 5, tengo que entrar 00:40:40
por la cabeza y siguiente, siguiente 00:40:42
siguiente, siguiente, siguiente 00:40:45
por lo tanto puede ser complejo en sitios 00:40:46
en el que cambian 00:40:49
poco los datos y se accede 00:40:51
mucho, o sea que digamos que 00:40:53
de aquí son complementarios 00:40:54
vector 00:40:56
Vector es igual a un ArrayList, muy parecido a un ArrayList. 00:40:58
Lo que cambia es que es ThreadSafe. 00:41:03
¿Y qué quiere decir? 00:41:06
Pues en segundo de DAM, en programación de procesos y servicios, aprenderéis qué quiere decir. 00:41:07
Nosotros trabajamos con un ThreadSol. 00:41:14
¿Vale? 00:41:16
Nosotros lanzamos el... hay un solo hijo del hilo de ejecución. 00:41:17
Lanzamos el main y es instrucción por instrucción por instrucción por instrucción. 00:41:21
¿Vale? 00:41:26
Los programas serios, al lanzarse, crean varios hilos de ejecución que van en paralelo. 00:41:27
Uno en cada nodo, en cada núcleo. 00:41:37
A veces dos en cada núcleo, seis en cada núcleo. 00:41:41
Entonces, cuando no hay un solo hilo de ejecución, pueden pasar problemas serios en la escritura de variables. 00:41:45
porque si yo empiezo a escribir 00:41:53
algo en una variable, en una zona de memoria 00:41:55
empiezo 0, 1, 0 00:41:57
y a mitad de mientras estoy escribiendo 00:41:58
otro hilo de ejecución va en la misma variable 00:42:01
y empieza a escribir 00:42:03
el número que tengo allí 00:42:04
no es ni el que quiere escribir el primer hilo 00:42:07
ni el que el otro, es una mezcla de los dos 00:42:09
esa se llama race condition 00:42:11
y es 00:42:14
mala 00:42:16
por lo tanto 00:42:18
vector me garantiza que si uso multinúcleo o multi hilo pues las operaciones que hago sobre vector 00:42:21
son sincronizadas si yo empiezo a escribir sobre vector bloqueo cualquier otro hilo que intenta 00:42:29
escribir sobre vector y hasta que yo no te diga he acabado pues los otros están ahí esperando como 00:42:37
escribe siempre solo una persona no hay problema el problema es que para garantizar este sistema 00:42:42
es mucho más lejos nosotros que tenemos un hilo sólo usamos arreglist vector no nos interesa 00:42:50
cosa interesante porque está aquí es que desde vector hereda stack a la implementación de la 00:42:55
stack la implementación de la pila en java es una implementación que deriva desde vector 00:43:04
llamó a clase vector cambiamos eso escribimos algunos métodos para que funcione que se ha 00:43:10
empeñado al principio y siempre quito desde el principio y obtengo la stack 00:43:16
tengo la clase vector y stack public stack extends vector 00:43:23
si? dudas? preguntas? 00:43:30
a release! es una presentación típica de las que hemos hecho nosotros se basa en un array dinámico 00:43:36
que aumenta el tamaño según crece la colección de elementos, puede contener elementos duplicados, 00:43:42
permite insertar al final o insertar en una posición concreta, el orden es importante 00:43:48
porque cuando lo recorro voy desde el principio hasta el final, permite el acceso aleatorio, 00:43:55
se puede acceder a la posición 7, la manipulación es lenta porque es necesario realizar muchos 00:44:01
cambios si se elimina algún elemento o sea manipular añadir y quitar es lento acceder 00:44:07
rápido si no está sincronizada o sea no es thread safe los threads aquí hacen caos 00:44:14
picket list es una implementación que se basa sobre lista doblemente enlazada o sea lo que 00:44:23
tenéis que hacer para hoy esa es la implementación que tenéis ya hecha en Java puede contener 00:44:29
de elementos duplicados, permite 00:44:36
insertar al final o en una 00:44:38
posición concreta si yo quiero, ¿vale? 00:44:40
El orden es importante porque cuando la recorro 00:44:42
voy desde el principio hasta el final, o desde 00:44:44
el final hasta el principio. 00:44:46
Esta implementación con respecto a 00:44:48
RELIST mejora la velocidad de monofonación 00:44:50
de los objetos, insertar y remover, ¿vale? 00:44:52
Pero empeora el acceso aleatorio. 00:44:54
Hacer la pasada debe tener que recorrer, 00:44:56
lo hemos dicho ya. No está 00:44:58
sincronizada. Esta de aquí es 00:44:59
guay porque 00:45:02
tiene dentro un montón 00:45:04
de métodos y si yo uso los métodos justos la misma implementación el mismo 00:45:06
objeto linked list puede funcionar como lista puede funcionar como pila puede 00:45:11
funcionar como por qué depende de cómo uso yo los métodos me 00:45:15
funciona de una cosa que es igual por lo que dice 00:45:22
arre list versus linked list cuando uso el otro cuando uso este de aquí vale 00:45:26
este es un array dinámico, de allá el array dinámico que es, 00:45:32
es un array que hace las cosas raras que decimos nosotros, 00:45:35
mientras este es lista doblemente enlazada. 00:45:38
Esto se basa sobre un array, 00:45:40
este de aquí se basa sobre objetos enlazados entre ellos. 00:45:42
¿Hay que subir al baño? 00:45:46
No. 00:45:48
La manipulación con Adrela es lenta, 00:45:49
la manipulación es rápida con LinkedList, 00:45:51
puede actuar como una lista solo, 00:45:55
porque implementa solo listas, 00:45:58
mientras aquí puede actuar como lista, cola, 00:45:59
porque implementa también otras cosas y mejora para almacenar y acceder a datos 00:46:02
y mejora para vincular los datos. ¿Vale? Mismas cosas. El FAQ, la vemos la próxima. 00:46:08
Dame tres minutos más y os doy un poquito de pausa porque quiero ver y que quede 00:46:15
grabado esto a vi con la acción de este colección desde collection all known 00:46:22
implement y clases podemos encontrar 00:46:43
Estas son clases, esta de aquí, listo, listo, luego está Q y cosas por el estilo, ¿vale? 00:46:48
Y Sep, ¿veis? 00:46:58
Entonces, esta collection en general, si os fijáis collection tiene añadir, añadir 00:47:00
toda una colección, limpiar la colección, ver, oye por favor, ver si este objeto es 00:47:07
contenido de la conexión iterar sobre la conexión borrar un elemento tamaño de la 00:47:16
colección vale son cosas muy genéricas si me voy a una list la lista hereda vale implementa perdón 00:47:24
la collection es iterable, es un interfaz también, estas son superinterfaces 00:47:35
y aquí añade algunas cosillas como esto lo veis que esto está aquí pero no está aquí 00:47:44
veis que la add aquí es sólo añádenme el elemento donde, ni idea, pero la lista añade 00:47:54
un añade un elemento en el índice index para insertarla en una posición de la 00:48:02
lista pero mantiene también mañana donde 00:48:09
quieres tú tiene al césped que hará de 6 00:48:12
insertarlo al principio atlas a la final vale que te las de un índice cualquiera 00:48:19
Vale, cosa por el estilo. Veis que añade algunas cosillas más. Bórrame un índice concreto, 00:48:28
bórreme un objeto, quita el primero, quita el último. Replace, vale, cámbiame. No sé cómo se 00:48:35
utilizará. Size, etcétera. Fijaos que están también cosas guay como devuélveme esta lista 00:48:45
como un array. Y ahora, esperad un segundo, aquí en la ImplementingClass debería estar 00:48:54
ArrayList y LinkedList. ArrayList es la que hemos hecho nosotros e implementa las de list. 00:49:08
Ok, fenomenal. Si vais a LinkedList en vez, LinkedList implementa además de lista, también det y también queue. 00:49:18
Entonces tiene también los métodos para hacer una cola o una lista. 00:49:32
Y si os fijáis aquí, aquí por ejemplo está la pick, la pull, la pop, la push. 00:49:36
Estas son las clásicas funciones que se usan en una cola, en una pila, ¿vale? 00:49:44
Por ejemplo, la pop y la push. La pop es un insertar en la pila, perdón, la push es un insertar en la pila y la pop es un remover en la pila, ¿vale? 00:49:52
Que pero te hacen el efecto de, te lo añaden y last in, first out, ¿sí? 00:50:03
pero si tú te pillas una una link una linked list y luego en vez de hacer la 00:50:08
add y usar la add y remove usa solo pop e push pues la estás utilizando como si fuera una 00:50:14
stack y porque te da la posibilidad de hacerlo una relist la pop e la push no la tiene 00:50:22
entonces no la puedes usar la podrías usarse pero tienes que hacer más atención que como 00:50:28
O sea, aquí ya te dan los métodos para poderlo utilizar, ya pensado por ellos, aquí tú lo tienes que currar tú. 00:50:34
Entonces, dependiendo de qué estructura queréis hacer, pues con una u otra. 00:50:42
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Autor/es:
Stefano Chiesa
Subido por:
Stefano C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
1
Fecha:
6 de febrero de 2026 - 13:53
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
50′ 53″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
426.94 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid