Saltar navegación

20260203 JerarquiaCollection - 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 7 de febrero de 2026 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues eso, como tengáis ya mucho río en la cabeza, dejo planteado este problema que hemos identificado, ¿verdad? Hemos identificado que el que ha hecho las pruebas del remove ha visto que tanto la posición 0 como la 1 las trata igual. En ambos casos borra la segunda de todas, ¿no? 00:00:00
Es decir, me da igual que yo le dé la 0 00:00:21
O que le dé la 1 00:00:40
Cuando le doy la 1 está claro, me borra Dios 00:00:41
Pero cuando le doy la 0 00:00:43
También me borra la segunda 00:00:45
Eso es lo que ha visto el de pruebas que funciona 00:00:47
Está chiquito 00:00:49
Error 00:00:53
De funcionamiento 00:00:59
Que hemos detectado 00:01:01
Cuando le damos 00:01:03
La posición 00:01:09
borra la 1 00:01:15
en vez de la 0 00:01:19
cuando le damos la 1, bien, borra la 1 00:01:20
cuando le damos la 2, borra la 2 00:01:23
para todas borra la correcta, pero cuando le damos la 0 00:01:24
borra la 1 00:01:27
a ver, tiene sentido también 00:01:29
porque cuando le estamos dando la 0 00:01:33
el bucle no se ejecuta nunca 00:01:35
y lo que está haciendo es esta sentencia 00:01:37
también, luego está haciendo lo mismo 00:01:41
para la 0 que para la 1 00:01:43
con lo cual efectivamente 00:01:44
vale, pues lo que yo os planteo 00:01:46
ahora es que 00:01:48
lo arregléis 00:01:49
hay una opción muy fácil que es tratar de forma especial 00:01:50
el caso 0 00:01:54
si posición es igual a 0 00:01:54
pues cambiáis inicio 00:01:57
inicio igual a inicio punto siguiente y ya está 00:01:59
¿verdad? bueno, ahí lo dejo planteo 00:02:02
arreglar 00:02:13
ala, pero vamos 00:02:14
es distinguir el caso y hacer la sentencia que sea 00:02:19
no tiene más 00:02:21
vale, el proyecto lo subo ahora 00:02:22
para que se te oiga como se ha quedado 00:02:25
Vale 00:02:27
Bueno, pues 00:02:30
Vamos a descansar un poco 00:02:40
Vamos a descansar un poco 00:02:45
Oyendo cosas un poco más ligeras 00:02:50
Más live 00:02:51
¿Vale? 00:02:52
Vamos a descansar un poquito 00:03:00
Vale 00:03:04
Bueno 00:03:14
Ya lo revisas, retócalo 00:03:16
Ahora que ya tienes el código más sencillo 00:03:19
Yo creo que podrás encontrarlo 00:03:22
Y si no, mañana lo dejamos arreglado 00:03:22
Venga, a ver 00:03:24
Bueno, pues estas dos clases 00:03:30
Que hemos visto 00:03:34
Son dos ejemplos estupendísimos 00:03:35
De clases que me permiten 00:03:38
A mí hacer aquí 00:03:40
Mi cajita 00:03:41
para meter un montón de cosas 00:03:43
y añadir 00:03:45
cada vez que quiera yo añado con el add 00:03:47
y me olvido de como lo haga por dentro 00:03:49
sé que eso se queda ahí metido 00:03:52
y puedo eliminar con el remove 00:03:53
me da igual como lo haga por dentro 00:03:56
sé que eso desaparece de la colección 00:03:57
y puedo recorrer 00:04:00
y recuperar con un get 00:04:01
bueno pues 00:04:03
estas clases que hemos hecho ya están 00:04:05
hechas con algunos 00:04:08
más pulidas, con más métodos 00:04:09
para poder hacer más cosas con ellas. 00:04:12
Ya están más pulidas, ¿vale? 00:04:14
Estas dos que hemos hecho. 00:04:16
Y son las que se llaman ArrayList, 00:04:18
que tiene un array por dentro y funciona 00:04:21
como el ArrayList nuestro y LinkedList, 00:04:24
que es una lista enlazada por dentro. 00:04:31
Es un poquito más complicada que la lista enlazada nuestra 00:04:34
porque es doblemente enlazada, 00:04:37
lo que permite que los recorridos sean más rápidos. 00:04:39
vale, tienen enlace 00:04:41
la mano, se la doy a todos 00:04:44
entonces puedo navegar para un lado, puedo navegar para otro 00:04:45
entonces es un poquito más 00:04:47
pero la idea es la misma 00:04:48
vale, la idea es la misma 00:04:50
vale, pues entonces 00:04:52
no son las únicas clases que hay 00:04:54
para meter datos, ya lo dijimos el otro día 00:04:57
hay otras más 00:04:59
y todas ellas 00:05:01
forman 00:05:03
lo que se llaman las colecciones 00:05:04
vale 00:05:07
entonces 00:05:11
Entonces, esto no son un montón de clases así a mogollón, afortunadamente, no son un montón de clases a mogollón, porque el que diseña ya cosas para Java, pues el que hizo el paquete colecciones, pues ya las diseñó con una arquitectura de herencia e interfaces para facilitarnos su uso. 00:05:13
No se puso a hacer clases sueltas, deslavazadas. No, hizo una jerarquía donde algunas se daban de otras, se podían reutilizar cosas. Eso me facilitaba a mí en un momento dado, pues cambiar de implementación porque ambas implementaba la misma interfaz. 00:05:31
Es decir, las clases colecciones entre las cuales están estas dos y más como el Haset, el Triset, pues las que veremos, las clases colección no están hechas así cada una por libro. Están metidas dentro de una jerarquía que me va a facilitar ahora ya su uso y su manejo. 00:05:50
Pues ¿cuál es la jerarquía de colecciones? 00:06:10
Vamos a buscar un dibujito bono. 00:06:14
Venga. 00:06:21
¿Qué hago yo? Estoy tonta. 00:06:30
Venga, a ver. 00:06:35
Vamos a poner. 00:06:40
Jerarquía. 00:06:44
Colecciones en Java 00:06:45
Ya me lo ofrece 00:06:50
Yo quiero un dibujito 00:06:51
Para que las veamos 00:06:54
Venga 00:06:59
Este me gusta, este dibujito 00:07:00
Pues no lo veo bien, confío en que 00:07:03
Este sí, que esté bien 00:07:05
Vale, vamos a confiar que esté bien 00:07:06
Bueno, para que os hagáis una idea 00:07:08
No es que la vayamos a destipar en detalle 00:07:19
Para, pero para ilustrar 00:07:21
Para que os hagáis una idea de que 00:07:23
Todas las herramientas que están desarrolladas 00:07:25
en Java están metidas 00:07:27
en una arquitectura de herencia de interfaces 00:07:29
porque eso es lo que las hace más operativas 00:07:31
pues entre ellas mis colecciones 00:07:33
vale, pues hay una 00:07:35
interfaz por ahí arriba de todo 00:07:37
ya sabemos lo que es una interfaz 00:07:39
por ahí que es 00:07:41
iterable, que no tiene todavía 00:07:43
nada dentro 00:07:45
y todas estas colecciones 00:07:46
que están aquí debajo, que pena que esto no se pueda 00:07:49
mover, todas ellas 00:07:51
cuelgan 00:07:53
de iterable 00:07:55
cuelgan 00:07:57
¿eso qué significa? 00:07:58
que sobre todas ellas vamos a poder iterar 00:08:00
obligatoriamente todas 00:08:03
tienen que permitir que 00:08:05
iteremos por ellas 00:08:07
iterable les da a todas 00:08:08
las colecciones con las que vamos a trabajar 00:08:11
les da a todas 00:08:13
el rol de poder 00:08:15
ser iteradas a través de 00:08:17
un objeto iterador, como ya veremos 00:08:19
porque uno puede recorrer 00:08:21
una colección con un for, como hemos hecho nosotros 00:08:23
con un for 00:08:25
y luego cada elemento 00:08:27
con el get sacarlo 00:08:29
pero también se puede 00:08:30
recorrer mediante un objeto un poco 00:08:33
más complejo que es un iterador 00:08:35
que me permite hacer cosas 00:08:37
un poquito más chulas, a lo mejor 00:08:39
o proteger ciertos recursos 00:08:41
bueno, pues todas las colecciones 00:08:44
que están hechas 00:08:46
obligatoriamente 00:08:47
implementan esta interfaz, con lo cual 00:08:49
tienen ese rol, el de poder ser 00:08:51
iteradas por un iterador, ya veremos cómo 00:08:53
vale 00:08:55
bueno, pues 00:08:57
iterable es la superinterfaz que todavía 00:08:58
no tiene nada, solamente tiene el rol de poder 00:09:01
ser iterables 00:09:03
pues de iterable, tenemos otra 00:09:04
colección por debajo que la implementa 00:09:07
otra interfaz 00:09:10
perdón, que la implementa, vale 00:09:11
que sigue siendo abstracta 00:09:13
completamente, vale 00:09:15
aquí cuando dice 00:09:17
interface, no sé, podría 00:09:18
ser clase abstracta también, vale 00:09:21
es decir, algo que no puedo instanciar todavía 00:09:23
bueno, pues collection 00:09:25
es otra clase abstracta 00:09:27
interfaz 00:09:29
que es 00:09:30
iterable y añade 00:09:33
la posibilidad de meter cosas y borrar 00:09:35
hace muy poco más añadir 00:09:37
pues todas las colecciones 00:09:39
todas 00:09:41
en el ande collection, todas, con lo cual 00:09:42
todas las que hagamos, ArrayList 00:09:45
PriorityQueue, HashSet 00:09:47
todas las que hay ahí en amarillito, ahí abajo 00:09:49
todas ellas 00:09:51
al heredar de colección, todas ellas 00:09:53
tienen que implementar los métodos 00:09:55
de colección, que los métodos de colección son 00:09:58
nada 00:09:59
vamos a ver cuáles son los métodos de colección 00:10:00
son nada, vamos a 00:10:03
poner aquí para verlo rápidamente 00:10:07
ahora lo borro, colección 00:10:09
vale 00:10:15
vale, colección 00:10:15
de java útil 00:10:25
estamos en el paquete java útil, no olvidéis 00:10:26
vale, pues una 00:10:28
colección, ¿qué puede hacer? 00:10:30
una colección, veis que poquita 00:10:32
cosa puede hacer 00:10:35
una colección me ofrece 00:10:35
estos métodos de aquí 00:10:48
recordad, esto no se 00:10:49
implementa, esto es una clase 00:10:52
abstracta, con métodos 00:10:54
vacíos, pero el que herede de 00:10:56
mí, tiene que implementar 00:10:58
estos, añadir un objeto 00:11:00
nuevo a la colección 00:11:02
añadir un mogollón de objetos 00:11:03
enteros 00:11:06
que a su vez están metidos en la colección 00:11:08
limpiarla enterita 00:11:09
limpiarla entera 00:11:11
ver si la colección contiene 00:11:12
un objeto igualito 00:11:15
a uno que yo le dé 00:11:16
ver si una colección 00:11:18
contiene todos los objetos 00:11:21
igualitos a una colección 00:11:23
que yo le pase por aquí 00:11:25
ya está 00:11:26
cualquier cosa que herede de colección 00:11:28
tiene que implementar estos métodos 00:11:31
que son poquitos 00:11:33
borrar, bórrame 00:11:34
un objeto de la colección 00:11:36
que sea igual a este 00:11:39
luego colección es una clase abstracta 00:11:41
y todas las colecciones 00:11:44
Hachette, Arraylis 00:11:46
todas heredan de colección 00:11:48
luego todas 00:11:50
tienen que implementar estos métodos 00:11:51
pero son nada, los básicos 00:11:54
añadir, borrar 00:11:56
un objeto que sea igual al que yo te doy 00:11:58
como veis aquí no hay un 00:12:00
borrar por posición 00:12:02
porque no todas las colecciones tienen posición 00:12:03
no todas, luego no tiene sentido 00:12:06
que en colección yo borre por posición 00:12:08
porque habrá colecciones que no tengan posición 00:12:10
borro por igualdad 00:12:12
doy un objeto, bórrame uno que sea igualito 00:12:14
que este, igualito 00:12:16
vale, pues ya está 00:12:17
bueno, pues esta es colección, que ya empezamos a bajar 00:12:19
en la jerarquía 00:12:22
vale 00:12:23
ahora 00:12:25
las colecciones en general 00:12:30
ya dijimos que hay de dos tipos 00:12:33
listas 00:12:35
y conjuntos 00:12:37
list y set 00:12:39
vale 00:12:41
Y las colas, que en realidad son como una lista, pero esta la dejamos un poco para el final. Son como una lista que te ofrecen métodos específicos de las colas y las pilas de toda la vida. Pero bueno, este concepto lo dejamos ahora para el final. Por ahora nos olvidamos de la parte de Q, nos olvidamos. 00:12:42
las colecciones en general 00:13:03
o son listas 00:13:07
o son conjuntos 00:13:09
¿cuál es la diferencia 00:13:11
entre que sean listas y sean conjuntos? 00:13:13
es lo que dijimos el otro día 00:13:16
una lista 00:13:17
en los elementos que están en ella 00:13:19
tienen una posición asociada 00:13:21
el que está en una lista está en una posición 00:13:23
sea la 0, la 1, la 2 00:13:26
en nuestras listas 00:13:27
que hemos hecho eran listas 00:13:30
porque tienen una posición asociada 00:13:32
Y yo podía recuperar por posición, por eso hacía get posición, podía añadir al principio, al final, porque la posición cuenta. En un conjunto no hay posición asociada, lo que se añade, se añade, no hay ninguna posición. 00:13:33
Vale, pues aquí de nuevo hay dos clases abstractas o interfaces que siguen sin implementar los métodos de collection, siguen sin implementarlas, pero añaden métodos específicos para lo que sea que queramos que sea lista y para lo que sea que queramos que sea set. 00:13:48
Por ejemplo, list añade los métodos específicos de recuperar por posición. Ese método en colección no tiene sentido que esté porque en una colección en general no tienes por qué recuperar por posición porque puede que no haya posiciones. Pero en list ya sí, ya se añade ese. 00:14:09
De hecho, si ahora en lugar de collection declaro esto como list, ahora este objeto mío lista tiene métodos que no tenía collection, que están relacionados con la posición. 00:14:25
veis 00:14:55
este tiene un método del tipo 00:15:08
añádeme este objeto 00:15:10
en esta posición 00:15:12
vale, tiene una versión de add para añadir 00:15:13
una posición concreta, que no la hemos hecho nosotros 00:15:16
pero la podríamos haber hecho 00:15:18
tiene añadir al principio 00:15:19
porque aquí las posiciones sí cuentan 00:15:22
tiene añadir al final 00:15:24
tiene 00:15:26
recuperar por posición 00:15:29
que colección no tenía 00:15:35
porque ahí no hay posición que valga 00:15:37
tiene recuperar el primero 00:15:39
recuperar el último 00:15:41
tiene 00:15:43
darme la posición en la que está 00:15:44
un objeto igual a este 00:15:47
tiene métodos relacionados con la posición 00:15:48
luego list 00:15:51
list 00:15:53
es también una clase abstracta 00:15:59
pero que me añade métodos 00:16:01
relacionados con 00:16:03
trabajar con posiciones 00:16:06
y set sin embargo 00:16:07
no me los añade 00:16:10
¿Vale? 00:16:11
Ahora ya 00:16:13
De list y de set 00:16:14
Ahora ya 00:16:15
Hay implementaciones concretas 00:16:17
Que ya se pueden instanciar 00:16:19
¿Vale? 00:16:21
Pues ArrayList 00:16:23
Es una de ellas 00:16:23
Y ArrayList es como nuestro 00:16:25
MiArrayList 00:16:27
Con todos los métodos 00:16:28
Para poner 00:16:29
Poner en una posición 00:16:30
Recuperar por posición 00:16:31
Y ya está 00:16:32
Y LinkedInList 00:16:33
Es otra implementación 00:16:35
Como las que hemos hecho nosotros 00:16:36
Pues parecidas 00:16:40
dos implementaciones distintas 00:16:41
que ya sí que se pueden instanciar 00:16:43
la interfaz list 00:16:44
que a su vez era de 00:16:45
collective 00:16:46
que a su vez de iterable 00:16:47
vale 00:16:48
y set 00:16:49
pues tiene 00:16:51
tres implementaciones básicas 00:16:53
estas dos 00:16:57
esto debería ser una h 00:17:00
donde pone una t es una h 00:17:02
vale 00:17:04
estas dos 00:17:05
que ya veremos en qué se diferencian 00:17:06
y cómo están hechas por dentro 00:17:08
dos implementaciones de set 00:17:10
Y luego hay una interfaz de set que añade métodos relacionados con conjuntos que admitan orden. Admitir orden no significa que se caractericen por posición, es otra cosa distinta. Conjuntos que admiten un criterio de orden entre sí. 00:17:12
son un conjunto de 00:17:29
o sea, un tipo de conjunto especial 00:17:32
es el conjunto en el que admite orden. 00:17:36
Pues esta interfaz 00:17:39
incorpora métodos relacionados con el orden 00:17:40
y esta interfaz tiene su propia implementación 00:17:43
que es el tríceps. 00:17:46
¿Vale? 00:17:49
Luego, las tres implementaciones de conjunto 00:17:50
hashed, linked hashed y tríceps. 00:17:53
Las dos de listas 00:17:56
ArrayList, que falta una R, y LinkedList 00:17:58
y está él en minúscula 00:18:00
y Sorter 00:18:05
no es una R ahí, es una D 00:18:06
vamos, el que ha hecho este dibujito 00:18:08
se ha lucido, ¿no? 00:18:11
Ratas, ha metido un montón 00:18:12
¿Eso de qué? 00:18:14
Es de la generación Z, seguro 00:18:16
¿A raíz de qué? 00:18:18
Vale, entonces 00:18:22
Vector y Stack 00:18:23
eran las primeras colecciones 00:18:25
que había ya en el pasado, hace siglos 00:18:27
todavía se conservan un poquito como código 00:18:29
legado que se llama, que es 00:18:32
hay código que se ha sustituido, clases 00:18:34
cosas que se han sustituido por código nuevo 00:18:36
pero dejamos las viejas 00:18:38
por si hay proyectos 00:18:40
que usan esas clases antiguas 00:18:42
no craquen de golpe 00:18:43
pues Vector y Stack son 00:18:45
las dos primeras implementaciones de colecciones 00:18:47
que había muy viejunas 00:18:50
pero ahí siguen y uno las puede seguir utilizando 00:18:52
y ArrayDQ 00:18:54
y PriorityQ 00:18:56
son dos implementaciones 00:18:58
que son listas enlazadas también. 00:19:01
Son listas enlazadas, en realidad. 00:19:03
Pero admiten métodos específicos 00:19:05
relacionados con colas. 00:19:07
Pero eso es lo que he dicho, que ese concepto 00:19:09
lo dejamos un poquito para el final. 00:19:11
Ahora vamos a centrarnos en las listas 00:19:12
y los conjuntos. En particular, 00:19:14
ArrayList, LinkedList, y Hashet, 00:19:17
LinkedHashet y Triset. 00:19:19
Se nos faltan muy bien esos tres. 00:19:21
Hashet, Linset... 00:19:23
Sí. Bueno, y ver un poquito más de cómo se usan 00:19:25
las listas, porque hemos hecho nuestra propia lista para entender 00:19:27
cómo se usa, para entender cómo está 00:19:29
hecha por dentro. Pero bueno, 00:19:31
los detalles de uso de 00:19:33
esto no es trivial tampoco. 00:19:35
Y luego esto en particular tenemos 00:19:38
que ver un poquito, pues, cómo está hecho por dentro 00:19:39
sin programarlo nosotros. 00:19:41
Y también los detalles de uso tampoco son triviales. 00:19:43
¿Vale? 00:19:46
Vale, venga, pues, 00:19:48
si queréis nos vamos. 00:19:49
Solo si queréis. 00:19:54
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
1
Fecha:
7 de febrero de 2026 - 18:49
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
19′ 55″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
209.06 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid