Saltar navegación

20260211 Colecciones_Set_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 15 de febrero de 2026 por Raquel G.

1 visualizaciones

Más información Transcripción

Descargar la transcripción

Tenemos dos tipos, listas y colecciones. De las listas conocemos prácticamente todos los pormenores, ¿vale? De las listas ya no nos pillan en ningún lado, conocemos todos los pormenores, salvo su uso como streams, pero eso ya se queda ya aparcado para cuando tengamos más capacidad para hacerlo. 00:00:00
bueno, pues además de las listas 00:00:19
tenemos los conjuntos 00:00:21
los conjuntos están implementados 00:00:23
de otra manera por dentro 00:00:25
ya irán surgiendo los detalles 00:00:26
y ya lo podemos ir viendo, ahora no os voy a contar todo ese rollo 00:00:29
de cómo están implementados por dentro 00:00:31
entonces los conjuntos son los set 00:00:33
y valen también para guardar cosas 00:00:36
por ejemplo, yo quiero 00:00:37
un conjunto de nombres 00:00:39
pues puedo declarar 00:00:41
mi conjunto de nombres tranquilamente 00:00:43
así 00:00:45
set stream 00:00:46
vale, y set 00:00:49
es de java útil 00:00:55
igual que 00:00:56
igual que collecten 00:01:00
igual que list que todos, vale 00:01:03
entonces set es la interfaz 00:01:04
la clase abstracta como lo era list 00:01:07
yo cuando ya 00:01:09
instancie el conjunto 00:01:11
tengo que elegir alguna 00:01:12
implementación 00:01:15
entonces hay tres implementaciones 00:01:16
de set 00:01:19
vale, entonces 00:01:19
las implementaciones serían 00:01:22
has set 00:01:25
conjuntos 00:01:31
linked has set 00:01:36
triset 00:01:42
solo un pelinín por encima 00:01:42
ver en que 00:01:59
están basadas por dentro 00:02:01
en que están basadas 00:02:02
listas y conjuntos 00:02:04
el set entra en el examen 00:02:08
pero no sufráis 00:02:11
Vale 00:02:15
¿En el examen no vas a poder hacer 00:02:19
Como crear nuestro propio 00:02:21
My LinkedIn List? 00:02:23
Solo usarlos, ¿vale? 00:02:25
Ha sido mejor la respuesta 00:02:30
Vale, pues entonces 00:02:31
Bueno 00:02:37
No raya 00:02:38
Vale, pues 00:02:40
Hashef 00:02:47
¿Sobre qué idea está basado? 00:02:50
No lo vamos a implementar nosotros porque es un poco lío, pero sí podemos entender sobre qué idea está basado. 00:02:54
Vale, pues está basado sobre el concepto de tabla hash, que repito, es una idea que vamos a darme por encima. 00:03:01
entonces la tabla 00:03:11
el concepto de las tablas hash 00:03:13
son tablas de códigos 00:03:15
códigos sencillos 00:03:17
que están pensados 00:03:21
para asociarse 00:03:26
a cosas 00:03:27
a cosas un poquito ya más complejas 00:03:29
¿vale? 00:03:32
entonces 00:03:35
la función de hash 00:03:36
lo que hace es 00:03:38
transformar 00:03:39
esa cosa compleja que tiene un montón de datos 00:03:41
esa cosa compleja, la transforma en un código hash, ¿vale? Esto sería una función hash, ¿vale? La transforma en un código hash, ¿vale? Entonces, de alguna manera, esto habilita la posibilidad de hacer ciertas cosas con estos objetos de forma más sencilla gracias a que los tengo transformados en códigos, ¿no? 00:03:46
cosas como por ejemplo 00:04:11
voy a localizar 00:04:13
uno de estos elementos más rápido 00:04:15
pues si tú consigues 00:04:17
el código hash de ese elemento 00:04:19
a través del código 00:04:21
ah, está aquí, pues el elemento está aquí 00:04:22
son ideas 00:04:25
entonces un montón de información 00:04:26
la puedes agrupar 00:04:31
en una serie de códigos 00:04:33
y eso te permite pues trabajar con ellos 00:04:34
para algunas cosas de forma más sencilla 00:04:37
¿Vale? 00:04:39
Bueno, pues entonces 00:04:42
El haset está basado en esto 00:04:43
¿Para qué sirve el haset? 00:04:45
Para guardar un montón de objetos 00:04:47
Eso como siempre, hasta ahí no hemos cambiado 00:04:49
¿Vale? 00:04:51
Para guardar un montón de objetos 00:04:52
Pues yo aquí tengo 00:04:54
Mis objetos 00:04:59
Entonces 00:05:02
Por otro lado, ¿cuál es la estructura más eficiente que hay? 00:05:05
El array 00:05:10
Bueno, pues entonces 00:05:10
El haset se basa en que tenemos aquí 00:05:12
un array y el array 00:05:15
es cada uno de los 00:05:20
códigos hash de estos 00:05:22
elementos, el array es 00:05:24
cada uno de los códigos hash de estos elementos 00:05:25
que estos sí que ya son los objetos 00:05:27
los objetos que van a ir 00:05:29
en el hash set 00:05:31
entonces para usar el hash set 00:05:32
lo primero que tenemos que saber 00:05:35
es que estas clases 00:05:37
tienen que tener implementada 00:05:39
la famosa función hash code 00:05:41
que nos ha parecido a veces 00:05:43
cuando hemos implementado el equals 00:05:45
nos aparecía el hashCode 00:05:48
¿vale? pues entonces 00:05:49
esa función hashCode que el clip se me da 00:05:51
una implementación por defecto 00:05:53
que está bien y es la que normalmente cogemos 00:05:55
esa implementación 00:05:58
hashCode me permite llevar 00:05:59
de un objeto al código 00:06:01
correspondiente suyo 00:06:05
¿vale? que se coloca en un array 00:06:06
que se coloca en un array 00:06:08
¿vale? entonces 00:06:10
¿qué ocurre? 00:06:12
que 00:06:15
el array tampoco puede tener un tamaño 00:06:16
enorme, entonces si van aumentando 00:06:19
los objetos, van aumentando los objetos, van aumentando los objetos 00:06:21
digo, jolín, es que 00:06:23
¿por qué es tan eficiente esto si no estamos ganando 00:06:24
tampoco nada? porque el hash set por debajo 00:06:27
tendrá que gestionar el 00:06:29
array de códigos, ¿verdad? 00:06:30
para ver si un objeto es igual a otro 00:06:32
pues el hash set por debajo internamente 00:06:34
mira a ver si los códigos 00:06:37
de hash son iguales, que le va a ser mucho más fácil 00:06:38
ver si los dos códigos de hash son iguales 00:06:41
que ver si los dos objetos son iguales 00:06:43
La tabla de hash optimiza sobre todo esto. 00:06:45
Tengo que ver, pues eso, ¿son diferentes? 00:06:49
Pues voy a ver si los códigos de hash son distintos. 00:06:51
Me es mucho más rápido hacer la igualdad entre dos códigos que entre dos objetos. 00:06:54
En eso se basa el hasher. 00:07:00
Él gracias a esta función lo transforma internamente en un código 00:07:02
y ese código le facilita la manipulación de muchas de las acciones. 00:07:05
Vale, pero efectivamente, si aquí empezara a haber un montón de objetos, 00:07:09
un montón de objetos 00:07:14
pues la tabla de hash tendría que ir creciendo 00:07:16
hombre, esto no tiene mucho sentido 00:07:18
precisamente los arrays son pesados 00:07:20
de manejar, son poco manejables 00:07:22
bueno, pues esta estructura hash set 00:07:24
por debajo 00:07:26
lo que se basa es 00:07:27
yo voy a limitar el tamaño de mi tabla 00:07:30
de códigos hash, la voy a limitar 00:07:32
a por ejemplo 00:07:35
este tamaño 00:07:37
este tamaño 00:07:38
y ahora ya, que el hash set siga aumentando 00:07:39
No pasa nada, pues una vez que he desbordado la tabla 00:07:43
Y ya no me caben más objetos colgando de la tabla 00:07:48
Pues se van a ir a través de una lista enlazada 00:07:50
Entonces mi tabla de códigos has, a lo mejor tiene cuatro códigos 00:07:56
Vale, y los objetos están así 00:07:59
Aquí a lo mejor hay tres 00:08:01
Aquí hay otros tres 00:08:06
Y aquí hay dos 00:08:11
¿vale? entonces tengo en mi hash set 00:08:13
tengo seis objetos 00:08:15
estos tres, estos tres 00:08:16
y estos dos 00:08:19
que salen de ahí, entonces el hash set trata de 00:08:21
combinar la potencia 00:08:23
de un array 00:08:25
con la eficiencia de una lista enlazada 00:08:25
por dentro son las dos cosas 00:08:29
una pequeña tablita manejable 00:08:30
una pequeña tablita de códigos hash 00:08:33
y a partir de ahí 00:08:35
cada uno de ellos me puede llevar a un objeto 00:08:36
o me puede llevar a una lista enlazada 00:08:39
depende de si me han llegado 00:08:41
a desbordar ya los objetos y tengo muchos 00:08:43
pues todos los tengo que ir acoplando 00:08:44
¿vale? pero todo eso se hace por debajo 00:08:46
a nosotros todo eso 00:08:49
no nos importa como lo hace 00:08:50
solo nos importa 00:08:52
que necesita el hashed para 00:08:54
funcionar, para poder hacer 00:08:56
esta historia, pues para 00:08:59
poder hacer esta historia el hashed lo que significa 00:09:01
repito, que los 00:09:03
objetos que van a formar parte de él 00:09:04
tengan el hashcode implementado 00:09:06
y no solo el hashcode 00:09:09
sino que tengan el equals 00:09:13
¿por qué? porque a través del 00:09:15
hashCode tú puedes llegar aquí 00:09:19
pero si hay varios colgando 00:09:20
de aquí, ¿cuál es 00:09:23
cada uno? ¿cómo encuentra el hashSet a cuál te 00:09:25
refieres? pues una vez que ha hecho el hashCode 00:09:27
y ha llegado aquí, él ya va haciendo 00:09:29
el equals a continuación 00:09:31
hasta que encuentre el objeto con el que tú quieres 00:09:32
trabajar 00:09:35
luego para trabajar con un hashSet 00:09:35
y que su funcionamiento sea el esperable 00:09:39
en la clase a la que 00:09:41
pertenecen los objetos del hashSet 00:09:43
tienen que estar implementados 00:09:45
estos dos métodos 00:09:47
por ahora, con quedarnos con eso es suficiente 00:09:49
si no están implementados 00:09:52
no puedo trabajar con un haset 00:09:54
sí, pero es que entonces esa clase 00:09:55
se va a quedar con la implementación de object 00:09:57
como ya sabemos 00:09:59
y la implementación de object 00:10:00
de hashCode e equals 00:10:03
lo que me haría 00:10:05
sería 00:10:07
que todos los objetos fueran 00:10:08
distintos, porque me haría la igualdad 00:10:11
por dirección de memoria, como ya sabemos 00:10:14
entonces sería un uso del hash set 00:10:15
absolutamente poco 00:10:18
eficiente, porque consideraría 00:10:19
cada objeto 00:10:22
distinto, tendría una 00:10:23
tabla inmensa de códigos hash 00:10:26
cada un objeto distinto por dirección de memoria 00:10:27
pues no 00:10:30
nosotros no queremos eso 00:10:30
queremos precisamente los set 00:10:33
para evitar duplicados, es decir 00:10:35
para no poder meter dos objetos iguales 00:10:37
si yo no implemento hash code 00:10:39
e equals, para java 00:10:41
Nunca jamás dos objetos van a ser iguales 00:10:43
A menos que esté uno encima del otro 00:10:46
Porque se va a ir a ir encima de memoria 00:10:48
Entonces esto deja de tener su sentido semántico 00:10:49
¿Vale? 00:10:53
Me convierto yo ahí en una tabla 00:10:54
Has enorme con un montón de objetos distintos 00:10:55
Pues que sentido tiene esto 00:10:58
Bueno esta es la idea por debajo 00:11:00
Que ahora mismo no quería meterme en rollo en historias 00:11:02
Vamos a ver el uso 00:11:04
Y las implicaciones de que por debajo sea así el haset 00:11:05
Pues 00:11:08
Esperamos a cambiar esto primero 00:11:09
vale, pues venga 00:11:13
vamos a meter nombres 00:11:30
en resumen 00:11:32
los conjuntos, lo que más nos importa 00:11:36
más que la implementación interna 00:11:38
lo que nos importa es, como vamos a ver ahora en el ejemplo 00:11:39
que en los conjuntos 00:11:42
no puedes meter elementos duplicados 00:11:43
¿vale? 00:11:46
vamos a verlo ahora 00:11:48
Vamos a hacer un conjunto de nombres 00:11:49
Vamos a elegir la implementación 00:11:51
Hashed, esa es la primera que vamos a 00:11:54
Ver como ejemplo 00:11:57
¿Vale? Como funciona el Hashed 00:11:57
La primera de todas 00:12:01
Bueno, voy a meter una función aparte 00:12:03
Para que luego cuando probemos esto no sea tan 00:12:05
Ejemplo Hashed 00:12:07
Vale 00:12:16
Pues venga 00:12:17
Ejemplo Hashed, voy 00:12:23
Vale, pues venga, nos vamos a hacer 00:12:29
Nuestro Hashed de nombres 00:12:31
Uy, de nombres de stream, perdón 00:12:33
Bueno, es que no tengo ningún modelo 00:12:39
Ahora mismo, no tengo ningún modelo 00:12:42
Claro, claro, no lo estoy implementando yo 00:12:44
Igual que hemos visto ArrayList, LinkedList 00:12:52
Pues vamos a ver ahora estas 00:12:54
Que son otras que ya están hechas, no las vamos a implementar nosotros 00:12:56
Vale, entonces 00:12:58
Vamos a hacer un conjunto 00:13:00
De nombres 00:13:03
Bueno, pues lo mismo 00:13:04
los set 00:13:10
son interfaces 00:13:14
clases genéricas 00:13:16
yo puedo decidir el tipo 00:13:17
que voy a meter o puedo dejarlo abierto 00:13:20
ya sabéis que si 00:13:22
lo dejo abierto, él asume que es 00:13:24
de object, con lo cual puedes meter cualquier 00:13:26
cosa 00:13:28
eso es un peligro 00:13:28
porque cuando saques de ahí, recorras, te puedes 00:13:31
salir cualquier cosa, entonces ¿qué haces? 00:13:34
¿haces casting? ¿qué haces? mala idea 00:13:36
¿no? buena idea 00:13:38
cuando uno usa una colección 00:13:40
Decidir qué va a ir ahí dentro 00:13:41
Para que todos sean del mismo tipo 00:13:43
O de las subclases correspondientes 00:13:45
Bueno, pues un set de nombres, hashel 00:13:47
¿Qué se hace con una colección? 00:13:49
Pues lo mismo, siempre lo mismo 00:13:51
Insertar, ver si algo hay 00:13:53
Eliminar y ya está 00:13:56
O cambiar algo que hay adentro 00:13:58
El único que se hace, pues ya está 00:13:59
Lo que pasa es que cada una 00:14:01
Con sus matices para que funcione bien 00:14:02
Los matices de las listas ya lo sabemos 00:14:04
Pues en los sets 00:14:07
Pues venga, vamos a meter nombres aquí 00:14:08
vamos a ver cuantos hemos metido 00:14:10
pues nombre tendrá su size 00:14:30
lógicamente, como cualquier colección 00:14:34
estamos implementando collection, pues implementamos collection 00:14:36
el método size hay que implementarlo 00:14:41
vamos a ejecutar esto 00:14:43
antes que nada 00:14:48
y me saldrá dos, lógicamente 00:14:49
pues sí, me sale dos, claro 00:14:58
porque he metido dos nombres, me sale dos 00:15:07
¿Vale? 00:15:09
¿Cómo la recorremos? 00:15:11
Pues como cual... 00:15:13
¿Eh? 00:15:14
Bueno, he llamado al método sin más 00:15:16
En mi main 00:15:18
Claro, es que las diferentes pruebas que haga 00:15:19
En métodos aparte, para que no se me quede un main 00:15:22
Luego te va a ganar comentando y es un rollo 00:15:23
Vale 00:15:25
¿Cómo recorremos una colección para ver lo que hay? 00:15:27
Pues siempre podemos usar el for each 00:15:30
Claro 00:15:32
Para cada 00:15:33
Nombre en mi colección 00:15:35
nombres exactamente igual que en una lista 00:15:38
exactamente igual que en una raíz 00:15:40
para recorrer, para mostrar 00:15:41
siempre podemos recorrerla con el for each 00:15:43
nombre 00:15:48
vale 00:15:49
exactamente igual que con cualquiera 00:15:50
con cualquier otra 00:15:59
vale, pues vamos a ver los nombres que tiene 00:16:00
vale, pues tiene los dos que he metido 00:16:05
pero como veis 00:16:11
el orden 00:16:14
en el que me ha hecho 00:16:16
la iteración 00:16:18
no tiene que ver con el orden de inserción 00:16:19
¿por qué? porque aquí no hay 00:16:22
ningún tipo de orden 00:16:24
esto no es una lista donde cada elemento 00:16:25
tenga una posición 00:16:28
cuando yo metí en el conjunto 00:16:29
pues ahí fue entrando 00:16:31
entonces no puedo pretender 00:16:33
que en un recorrido para ver lo que hay 00:16:35
se conserve 00:16:38
el orden en el que yo lo introduje 00:16:39
porque aquí cada elemento no tiene una posición 00:16:42
Eso es lo primero, ¿vale? 00:16:44
Entonces, el orden de iteración no es el de inserción, ¿vale? 00:16:46
Y posiciones no hay. 00:17:01
Es decir, aquí el método get de listas no existe. 00:17:03
Con lo cual, si yo quisiera recorrer con un for de índice así, no puedo porque no tengo el get. 00:17:09
No puede ser el net tampoco. 00:17:15
el size sí, el size cualquier colección 00:17:16
claro 00:17:20
una colección tiene una cantidad 00:17:21
de elementos, entonces tiene su size 00:17:23
pero lo que yo no puedo hacer 00:17:25
es pretender hacer ahora 00:17:28
nombre.get 00:17:29
de i 00:17:33
porque este método no existe 00:17:34
el método get no existe para la 00:17:36
interfaz set 00:17:39
porque no hay posición, no puedo 00:17:39
recuperar por posición, no puedo 00:17:43
entonces esto 00:17:44
este recorrido 00:17:47
no se puede hacer 00:17:49
y por tanto tampoco podría 00:17:50
borrar por posición con el remove 00:18:08
y ni tendría sentido el método 00:18:10
index of al que le pasas 00:18:12
un elemento y te da la posición 00:18:14
del primero que encuentra igual 00:18:16
todos los métodos relativos a posiciones 00:18:17
aquí no existen 00:18:20
vale, entonces significa que solamente 00:18:25
podemos recorrer con un for 00:18:27
con un for each como este 00:18:29
no, también podemos recorrer 00:18:31
aparte de con streams de programación 00:18:34
funcional, que insisto, que las aparcamos 00:18:36
cuando sepamos un poco más, aparte 00:18:38
de eso 00:18:40
también podemos recorrer con el famoso 00:18:41
iterador, ¿vale? 00:18:44
vamos a ponerlo aquí 00:18:48
¿qué es un iterador? 00:18:50
un iterador es un objeto 00:18:55
que me sirve 00:18:56
para recorrer cualquier colección 00:18:58
cualquiera, lo que vamos a hacer aquí 00:19:00
para la lista sería igual 00:19:02
¿vale? 00:19:03
entonces no es un elemento que se use 00:19:07
ya mucho porque ahora mismo en las colecciones 00:19:08
siempre se usa programación funcional 00:19:10
prácticamente siempre 00:19:12
pero bueno, hay que conocerlo 00:19:13
entonces el objeto iterador es un objeto 00:19:16
de esta clase 00:19:18
que se asocia lógicamente 00:19:19
al tipo de dato 00:19:23
que yo ponga 00:19:25
mi iterador 00:19:27
¿y cómo consigo este objeto iterador? 00:19:28
este objeto iterador lo consigo 00:19:32
a partir de mi colección 00:19:34
sacándola con el 00:19:38
método iterador 00:19:40
iterador se convierte 00:19:41
ahora hecho esto 00:19:55
se convierte en una especie de objeto puntero 00:19:58
que me va señalando cada objeto 00:20:01
y a partir de ese objeto puntero yo puedo hacer cosas 00:20:04
inicialmente este objeto puntero 00:20:07
se queda apuntando 00:20:10
al anterior al primero 00:20:12
o sea, a ninguno todavía, al anterior al primero que ve 00:20:15
Entonces, yo avanzo el objeto puntero 00:20:18
Con un método que es next 00:20:21
Y además tengo otro método de literador 00:20:22
Que es hashNext 00:20:26
Que me dice si tengo puntero 00:20:27
O sea, si tengo siguiente 00:20:29
Con lo cual, la forma de recorrer con un puntero 00:20:30
Es esta siempre 00:20:34
n igual a ir.next 00:20:34
Y ahora aquí con n hago lo que sea 00:20:41
Lo que quiera 00:20:45
Es decir, el literador 00:20:46
Es un objeto que según yo voy haciendo 00:20:50
next 00:20:53
se va cargando 00:20:53
con cada uno de los elementos 00:20:56
y hash next me devuelve un boolean 00:20:58
para decirme si hay siguiente 00:21:01
o si no hay siguiente 00:21:02
con lo cual la mejor forma de combinar eso en un bucle 00:21:03
es esta 00:21:07
mientras tenga siguiente 00:21:07
cárgate con el siguiente 00:21:09
y yo ya con ese hago lo que quiera 00:21:12
pero claro 00:21:14
aquí no te devuelve ningún 00:21:16
no, este iterador va 00:21:17
random 00:21:22
A ver, no es que vaya random 00:21:23
Pero no sigue orden de inserción 00:21:25
Pero no hay posiciones 00:21:27
Va a seguir el mismo que el for each 00:21:28
Si lo ejecutamos 00:21:30
Aquí otra vez, ¿ves? 00:21:33
Este es con el for each y este es con el iterador 00:21:35
¿Vale? 00:21:37
Porque está usando 00:21:45
Internamente el orden alfabético 00:21:47
Como veis 00:21:49
¿Vale? O sea, si 00:21:51
Juraría, imaginaos que yo meto ahora 00:21:52
Nombre 00:21:55
¿No? 00:21:57
En cualquier caso es que es una pregunta que no deberíamos necesitar resolver, porque uno usa un conjunto precisamente en estructuras en las que el orden no le importa, no quiere orden, ¿vale? 00:21:59
De hecho, por eso no existe ni el sort, ¿vale? 00:22:12
¿Veis? El método sort no existe aquí. 00:22:16
Entonces, voy a probar. 00:22:20
a ver, voy a meter 00:22:32
claro, es que 00:22:34
descubrimos un patrón que los string 00:22:36
él los itera por 00:22:39
alfabético, que los int los itera 00:22:40
por orden de menor a mayor, puede ser 00:22:42
pero no es una información que debamos usar, pero si queremos un orden 00:22:44
entonces usamos otras estructuras 00:22:46
usamos comparables, etc 00:22:48
entonces aquí 00:22:49
pues me ha cambiado estos dos y este no 00:22:51
entonces 00:22:55
en realidad está usando 00:22:56
el orden del hashcode 00:23:00
en realidad 00:23:02
vale 00:23:03
a ver 00:23:05
volvemos al iterador 00:23:08
el iterador entonces 00:23:11
en realidad es muy poco útil 00:23:13
porque uno puede recorrer con un for each 00:23:16
salvo para una cosa 00:23:18
el iterador es utilísimo 00:23:20
para eliminar 00:23:22
porque tiene 00:23:24
el método remove 00:23:26
vale, por ejemplo 00:23:27
vamos a suponer que queremos 00:23:30
Hacer esto 00:23:32
Eliminar 00:23:33
Los nombres 00:23:35
Que empiecen 00:23:37
Por A 00:23:40
Por ejemplo 00:23:43
Vale 00:23:45
Pues 00:23:49
Si lo hacemos aquí con un for each 00:23:50
Que empiecen por A 00:23:54
Pues haríamos algo así 00:23:55
For string 00:23:57
Y nombre 00:23:59
Si n.char 00:24:02
At 0 00:24:08
Resulta que es igual 00:24:09
Pues entonces 00:24:13
Haríamos 00:24:17
Nombre.remove 00:24:17
Remove 00:24:20
Porque el remove funciona exactamente 00:24:23
Igual que en cualquier otra colección 00:24:26
Te borra un elemento 00:24:28
Igual que n 00:24:30
Te borra un elemento igual que n 00:24:31
y empezar por no es criterio de igualdad 00:24:34
lo cual no puedes poner directamente 00:24:36
entonces, si quieres borrar 00:24:38
por algo que no sea el criterio 00:24:41
de igualdad, con el for each 00:24:43
es que no nos queda más remedio que hacer esto 00:24:44
no nos quedaría más remedio que hacer esto 00:24:46
y aquí es cuando se nos saltan 00:24:48
las alarmas, pero bueno 00:24:50
¿qué es esto de meter un remove 00:24:52
dentro de un for? 00:24:55
ya sabemos que esto nos puede dar el concurrent 00:24:56
modification exception 00:24:58
que en este caso no sé si me lo va a dar, depende de en qué 00:25:00
momento pilla, vamos a probarlo 00:25:03
¿veis? me lo ha dado, no puedo hacerlo así 00:25:04
vale, pues para esto 00:25:12
a falta de la programación funcional 00:25:15
que sería la buena 00:25:16
yo lo puedo hacer con 00:25:17
el iterador 00:25:19
entonces ponemos aquí 00:25:21
esto 00:25:25
error 00:25:27
concurrencia 00:25:30
vale, ¿cómo lo podríamos 00:25:32
hacer sin que eso 00:25:34
pues con un iterador? entonces 00:25:35
me cojo yo 00:25:38
mi iterador, vale 00:25:40
aquí con el iterador 00:25:42
ya he terminado 00:25:44
pues vamos a volver a generarlo 00:25:45
porque después del bucle 00:25:48
de arriba ya lo he 00:25:50
ya lo he 00:25:51
vale, me cojo mi iterador 00:25:54
y voy recorriendo 00:26:01
y ahora 00:26:02
¿qué puedo hacer yo con el iterador? 00:26:04
pues si n 00:26:06
resulta que 00:26:07
charat 0 00:26:10
es igual a la 00:26:12
cumple el criterio que quiero borrar 00:26:16
a cero 00:26:18
igual a a 00:26:21
pues entonces a través del iterador 00:26:24
puedo borrar sin problema 00:26:27
es decir, el iterador no vale solo para apuntar 00:26:30
a través de elit.next me devuelve el objeto 00:26:34
y se queda apuntando a él, sino que además lo puede borrar 00:26:37
y esto lo hace ya protegiendo 00:26:41
Toda esa concurrencia 00:26:44
Y no nos vamos a encontrar aquí el problema 00:26:45
Entonces vamos a volver a mostrar la colección aquí 00:26:47
Para ver si lo ha borrado 00:26:50
Bueno, a ver, es que estoy haciendo la prueba 00:26:52
Que borre directamente el que empieza por A 00:27:00
Podría pasarlo por parámetro, es solamente para hacer la prueba 00:27:01
De cómo funciona 00:27:03
El que le tengo que pasar como parámetro 00:27:04
El it se queda apuntando 00:27:08
El it es que ya está apuntando al objeto en el que está 00:27:11
Cada it.next le deja colocado en uno 00:27:14
Y ahí se queda colocado 00:27:16
Y hasta que tú no hagas otro it.next 00:27:17
No avanza el siguiente 00:27:19
Y aquel en el que está colocado 00:27:20
Pues te lo puede borrar con it.remove 00:27:23
En el que está colocado 00:27:26
Entonces si ahora mostramos otra vez la colección 00:27:27
Pues esto que es lo que da error 00:27:29
Lo voy a dejar comentado 00:27:33
Que era lo que nos daba error 00:27:35
Y ahora si lo ejecutamos otra vez 00:27:39
Pues efectivamente me ha borrado 00:27:42
Al primero, al que empezaba por a 00:27:46
¿Vale? Luego 00:27:53
Sí 00:28:04
Pues eliminar 00:28:07
A falta de programación funcional 00:28:13
Eliminaremos con un iterador 00:28:16
De una colección 00:28:18
Y esto que hago 00:28:21
Aplica igual, me da igual que sea una lista que un conjunto 00:28:22
Esto de iterador es igual 00:28:24
En ambos casos funciona igual 00:28:26
Me da igual lista de conjunto 00:28:28
¿Vale? Para cualquier colección, me da igual 00:28:30
Vale 00:28:32
Entonces, añadir está claro 00:28:37
add, los métodos de add all 00:28:40
remove all, todo eso funciona 00:28:42
el remove funciona, por ejemplo 00:28:43
que yo quiero borrar a Bea 00:28:45
pues no hay ningún problema 00:28:47
esto funciona 00:28:51
¿vale? 00:28:53
esto funciona igual que las listas 00:28:55
por ejemplo 00:28:57
que yo quiero borrar ahora un elemento 00:28:58
pues el remove funciona igual que en las listas 00:29:01
igual, yo le paso el elemento 00:29:03
y me borra 00:29:05
aquí no hace falta que diga yo el primero que 00:29:07
encuentre igual a Bea, es que aquí 00:29:09
solo puede haber uno igual a Bea 00:29:11
entonces me borra a Bea 00:29:12
sin embargo en una lista 00:29:14
me borraba el primero que encontraba igual 00:29:16
aquí me borra directamente 00:29:19
la única instancia que puede haber 00:29:21
de este, vale 00:29:23
de hecho si 00:29:26
si, te devuelve un boolean para ver si borró 00:29:27
alguno o si no lo borró 00:29:30
vale, pero es que aquí solo puede haber 00:29:31
un Bea entonces 00:29:34
de hecho para añadir 00:29:35
vamos a suponer que añadimos 00:29:40
aquí al principio de todo que yo tengo 00:29:42
ya a estos tres, vamos a añadir uno que ya está. Vamos a añadir a Juan otra vez, ¿vale? 00:29:46
Y vamos a mostrar otra vez cuántos tiene. Pues este ad no ha añadido nada, porque ya 00:30:02
hay uno igual. Veremos que aquí hay tres y que aquí hay tres, ¿vale? ¿Veis? Tres 00:30:13
y 3 no ha añadido nada vale eso es lo siguiente es que es muy lista y te adelantas sí pero este 00:30:21
objeto lo hemos hecho nosotros entonces efectivamente bueno paramos en un minutos 00:30:33
un momentito 00:30:43
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:
15 de febrero de 2026 - 17:55
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
30′ 44″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
549.38 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid