Saltar navegación

20250213 Colecciones_Iterador - 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 13 de febrero de 2025 por Raquel G.

19 visualizaciones

Más información Transcripción

Descargar la transcripción

Venga, vamos a intentar ser rápidos 00:00:00
Para que nos junde el tiempo 00:00:03
Ejercicio 2 00:00:04
A ver 00:00:08
Una clase 00:00:10
Es más sencillo que el 1 00:00:13
Porque solamente tiene 00:00:14
Dos clases 00:00:17
Bueno 00:00:19
Ese también tenía dos 00:00:21
Pero era un poquito más lioso 00:00:23
Una discoteca que tiene un montón de discos 00:00:24
Y se acabó 00:00:28
vale, nada más, y ahora ya vamos a hacer las cosas con los discos que hay ahí dentro, o sea, una tonterita, vale, pero el problema es cuando eliminamos de una colección, eliminamos de una colección, no por la clave primaria, no por el equals, porque si eliminamos por el equals hacemos remove y listo, si no eliminamos por el equals es el problema, vale, pues venga, vamos a hacernos estas clases, 00:00:29
Primero disco, que es la que depende 00:00:54
De la que depende la discoteca esa 00:00:56
Eso 00:00:58
Entonces la clase disco 00:01:00
Que tenía como propiedades 00:01:02
El título y autor 00:01:04
Imagino 00:01:05
Sí, disco 00:01:07
Vosotros como ya este concierto 00:01:15
Vosotros tenéis las canciones 00:01:16
De streaming, que uno saca una canción 00:01:18
Y ya está, y se acabó 00:01:20
Antes no, antes las cosas se curraban 00:01:21
Y sacabas un disco completo 00:01:23
y no te ponías ahí en streaming 00:01:25
a hacer el tonto y el idiota 00:01:28
como se hace ahora 00:01:29
me desahogo 00:01:30
es que esto de banalizar la cultura 00:01:33
como se está haciendo me pone muy nerviosa 00:01:38
déjame que me desahogue 00:01:40
Sí 00:01:55
Vale, pues ya está 00:01:56
Tenemos el disco con sus dos propiedades 00:02:01
Por supuesto, aquí no nos paramos ya 00:02:03
Silencio, con los constructores 00:02:07
Getty Set, no me para decir nada 00:02:09
Los ponemos y ya está 00:02:11
Que tampoco 00:02:12
Vale, y ahora 00:02:14
La discoteca que tiene la temática 00:02:17
Y los discos, y ya está 00:02:19
Constructores Getty Setter 00:02:21
y ya iremos poniéndolos 00:02:22
igual los jascos, todo eso según nos vaya 00:02:24
pidiendo el cuerpo 00:02:26
si hombre, siempre 00:02:27
hacemos constructores getter y setter 00:02:30
y la verdad es que si generamos 00:02:32
siempre por sistema los toStream 00:02:34
pues mejor 00:02:36
venga 00:02:37
porque estoy idiota 00:02:39
pero no pasa nada 00:02:43
voy a refactorizar 00:02:46
aunque el getty set no me la refactoriza 00:02:48
así que cuidadín 00:02:50
Autor 00:02:50
Vale, entonces 00:02:52
Autor 00:02:56
Autor 00:02:59
Y set autor 00:03:15
Vale 00:03:28
Pues ya está todo 00:03:29
en el constructor 00:03:30
autor y título 00:03:32
autor, autor y título 00:03:33
vale, ya está 00:03:36
entonces mira, ya que he vuelto a entrar en esta clase 00:03:37
y no nos cuesta nada, vamos a hacer un toString 00:03:39
porque cuando lo pasamos a un system.out 00:03:41
es más bonito lo que nos saca 00:03:43
como ya sabemos 00:03:46
¿vale? o sea, otro ejemplo 00:03:47
del polimorfismo 00:03:50
el toString es un método 00:03:51
al que llama el system.out.println 00:03:54
cuando lo pasamos a un objeto 00:03:56
y llamará al toString de ese objeto 00:03:57
entonces es un ejemplo más de polimorfismo 00:03:59
el tuestring funciona diferente en alumno 00:04:01
en disco, en no sé qué 00:04:04
si escucharas 00:04:05
vale, ahora la otra clase 00:04:12
este, que nombre más feo 00:04:14
pero bueno 00:04:21
sí, un nombre muy feo 00:04:21
que si no me gustaban 00:04:24
¿por qué habláis en pasado? 00:04:28
si yo sé que soy muy mayor 00:04:30
pero todavía puedo ir a discotecas 00:04:31
te lo digo, en serio 00:04:33
y seguramente haga muchas más cosas 00:04:35
que tú en la discoteca 00:04:37
es que de verdad 00:04:38
a ver si es freje 00:04:43
la vida se acaba 00:04:44
vale 00:04:46
venga, entonces 00:04:49
vamos a hacer que sea 00:04:56
un conjunto 00:04:58
una lista 00:05:00
que 00:05:00
¿qué colección 00:05:02
os es más incómoda? 00:05:05
Conjunto, dice conjunto 00:05:08
y lo habéis hecho con conjunto, pues vamos a hacerlo 00:05:09
con conjunto 00:05:11
conjunto sería siempre la opción natural 00:05:11
por defecto porque es más sencilla 00:05:15
de implementar, un segundo 00:05:16
pero si necesitamos 00:05:18
las posiciones porque me son interesantes 00:05:20
para algo, pues haríamos una lista 00:05:23
¿vale? dime 00:05:25
ya, es que me ponéis nerviosa 00:05:26
Pues cambio las cosas 00:05:31
Venga, set 00:05:32
De disco 00:05:36
Vale, los discos que tiene 00:05:38
Aquí lo mismo 00:05:41
Es buena práctica instanciarlo aquí 00:05:43
Para que ya directamente haya una colección vacía 00:05:45
Me ahorro null pointer exception cuando añade el primero 00:05:47
Etcétera 00:05:49
¿Cuál nos gusta? ¿Hashet? ¿Treset? 00:05:50
Hashet 00:05:53
Vale, y luego vamos a rápidamente a cambiarlo en treset 00:05:53
A ver qué cambiaría en el ejercicio 00:05:57
Si uno decide que lo cambie a treset 00:05:59
¿vale? porque de cambiarlo 00:06:00
a linked hash no cambiaría nada 00:06:03
absolutamente nada 00:06:04
pues venga 00:06:05
importamos 00:06:08
vale 00:06:10
en entidades como estas 00:06:12
está bien hacer un constructor 00:06:14
con las propiedades que no sean colección 00:06:16
porque normalmente cuando yo instancio 00:06:18
una discoteca la instanciaré primero 00:06:21
con una temática y discos vacíos 00:06:22
y luego ya voy metiendo, es lo normal 00:06:24
entonces bueno, es habitual hacer un 00:06:26
constructor solo con 00:06:28
Esta propiedad 00:06:30
Ya los discos los iré metiendo después 00:06:32
Uno sin parámetros porque me facilita 00:06:34
La vida 00:06:37
Seguramente en algunas situaciones 00:06:37
Vale 00:06:50
Y un to stream, ya que nos ponemos 00:06:53
Un to stream 00:06:56
Bueno, aunque mirar la discoteca vamos a hacer 00:06:58
Vamos a mirar los discos, va, pasamos del to stream 00:07:00
Para no perder tiempo 00:07:02
vale, no he puesto ni Haskell 00:07:03
ni Equals ni nada 00:07:06
aunque nos podríamos adelantar desde ya porque no perdemos nada 00:07:06
pero vamos a hacerlo cuando ya identifiquemos 00:07:10
que es que es imprescindible 00:07:11
vale, pues estas entidades 00:07:13
no tienen métodos propios, aquí estaría 00:07:15
muy bien hacer un método que fuera 00:07:17
pues agregar un disco a la discoteca 00:07:19
pero bueno, es que eso es hacerle un 00:07:21
add, tampoco tiene más rollo 00:07:23
¿no? pero 00:07:25
para que no se nos vayan olvidando 00:07:27
bueno, no, porque si no os cambio el ejercicio 00:07:28
iba a poner un método que fuera 00:07:31
agregar disco 00:07:34
que tuviera dentro 00:07:35
lo único que tendría dentro es una 00:07:37
ya está 00:07:38
pero bueno suele ser el diseño habitual 00:07:39
que la clase 00:07:44
tenga sus propios 00:07:45
ofrezca los métodos 00:07:47
como la propiedad discos es privada 00:07:49
pues que tú no tengas que hacerlo 00:07:52
con un get desde el otro sitio 00:07:54
y luego añadir 00:07:56
sino que te ofrezca lo que tú 00:07:57
lo que tú quieras hacer, agregar disco 00:07:59
A ver, porque tú podrías 00:08:01
Quitar el get 00:08:08
Y ocultar toda tu implementación interna 00:08:09
Ocultar que es un set, que es una lista 00:08:12
Entonces si la ocultas 00:08:13
Tienes ya que publicar tú en métodos propios 00:08:15
Lo que tú dejas hacer 00:08:18
Agregar un disco, no sé qué 00:08:19
Entonces estás ocultando si es un set, una lista, lo que sea 00:08:20
Entonces es un diseño habitual 00:08:23
Pero en nuestro caso 00:08:25
Como nos pueden coger el set 00:08:26
Desde el get 00:08:29
vale, pues venga 00:08:30
un main con estas funcionalidades 00:08:32
de aquí, pues ala 00:08:34
vamos allá 00:08:36
vale, las funcionalidades las vamos a poner como métodos 00:08:36
aparte para probarlas 00:08:48
pues venga 00:08:49
la primera de ellas 00:08:51
vamos a 00:08:53
añadir 00:08:54
discos 00:08:58
como se van a pedir por teclado 00:09:01
ahí no se lo pasamos 00:09:10
se lo voy a llamar desde el main 00:09:11
efectivamente 00:09:13
como los vamos a pedir por teclado 00:09:15
han dicho, no los vamos a meter 00:09:17
ahí, pero ahí sí que vamos a meterle 00:09:19
el objeto al que 00:09:21
se lo vamos a añadir, pues entonces eso 00:09:23
vale, es a esta discoteca al que se lo vamos 00:09:25
a añadir, y ahora aquí ya 00:09:30
leemos 00:09:32
pues por ejemplo, lo primero que le 00:09:33
diríamos, en lugar de 00:09:36
hacerlo con un escáner 00:09:38
pues yo lo voy a hacer 00:09:40
con la otra 00:09:42
pues hazlo como 00:09:43
Por si luego importáis estos proyectos 00:09:45
Vosotros, me voy a acostumbrar a 00:09:54
Poner la librería dentro 00:09:55
Y así no tenéis luego que cambiarlo 00:09:58
Y os funciona 00:09:59
Si yo la pongo aquí 00:10:00
En una carpeta 00:10:03
Live 00:10:06
La pongo aquí en una carpeta 00:10:07
Live 00:10:12
La meto aquí 00:10:12
Paste 00:10:14
Y ahora ya 00:10:16
Actuil 00:10:20
Vale, pues entonces ahora ya 00:10:21
¿Cuántos discos quiere usted? 00:10:25
Pues nada 00:10:36
Estos discos quiere 00:10:37
Y ahora ya 00:10:43
Hacemos un 00:10:44
For 00:10:46
Solamente con N 00:10:48
Y ahora ya le decimos 00:10:50
El disco tiene el título y autor solamente 00:10:55
Título 00:10:57
Y autor 00:11:01
Claro, como lo va a meter seguido 00:11:02
Pues entonces, como ha dicho 00:11:06
Esto simplemente para practicar con ese método 00:11:08
Añadir y eliminar 00:11:10
Vamos a usar el método 00:11:12
AddAll y RemoveAll, que es añadir de golpe 00:11:13
Entonces vamos a crearnos una colección 00:11:16
Primero para meter esos 00:11:18
Y le hacemos un AddAll y ya está 00:11:19
Y así nos vamos 00:11:20
¿Eh? 00:11:21
Y con lo 00:11:24
¿Eh? 00:11:27
¿Eh? 00:11:29
A ver, espérate 00:11:29
Tú tranquila que forzaremos el error 00:11:38
Vale, por lo pronto estamos añadiendo ahora mismo 00:11:40
Entonces aquí no va a dar error en ningún caso 00:11:42
Vamos a esperar al remove, vale 00:11:44
Entonces vamos a crear aquí una colección 00:11:45
Y de hecho, nos da igual que sea una lista 00:11:48
Que una set, nos da lo mismo 00:11:52
Vamos a crear una colección de discos 00:11:53
Vale, vamos a crear una colección de discos 00:11:55
Y ahora en esta colección de discos 00:12:13
Temporal 00:12:14
pues vamos metiendo 00:12:15
un nuevo disco con los datos que me han dado 00:12:19
no sé en el 00:12:21
constructor en qué orden iban 00:12:24
en el constructor mío al menos 00:12:25
iban autor y título 00:12:27
pues entonces 00:12:29
es que todavía no tengo la colección 00:12:31
que voy a añadir de golpe 00:12:33
claro todavía no 00:12:34
ya sé, desvinculártelos a raíz 00:12:38
te cuesta 00:12:44
que no pasa nada 00:12:44
que si uno 00:12:50
pues al final se encariña 00:12:52
con quien se encariña, tampoco puede elegir 00:12:53
vale, pues ya hemos añadido 00:12:56
ya tenemos este for que está añadiendo 00:13:01
todo el rato a esta lista temporal 00:13:03
que nos hemos hecho, está añadiendo 00:13:05
todo el rato un nuevo disco 00:13:07
un nuevo disco 00:13:09
ahora ya 00:13:09
de mi colección dentro de la discoteca 00:13:12
que es esta 00:13:15
getDiscos de esta 00:13:16
yo ahora ya tengo un método addAll 00:13:18
al cual 00:13:21
le puedo pasar cualquier otra colección 00:13:23
cualquier otra 00:13:25
y se acabó y todos los discos de esta 00:13:27
colección, todos ellos van 00:13:29
al set 00:13:31
entonces es verdad que en esta colección 00:13:32
discos están ordenaditos 00:13:35
pero según se van metiendo al set 00:13:37
pues van cayendo ya en cualquier lado 00:13:39
¿vale? 00:13:41
el addAll los va sacando de la lista 00:13:43
y los va metiendo al set ahí a mogollón 00:13:45
si alguno 00:13:46
de los de esta lista 00:13:49
si alguno de los de esta lista 00:13:50
estuviera ya en el set, pues no lo metería 00:13:52
pero eso ya sabemos que funciona así 00:13:55
¿por qué utiliza una lista? 00:13:56
porque me da igual 00:14:01
o sea, he utilizado una lista 00:14:03
me he dicho, bueno, me da igual una lista, un conjunto 00:14:04
me da igual, vamos a ver que 00:14:06
para especificar que 00:14:08
aunque esto sea un set 00:14:09
yo le puedo meter todo lo que hay en una lista 00:14:11
en cualquier cosa 00:14:14
que sea colección, en cualquier cosa que sea colección 00:14:16
vale 00:14:19
entonces 00:14:22
el add all 00:14:23
vale 00:14:26
ya está 00:14:28
vale 00:14:43
entonces pensaba yo 00:14:45
que igual te devolvía el número de discos 00:14:47
que realmente he insertado 00:14:49
pero no, o sea te devuelve un boolean 00:14:50
que es true si se ha insertado 00:14:52
alguno al menos, o sea si ha habido 00:14:55
alguna modificación en el set y falso si no se ha 00:14:57
insertado ninguno. Pero esto ya sabemos 00:14:59
que es un set, con lo cual de esta colección 00:15:01
solo se van a insertar aquellos que 00:15:03
no estén previamente. Pero que 00:15:05
no estén, ¿cómo? Pues 00:15:07
según el criterio de igualdad entre discos. 00:15:09
Como no tenemos ninguno, 00:15:11
no tenemos ninguno, 00:15:13
pues se van a insertar todos. 00:15:15
Que yo, este usuario ha vuelto a 00:15:17
meter el disco 00:15:19
no sé qué 00:15:21
de no sé quién, y ese ya estaba. 00:15:23
Pues lo va a volver 00:15:26
Lo va a volver a añadir 00:15:27
¿Vale? 00:15:29
Entonces, si no queremos repetidos 00:15:31
Porque lo 00:15:33
Oye usuario, que el que me estás dando ya lo tengo 00:15:34
Pues si no queremos repetidos 00:15:37
Tendremos que ponerle en disco 00:15:39
Un jasco de equals 00:15:41
¿Vale? 00:15:42
Entonces, ¿por qué 00:15:45
Esta colección 00:15:47
Es un set? 00:15:49
Vale, pues ¿qué jasco de equals 00:15:51
Podríamos poner aquí? 00:15:53
A ver, aquí el jasco de equals en realidad deberían ser los dos porque un autor puede tener varios discos y un disco que se titula Hermoso Día puede tener varios autores. 00:15:57
¿No? Entonces, aquí es un ejemplo en el cual las claves primarias no tienen que ser siempre un único valor. La clave primaria puede ser múltiple, ¿verdad? 00:16:13
Es decir, el autor no identifica de forma única el disco, porque puede haber varios discos con el mismo autor. 00:16:27
Y el título tampoco lo identifica de forma única, porque puede haber varios autores que hayan coincidido en el título del disco. 00:16:34
¿Vale? 00:16:40
¿Qué podría ocurrir si no tienen mucha imaginación? 00:16:41
Y pasa. 00:16:45
Pues entonces no pasa nada, hacemos un jasco de equals con las dos propiedades. 00:16:46
Y ya está. 00:16:55
Entonces, solamente los objetos que coincidan en título y autor son considerados iguales, ¿vale? 00:16:56
Este jasco de equals que me ha generado considera tanto autor como título. 00:17:06
Vale 00:17:30
Bueno, pues entonces 00:17:34
Nos vamos al main 00:17:42
Pues ya está, añadir discos 00:17:45
Ahora, eliminar 00:17:46
Vale, pues lo mismo, vamos a decirle 00:17:47
Oye, ¿cuántos discos quieres eliminar? 00:18:06
Los vamos a meter en una colección 00:18:09
Aparte 00:18:10
Y luego le mandamos borrar 00:18:11
Las cuatro primeras líneas de arriba 00:18:14
Bueno, todas son idénticas 00:18:18
¿Cuántos discos quieres eliminar? 00:18:22
Todos estos discos 00:18:30
Guárdamelos a una colección aparte 00:18:31
Título autor, título autor 00:18:33
Y ahora a esta de aquí 00:18:34
De .get 00:18:36
Ah, que no le he pasado 00:18:41
Perdón 00:18:46
Este no se lo he pasado 00:18:46
Pues ahora ya a este punto 00:18:52
A esta colección 00:18:56
Bórrame todos aquellos 00:18:58
Que sean iguales 00:19:02
A alguno de estos de aquí 00:19:04
Y esto no da ningún tipo de error 00:19:07
Porque el error que os da a vosotros 00:19:09
Es un error que se genera 00:19:12
Cuando dentro de un for 00:19:14
Hay un remove 00:19:16
Porque anidas dos bucles 00:19:18
Y los dos bucles colisionan 00:19:20
En la colección 00:19:22
¿Vale? 00:19:23
Entonces, ¿cómo podríamos provocar el error? 00:19:25
Aquí lo que pasa es que vosotros igual 00:19:28
Habéis recorrido la colección, los habéis ido eliminando uno por uno 00:19:29
¿O cómo habéis hecho? 00:19:32
Para que os salga el error 00:19:33
Vale, vamos a hacer una cosa 00:19:34
Vamos a hacer un método 00:19:50
Que borra todos los discos 00:19:51
Del autor patatín 00:19:53
Que es un ejemplo 00:19:54
Que vamos a tener que hacer 00:19:56
Lo que vosotros habéis hecho 00:19:58
Forzar, eso, que es la misma idea 00:20:00
Ah, en la siguiente funcionalidad 00:20:03
En la última, vale 00:20:07
Por ahora vamos a añadir 00:20:08
Por ahora vamos a añadir 00:20:10
Un método extra para ver ese error 00:20:13
Por qué sale y cómo arreglarlo 00:20:14
Vamos a añadir un método extra 00:20:16
que es, vamos a borrar 00:20:18
todos los discos de un autor 00:20:20
porque ese autor 00:20:22
se ha condenado 00:20:23
la han cancelado, ha escrito un tweet 00:20:26
muy incorrecto 00:20:31
y han dicho, tú fuera 00:20:33
vamos a eliminar 00:20:35
todos los títulos que se llamen 00:20:38
de este 00:20:40
ala 00:20:45
todos los de este, entonces 00:20:48
aquí 00:20:49
vale 00:20:52
no tiene sentido 00:20:53
que nosotros 00:20:55
hiciéramos esto 00:20:57
de esto de aquí 00:20:59
vamos a ver, vamos a crearnos 00:21:01
un disco 00:21:04
igual a new disco 00:21:06
vamos a ponerle 00:21:11
a este disco 00:21:14
como propiedad autor 00:21:15
este autor de aquí 00:21:17
vale 00:21:18
y ahora 00:21:20
imaginaos que hacemos 00:21:22
de punto getDiscos y ahora 00:21:23
borrame uno igual a este 00:21:26
vale 00:21:28
esto no nos va a eliminar nada 00:21:32
está claro, ¿por qué? 00:21:34
porque ¿qué hace el método remove? 00:21:35
el método remove 00:21:37
te borra el disco que encuentre 00:21:39
en esta colección 00:21:42
igual a este 00:21:43
vale, pero para que sea igual 00:21:44
tiene que ser igual el autor y el título 00:21:48
y este disco, su autor es este 00:21:50
pero su título es null 00:21:52
yo no se lo he fijado, es null 00:21:54
entonces no te va a encontrar ninguno igual a ese 00:21:55
¿vale? 00:21:58
claro, porque es que el problema es que yo quiero borrar 00:22:00
no solo uno, uno igual a ese 00:22:02
sino quiero borrar todos 00:22:04
los cuyo autor sea este 00:22:06
por eso aquí no fijo el título 00:22:08
claro, yo aquí no fijo el título 00:22:10
no lo fijo, porque 00:22:14
yo quiero borrar todos 00:22:16
los que tienen como autor este 00:22:18
y título cualquiera 00:22:20
entonces no puedo hacerlo con un remove sin más 00:22:21
así no puedo 00:22:24
lo puedo hacer con un remove sin más 00:22:25
si me dijeran 00:22:28
borra el 00:22:29
claro, borra 00:22:31
este autor 00:22:33
y de este autor borra 00:22:35
su disco que se llama así 00:22:37
este en concreto 00:22:40
entonces sí, porque el método equals 00:22:42
utiliza los dos 00:22:44
entonces, ahora ya 00:22:45
lo tendría resuelto, le digo, oye tú 00:22:46
borra ese disco 00:22:49
que encuentres igualito a este 00:22:51
entonces, él coge el autor de ese 00:22:53
el título de ese 00:22:55
que ya se lo he fijado los dos, busca 00:22:57
uno igualito a ese y te lo elimina 00:22:59
pero ese no es el problema 00:23:01
que nos han dado, el problema que nos han dado es 00:23:03
no, no, no, bórrame todos 00:23:05
los del autor, luego un único remove no nos vale 00:23:07
porque el remove es para borrar 00:23:09
uno igual a ese 00:23:10
luego un único remove no nos vale 00:23:12
vale, vale, entonces 00:23:14
¿qué es la siguiente cosa que nos plantearíamos hacer? 00:23:17
bueno, pues voy a recorrer la colección 00:23:19
voy a recorrer la colección 00:23:21
que como es un set 00:23:23
la tengo que recorrer con un for each 00:23:26
no sabemos, hasta ahora no sabemos de otra manera 00:23:28
si fuera una lista 00:23:30
podríamos recorrerla con un for de índice 00:23:33
desde igual a cero, mientras sea menor que el tamaño 00:23:35
de la lista, pero como es un set 00:23:37
un for each, no tenemos otra historia 00:23:39
vale, pues para cada disco 00:23:41
que es la discoteca que me han dado como parámetro 00:23:50
punto get discos 00:23:53
vale, para cada disco 00:23:54
dis 00:23:57
en esta 00:23:59
pues ahora, podríamos preguntarnos 00:23:59
a ver, este es uno de los que yo quiero borrar 00:24:02
o lo que es lo mismo 00:24:04
dis.get autor 00:24:05
resulta que es igual 00:24:07
al autor que me han dado 00:24:10
¿vale? que esta no es 00:24:12
la igualdad total del objeto 00:24:14
no es la igualdad, esta es solo la igualdad 00:24:17
en autor 00:24:19
claro, la igualdad en el string autor 00:24:19
¿vale? este disco 00:24:22
dis resulta que su autor 00:24:25
es igual que este 00:24:27
autor, es igual que este autor 00:24:28
pues sí 00:24:31
es igual 00:24:32
¿vale? entonces 00:24:34
tendríamos que borrar este disco 00:24:36
¿y qué haríamos? pues yo cojo 00:24:39
mi discoteca esta de aquí 00:24:40
que la saco con dis.getDiscos 00:24:42
y le digo 00:24:45
oye, bórrame 00:24:46
este disco dis, que es el que quiero borrar 00:24:47
este dis, que es el que he comprobado 00:24:50
que el autor es igual a este 00:24:53
este dis, que es el que tú quieres borrar 00:24:54
este, bórramelo 00:24:56
y así con el for todo el rato 00:24:57
pasamos al siguiente dis 00:24:59
su autor es igual al autor que me han dado 00:25:01
también lo es, pues ala 00:25:04
de esa colección 00:25:06
borra el igual a ese 00:25:08
vale, y así creeríamos 00:25:09
que estamos borrando las cosas 00:25:12
y esto a nivel de código 00:25:13
está bien, tiene sentido 00:25:15
está bien hecho, vale 00:25:17
vamos a 00:25:19
public static, me falta el void 00:25:22
vale 00:25:23
vamos a hacer una pequeña 00:25:25
prueba, primero en 00:25:28
mi main, añadiendo 00:25:30
unos discos 00:25:32
vale, vamos a llamar 00:25:33
primero vamos a crear la discoteca 00:25:36
Claro, discoteca 00:25:38
De una nueva 00:25:40
Discoteca, aquí veis que bien 00:25:42
Me viene el constructor solo con la temática 00:25:44
Me viene genial el constructor solo con la temática 00:25:46
Porque, joel, nunca he visto tantos bostezos 00:25:49
Simultáneamente 00:25:50
Bueno, me viene muy bien una 00:25:51
Un constructor solo con la temática 00:25:53
Porque 00:25:57
Le digo, ¿de qué va a ser tu discoteca? 00:25:58
Pues va a ser de jazz 00:26:00
Muy bien 00:26:02
Toma ya, y la colección no la 00:26:04
Ahí está. No la inicializo porque ya se inicializa 00:26:06
aquí. 00:26:08
Ya se inicializa aquí. 00:26:10
Es maravilloso. 00:26:15
Lo que pasa es que es unos osos. 00:26:16
Claro, es que es tan amplio. 00:26:20
Vale, pues entonces, 00:26:23
ahora vamos a añadir unos cuantos discos. 00:26:24
Vale. 00:26:39
Y ahora 00:26:40
vamos a borrar unos cuantos 00:26:42
discos. 00:26:44
entonces vamos a poner aquí 00:26:44
un este 00:26:52
para 00:26:54
que sepamos donde 00:26:54
empieza este método 00:26:57
venga 00:27:01
vamos a ejecutar esto 00:27:04
a ver si nos añade y nos borra 00:27:05
porque aquí podemos haber hecho cualquier tontería 00:27:08
depende de si el que borra 00:27:11
es justo el último 00:27:14
si coincide que el que tiene que borrar es justo el último 00:27:15
pero bueno 00:27:17
vale, ¿cuántos vamos a meter? 00:27:19
Venga, vamos a meter tres. Autor, pues el autor va a ser A1 y su título va a ser título 1. El segundo autor, el A1, también va a tener otro disquito, que es el título 2. 00:27:21
Y luego vamos a tener un autor 2, cuyo título es el título 3. 00:27:35
Entonces, tenemos tres autores. 00:27:44
El A1, que ha hecho dos discos, y el A2, que ha hecho un disco solo. 00:27:48
¿Cuántos discos...? 00:27:53
¿Por qué me pregunta esto? Un momentito. 00:27:57
Me tendría que preguntar el autor, ¿no? 00:28:00
Un momentín. 00:28:03
a ver 00:28:05
ah, es que he llamado 00:28:08
elimina discos, no, yo quiero 00:28:17
probar elimina autor, para probar he llamado 00:28:19
he probado elimina discos, bueno ya que lo he lanzado 00:28:21
vamos a probar a ver si nos elimina los discos 00:28:23
y nos da error, ¿cuántos discos? 00:28:25
pues venga, vamos a borrar 00:28:27
el autor 2 00:28:28
con el título 3 y ya está 00:28:31
a ver si nos da algún error o no 00:28:32
¿cuántos discos 00:28:34
quiero borrar? pues quiero borrar un disco 00:28:37
Autor 00:28:39
A2 y título 3 00:28:41
No ha dado error 00:28:44
Seguramente sé de eliminar discos 00:28:46
Este bien hecho 00:28:48
Vale, y ahora ya yo quería probar 00:28:49
El elimina autor 00:28:52
No elimina discos 00:28:53
Voy a probar este 00:28:55
Elimina autor 00:28:57
Vamos a borrar 00:29:01
Entonces le vamos a decir 00:29:05
Autor a borrar 00:29:06
Autor a borrar 00:29:09
leemos el autor a borrar 00:29:13
y ahora ya 00:29:16
a elimina autor le decimos 00:29:23
bórrame todos los de este autor 00:29:25
en esta discoteca que acabas de hacer 00:29:27
y en la que acabas de agregar discos 00:29:29
vale 00:29:31
otra vez 00:29:33
ejecutamos 00:29:35
vamos a meter 3 00:29:36
el autor 1 00:29:39
te ha hecho un disco 00:29:41
el autor 1 te ha hecho un disco 00:29:44
y el autor 2 00:29:48
te ha hecho un disco T3 00:29:50
vale, vamos a borrar 00:29:52
¿a quién quieres borrar? al autor 1 00:29:55
pam, ¿vale? 00:29:56
era de esperar porque estamos 00:29:59
borrando autores que están ahí metidos 00:30:00
en la colección, es este concurrent 00:30:03
este de aquí 00:30:05
entonces, este error ha salido 00:30:05
de esto, vale 00:30:10
ha salido de esta situación 00:30:12
que 00:30:16
dentro de un for en el que yo estoy recorriendo 00:30:18
estoy borrando 00:30:20
también, entonces esta colección 00:30:22
getDiscos 00:30:24
ya se ha apropiado de ella el forEach 00:30:25
porque ya la está recorriendo 00:30:27
y el remove se quiere meter también en ella 00:30:29
a recorrerla, porque tiene que recorrerla 00:30:31
también hasta que encuentre el disco 00:30:34
igual a dis y borrarlo 00:30:35
pues no, no, con dos no 00:30:36
aquí estos tríos 00:30:39
no le van, tiene que ser o uno o el otro 00:30:43
con lo cual, ¿cómo arreglamos esto? 00:30:45
pues esto no nos gusta 00:30:48
vale 00:30:48
pues en esta situación en concreto 00:30:50
cuando queremos 00:30:53
borrar por otros 00:30:58
datos que no son la clave 00:31:03
primaria, es decir 00:31:04
lo que está en el equals 00:31:09
o hashcode 00:31:10
si es que es un set, porque esto es igual para 00:31:13
lista que para set, me da lo mismo 00:31:15
no podemos 00:31:16
anidar 00:31:23
remove en el 00:31:24
for each 00:31:29
es porque 00:31:30
da una excepción 00:31:34
concurrencia. 00:31:37
Vale. 00:31:41
Eso, esa situación, 00:31:42
la hacemos con un iterador. 00:31:44
Vale, que el iterador además te ofrece 00:31:52
otras funcionalidades y todo eso. 00:31:54
Pues venga, ¿cómo hacemos esto mismo? 00:31:56
Esto ya lo hemos comentado. Vale. 00:31:58
Pues el iterador es un objeto que es capaz de iterar 00:32:00
por una colección, como su nombre indica. 00:32:02
y el iterador pertenece a la clase iterator 00:32:04
vale, pues el iterador hay que decirle 00:32:06
es una clase genérica, hay que decirle tú sobre qué vas a iterar 00:32:10
sobre qué tipo de objetos, en este caso 00:32:13
como nuestra colección es de discos, pues le decimos 00:32:16
oye iterador, tú vas a iterar sobre una colección 00:32:19
que tiene discos, si quisiéramos iterar 00:32:22
sobre una colección que no está parametrizada, que puede tener cualquier cosa 00:32:25
pues podríamos crear el iterador así 00:32:28
pero como en nuestro caso es una colección de discos 00:32:30
parametrizada a discos, pues iteramos así 00:32:34
vale, pues este iterator 00:32:36
¿cómo se instancia? ¿cómo se crea? 00:32:38
pues tendremos que coger la colección 00:32:41
en la cual queramos iterar 00:32:43
que en nuestro caso es de .getDiscos 00:32:45
y esa colección tiene un método 00:32:48
que es el método iterator 00:32:50
que te genera un iterador y te lo devuelve 00:32:52
uno pone la colección que sea 00:32:55
de la que quiere sacar el iterador 00:32:58
y con este método 00:33:00
saca ese objeto iterador 00:33:02
y te lo devuelve 00:33:04
vale, pues ya está, ya tenemos el iterador 00:33:05
que está en java útil 00:33:08
lo importamos y ya está 00:33:10
y ahora este objeto iterador 00:33:12
tiene métodos 00:33:14
para avanzar por mi colección 00:33:16
y devolverme los objetos 00:33:19
en los que está posicionado 00:33:21
según avanza y hacer cosas con ellos 00:33:22
¿cuál es el método 00:33:24
más importante de el iterador? 00:33:26
pues deliterador si vemos lo que tiene 00:33:29
tiene muchas cosas 00:33:34
pero tiene un método 00:33:38
next 00:33:42
que es el que sirve para 00:33:43
avanzar, el literador 00:33:45
inicialmente está colocado 00:33:47
antes del primero, el literador está 00:33:49
colocado antes del primero y cada 00:33:51
next que hacemos le avanza una posición 00:33:53
con lo cual para empezar por 00:33:55
el primero ya hay que hacer un primer next 00:33:58
para luego pasar al segundo hay que hacer un segundo 00:33:59
next, para luego pasar al tercero 00:34:02
hay que hacer un tercer next. 00:34:04
Ese es el método más importante. 00:34:05
Y luego tiene hashNext que te dice 00:34:08
¿hay un siguiente? O sea, ¿tiene sentido 00:34:09
que hagas un next porque hay un siguiente? 00:34:11
True si hay un siguiente, 00:34:14
con lo cual tú avanzas, y false si no. 00:34:16
Entonces, la combinación de estos 00:34:18
dos métodos en un bucle 00:34:20
es la que te permite ir avanzando con el iterador. 00:34:21
Y luego, aparte, pues iterator 00:34:24
pues tiene 00:34:26
métodos para hacer cositas, pero como veis 00:34:26
muy poco. 00:34:30
Justo. Claro, entonces, ¿cómo 00:34:32
usamos un iterador para recorrer 00:34:34
una colección. 00:34:36
Pues hacemos. Mientras. ¿Mientras qué? 00:34:38
Pues mientras tenga siguiente. 00:34:40
Mientras tenga 00:34:43
siguiente. 00:34:44
Mientras tenga siguiente. Vale. 00:34:45
Pues mientras tenga siguiente. 00:34:48
Hacemos un next. ¿Vale? 00:34:50
Para colocarnos en ese siguiente. 00:34:52
Ese next 00:34:55
coloca el iterador en el siguiente. 00:34:56
Y te lo devuelve como parámetro. 00:34:58
Entonces si tú quieres hacer algo con él 00:35:00
porque quieres pues 00:35:01
como es un disco, pues lo podemos guardar aquí 00:35:04
por ejemplo, y yo aquí 00:35:06
con este disco, pues podría 00:35:11
cambiarle una propiedad, cambiarle 00:35:13
el autor 00:35:15
mostrarlo, lo que quisiera 00:35:15
pero en particular, el iterador 00:35:18
te permite borrar 00:35:21
el elemento en el que estés 00:35:23
te permite borrarlo 00:35:24
claro, con el 00:35:26
método remove 00:35:29
que está sincronizado con el while 00:35:30
y al estar sincronizado no te da 00:35:33
concurrencia, entonces este bucle 00:35:35
en particular que he hecho te los estaría borrando todos 00:35:37
pero no, no queremos borrar todos 00:35:39
queremos borrar solo los que sean 00:35:41
autor, pues entonces aquí lo que incluiríamos es 00:35:43
a ver, si este disco 00:35:45
de aquí, su autor 00:35:47
resulta que es igual 00:35:49
al autor que me han dado como parámetro 00:35:51
pues entonces 00:35:53
it, porque ahora 00:35:55
me it está posicionado ahí 00:35:57
remove, y esto no 00:35:58
nos va a dar error de concurrencia, porque 00:36:01
el iterador ya es un objeto 00:36:03
aparte que gestiona la concurrencia 00:36:05
entre el while y... 00:36:07
¿Vale? 00:36:09
Un segundinín que digo lo último y ya me preguntas. 00:36:14
O es un descansito, era. 00:36:17
Vale, pues digo lo último y un descansito. 00:36:19
Cuidado aquí. 00:36:21
Yo lo he... 00:36:23
¿Vale? Cuidado aquí porque 00:36:25
cada it next que hagas 00:36:26
te avanza. 00:36:28
Entonces, imaginaos que en lugar de haberlo 00:36:30
guardado aquí, 00:36:32
yo hago un it next, 00:36:33
Por ejemplo, imaginaos que hago esto 00:36:35
Pensando, avanza 00:36:39
Y ahora como no lo tengo guardado en ningún sitio 00:36:42
Pues sustituyo esto por esto 00:36:45
Cuidado, o sea, cada next te avanza una posición 00:36:47
No, a ver 00:36:50
Lo que estoy diciendo, itnext.getAutor 00:36:53
A ver, cuidados 00:36:57
Cada next te avanza una posición 00:36:59
Entonces imaginaos que yo he hecho un itnext aquí 00:37:01
Creyendo que con eso avanzo 00:37:03
para el literador, que es lo que tengo que hacer, efectivamente 00:37:04
lo he avanzado, vale 00:37:06
e in next me devuelve el objeto disco 00:37:08
vale, pero si vuelvo a hacer otro 00:37:10
in next aquí para coger el objeto disco 00:37:12
ya me he avanzado al siguiente 00:37:15
entonces, dentro de este 00:37:17
while, estaría avanzando 00:37:19
de dos en dos, avanzo uno 00:37:20
y luego avanzo otro, y ya de este miro el autor 00:37:22
entonces, cuidado 00:37:25
por eso lo he guardado en un sitio 00:37:26
para no avanzarlo dos veces 00:37:28
lo he guardado aquí, digo, a ver, avanza una vez 00:37:30
solo una, avanza una 00:37:33
el disco al que has avanzado es este 00:37:34
vale, pues si este disco 00:37:37
y este disco 00:37:39
su autor es este 00:37:41
me lo borras, porque el iterador está 00:37:42
colocado en él, vale, ojo 00:37:45
porque cada it next dentro del 00:37:47
bucle, va, te va saltando, te va saltando 00:37:49
dime 00:37:50
el it next, lo que te devuelve 00:37:51
es el disco anterior al que has saltado 00:37:55
no, no, no, el disco en el que te acabas de 00:37:57
colocar, it 00:37:59
el iterador inicial, si tu 00:38:00
colección es este, este y este 00:38:03
de tres, el iterador inicialmente 00:38:04
se queda colocado antes del 00:38:06
primero, entonces 00:38:08
el primer itnex se coloca en el primero 00:38:10
y te devuelve el primero, y hasta que 00:38:12
tú no hagas un itnex, el iterador está 00:38:14
ahí colocado, vale 00:38:16
si yo hiciera otro itnex ya estaría en el siguiente 00:38:18
entonces por eso la mejor forma de no 00:38:20
colocar, de no confundirse 00:38:22
es que tú hagas un 00:38:25
itnex, cojas el objeto 00:38:26
con ese objeto hagas ya todo lo que 00:38:28
quieras aquí, no vaya a ser que te saltes 00:38:30
al siguiente sin querer, hagas todo lo que quieras 00:38:32
y no hagas el siguiente index hasta 00:38:34
la siguiente vuelta 00:38:36
¿vale? entonces 00:38:37
esta versión ya no nos va a dar ese error 00:38:39
la probamos y descansamos 00:38:43
vale 00:38:47
vamos a volver a ejecutar esto 00:38:50
a ver si lo hemos escrito bien 00:38:52
vamos a meter tres autores 00:38:54
vamos a simular la misma situación de antes 00:38:56
el autor uno que me ha escrito 00:38:58
este disco 00:39:01
el autor uno que ha 00:39:02
escrito este otro 00:39:04
y el autor 2 que ya ha escrito 00:39:06
uno cualquiera 00:39:10
vamos a borrar el autor a 1 00:39:12
y aquí no da error 00:39:16
a ver si lo visualizará con un for 00:39:18
veríamos que sí, que efectivamente me los ha borrado 00:39:21
solo hay uno, lo podríais añadir 00:39:22
que lo recorra para ver si están 00:39:25
pero como veis aquí no ha dado el error 00:39:26
en una situación idéntica a la anterior 00:39:29
¿vale? 00:39:30
no hombre, no 00:39:33
y venga 00:39:36
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:
19
Fecha:
13 de febrero de 2025 - 13:13
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
39′ 38″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
182.21 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid