Saltar navegación

Activa JavaScript para disfrutar de los vídeos de la Mediateca.

Clase 08-03-24 - 3 - 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 10 de marzo de 2024 por Raquel G.

12 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, aquí no se puede plantear hacer la revuelta, la situación es distinta, porque puede haber varios, aquí no hay igualdad por equipo, la igualdad es por equipo y número, entonces aquí pues uno, ¿qué le podrías ir a hacer? Pues un forno, uno para localizar, para cada jugador, jota en jugadores, vamos a ver si este es uno de los que toca borrar, si este es uno de los que toca borrar, 00:00:01
porque aquí no podemos, repito, borrar por igualdad 00:00:27
aquí hay que ver, si este jugador 00:00:32
tiene ese equipo 00:00:34
pues será de los que toca borrar 00:00:35
pues vamos a ver 00:00:37
si el equipo de este jugador 00:00:39
es igual 00:00:43
al equipo que me han pasado 00:00:45
al que pertenecen 00:00:47
los que tengo que borrar 00:00:49
vale 00:00:52
entonces si este jugador 00:00:54
pues entonces ahora ya uno podría 00:00:58
plantearse hacer, vale, pues entonces 00:01:01
a este jugador en concreto, a este J 00:01:02
A este 00:01:04
Que he visto que su equipo es igual a este 00:01:05
A este jugador le tengo que borrar 00:01:09
A ese, a uno igual a ese 00:01:11
Entonces aquí uno sí que 00:01:12
Tendría sentido que se planteara hacer esto 00:01:14
¿Verdad? 00:01:16
Jugadores.remove 00:01:18
¿No? Este remove ya tiene sentido 00:01:21
Porque aquí queremos 00:01:25
Borrar a este, a este le queremos borrar 00:01:26
A este 00:01:28
Porque hemos visto que su equipo es igual 00:01:29
Luego a ese hay que borrarle 00:01:32
Pues si le pasamos al remove 00:01:33
Borrará a ese 00:01:34
O a uno igual a ese 00:01:35
Pero es que ser igual es ser el mismo 00:01:37
Estamos hablando de 00:01:39
Entonces que cinco veces 00:01:41
Se encuentra 00:01:44
A cinco jugadores de ese equipo 00:01:46
Pues borraría a los cinco 00:01:48
Haría cinco remove 00:01:50
¿No? 00:01:52
Mismo equipo 00:01:56
Claro, el parámetro que yo le he pasado es el de equipo 00:01:57
Entonces todos 00:02:00
Los que pertenezcan a un equipo 00:02:01
a todos esos los está borrando 00:02:03
¿no? 00:02:06
¿entendéis la sintaxis de este for? 00:02:08
¿no? o sea lo que está por ahí 00:02:10
a ver 00:02:11
vale, bueno 00:02:27
esto que está aquí 00:02:45
todo el mundo lo entiende 00:02:47
¿y le veis sentido? 00:02:50
estamos borrando a este porque su equipo 00:02:52
es igual que luego después de 00:02:54
tres iteraciones después encontramos a otro 00:02:56
cuyo equipo es igual, estamos borrando 00:02:58
todo esto tiene sentido ¿no? 00:03:00
Porque ahora el remove ya sí que queremos borrar uno 00:03:01
Igual a este, igual 00:03:04
Y esto habrá que hacerlo tantas veces 00:03:05
Como jugadores encontremos 00:03:07
Que pertenecen a ese equipo 00:03:10
A lo mejor borraremos cinco 00:03:11
O a lo mejor borraremos seis, no lo sé 00:03:14
No es como aquí, aquí borramos uno 00:03:15
Borramos el jugador de este número 00:03:17
Y de este equipo, borramos uno 00:03:20
Hacemos una auxiliar y borramos uno 00:03:22
Igual a ese, este es otro método 00:03:24
Vale, pues entonces 00:03:25
Vamos a probar esto 00:03:28
Poniéndole más 00:03:29
Para que haya varios del mismo equipo 00:03:31
Vale, pues vamos a poner aquí 00:03:34
Otro diferente del Madrid 00:03:41
Vamos a poner aquí otro diferente 00:03:45
De Valencia 00:04:03
Y aquí otro diferente del Madrid 00:04:05
Tenemos entonces tres del Madrid pero que son distintos 00:04:08
El 1, el 2 y el 3 00:04:16
Tres jugadores distintos que pueden ir a la colección 00:04:18
Sin ningún problema porque son distintos 00:04:21
porque el número es distinto 00:04:23
y la igualdad viene por número y equipo 00:04:24
vale, pues entonces, ya tenemos este método 00:04:27
vamos ahora en el main 00:04:31
incorporar para que haga eso 00:04:33
vale, pues venga 00:04:35
vamos ahora a 00:04:40
hacer 00:04:42
esto 00:04:44
eliminar 00:04:47
jugadores 00:04:48
de un equipo 00:04:52
vale 00:04:55
pues pedimos el equipo 00:05:00
Y ahora ya sí 00:05:01
Podemos llamar al método correspondiente 00:05:11
Que era 00:05:14
Eliminar jugadores de un equipo 00:05:15
Le pasamos el equipo 00:05:18
Que acabamos de leer 00:05:20
Para que elimine todos los de ese equipo 00:05:21
Y el set con el que trabajar 00:05:23
Y ahora vamos a volver a 00:05:24
Llamar a mostrar jugadores 00:05:26
A ver si ha eliminado todos los de ese 00:05:28
Lo que estamos haciendo 00:05:30
Pedimos un equipo, llamamos al método que acabamos de hacer 00:05:34
Y volvemos a mostrar 00:05:36
Y el método 00:05:38
El método que acabamos de hacer es 00:05:40
Este 00:05:43
Va uno por uno 00:05:44
Todos los que coinciden en equipo 00:05:47
A borrar 00:05:49
Pues venga 00:05:50
Vamos a hacer el main 00:05:52
Que hace un montón de cosas 00:05:55
Es un rollo, hay que meterle varias cosas, pero bueno 00:05:59
Vale, pues venga 00:06:01
Tiene seis 00:06:04
Le hemos metido seis 00:06:05
Vale 00:06:08
Entonces, como veis 00:06:10
el orden en el que 00:06:11
los muestra 00:06:14
no tiene nada que ver 00:06:15
nada que ver 00:06:18
con el orden en el que 00:06:19
lo hemos insertado 00:06:22
lo hemos insertado 00:06:23
Luis, Pepe de Madrid, Sevilla 00:06:26
lo hemos insertado en este orden 00:06:28
pero cuando luego hemos hecho el for 00:06:30
y lo hemos mostrado 00:06:32
el orden no tiene nada que ver 00:06:33
es que no hay orden 00:06:36
en los conjuntos 00:06:38
es decir, el orden de iteración en el for 00:06:39
el orden por el que he ido iterando 00:06:41
es un orden que no se corresponde 00:06:43
con el orden con el que yo he ido insertando 00:06:46
en las listas 00:06:48
sí, cuando yo insertaba 00:06:50
una lista y luego recorría con un for each 00:06:51
pues yo veía que se me iba mostrando 00:06:53
en el mismo orden en que había 00:06:56
ido insertando 00:06:58
pero aquí no 00:06:59
aquí es donde mejor se ve 00:07:00
que en los conjuntos no hay una 00:07:03
posición, no hay un orden 00:07:05
Vale, pues entonces 00:07:07
Estos son los datos que hemos metido 00:07:17
Son estos 6 00:07:19
Vamos a comprobar si hay jugadores 00:07:21
En el equipo de Sevilla 00:07:25
Por ejemplo 00:07:27
Pues sí existe 00:07:28
Ahora vamos a ver si existe alguno en concreto 00:07:30
Venga, el 1 de Sevilla, a ver si existe 00:07:33
Uy, nombre de equipo 00:07:35
Sevilla, el 1 00:07:37
El jugador está 00:07:40
Vamos a eliminar 00:07:41
Pues 00:07:43
El de Sevilla 00:07:44
También, 1 Sevilla 00:07:47
Venga, nombre de equipo 00:07:49
Este 00:07:50
Y efectivamente ya solo me quedan 5 00:07:53
Lo he eliminado 00:07:56
¿Vale? Y ahora vamos a eliminar jugadores 00:07:58
Que pertenezcan a un equipo 00:08:01
Jugadores que pertenezcan a un equipo 00:08:03
Que es la última funcionalidad que nos faltaba 00:08:04
Que ese es el que hace el Zor y va uno por uno 00:08:06
Pues venga, Madrid 00:08:09
Y no sale una excepción 00:08:11
Una excepción rarísima 00:08:14
Porque realmente esto 00:08:17
Con todo lo que hemos visto 00:08:18
Está bien hecho 00:08:21
Esto está bien 00:08:22
Un for each que recorre 00:08:23
Para cada jugador cuyo equipo coincida con el equipo que me han dado 00:08:25
Se lo pasa al remove 00:08:29
Para que lo elimine 00:08:30
Uno igual a ese 00:08:32
En este caso ese mismo 00:08:33
Porque es que es directamente el que estoy aquí de la colección 00:08:35
Pero ha sido un error muy raro 00:08:38
Vamos a volver a probarlo 00:08:40
Eliminando los de Valencia 00:08:43
Por ejemplo 00:08:49
Vamos a ver 00:08:50
Comprar jugadores de un equipo 00:08:53
Estas son las primeras, meto cualquier cosa 00:08:56
No existe, nombre de equipo, patatín 00:08:58
Número de jugador 2 00:09:01
No está, eliminamos jugador, nombre de equipo 00:09:02
Patatín 00:09:04
Vale, y ahora vamos a eliminar 00:09:06
Jugadores de 00:09:08
Valencia 00:09:09
Vale, nos vuelve a salir 00:09:13
El mismo error 00:09:19
Vamos a 00:09:20
hacer otra prueba 00:09:23
ahora lo miramos 00:09:28
ahora lo miramos 00:09:30
lo vamos a mirar y vamos a aclararlo 00:09:31
pero estoy yo buscando 00:09:33
un caso de prueba 00:09:35
vamos a ver 00:09:37
vamos a meter 00:09:38
vale, vamos a eliminar 00:09:40
a este, vamos a hacer el otro caso de prueba 00:09:48
vamos a hacer otro caso 00:09:50
de prueba que sea este de aquí 00:09:54
vamos a meter solamente 00:09:56
a dos, a este y a este 00:09:59
Estos fuera 00:10:02
Vamos a hacer ahora la ejecución 00:10:02
Pero solo con estos dos jugadores 00:10:09
Pues venga 00:10:11
Solo con estos dos en la colección 00:10:13
Hay jugadores en este equipo 00:10:15
No, introduzca nombre de equipo y número 00:10:17
No está, eliminamos jugador 00:10:19
De este equipo y de este número 00:10:21
No está, siguen estos dos 00:10:23
Ahora vamos a eliminar jugadores 00:10:25
De este 00:10:27
Pues aquí me lo ha hecho bien 00:10:29
No he cambiado nada el código fuente 00:10:34
No he cambiado nada 00:10:36
A ver, he metido menos jugadores 00:10:37
Pero vamos, que el método es igual, todo es igual 00:10:39
Y no solo no me da error 00:10:42
Sino que me lo ha eliminado 00:10:44
Cuando yo miro 00:10:46
Cuando yo miro 00:10:48
Me lo ha eliminado, aquí lo ha hecho bien 00:10:51
Entonces aquí, a ver Ana 00:10:52
Cállate por favor 00:10:56
Entonces aquí, ¿qué está pasando? 00:10:57
Bueno, esto primero 00:11:02
Esta es la primera muestra de que cuidado con las fases de prueba 00:11:03
Tienen que ser completas 00:11:07
Si uno hace un único caso de prueba con estos dos 00:11:08
y mete Sevilla A, eliminado 00:11:11
muy bien, funciona el código 00:11:13
y tiro para adelante 00:11:14
cuando uno se puede hacer más casos de prueba 00:11:16
de repente le salen errores 00:11:19
que es lo que nos ha pasado a nosotros 00:11:20
es importante no concluir con una sola prueba 00:11:22
que el código está bien hecho 00:11:25
bueno, pues ahora vamos a la siguiente parte 00:11:26
hemos hecho más casos de prueba 00:11:29
metiendo más jugadores 00:11:31
y nos ha dado un error 00:11:32
vamos a volver a forzarlo 00:11:34
para ver 00:11:37
para ver 00:11:39
qué tipo de error nos da 00:11:46
nombre de equipo 00:11:50
nada, nombre de equipo 00:11:56
número, nombre de equipo 00:11:58
número, y ahora vamos a eliminar 00:12:00
jugadores de un equipo 00:12:02
Madrid, ahí está el error 00:12:03
con el mismo código 00:12:05
vale 00:12:07
pues venga, qué error nos da 00:12:10
este que no lo hemos visto en la vida 00:12:11
error de modificación 00:12:13
concurrente 00:12:16
vale, ¿qué significa 00:12:16
modificación concurrente? 00:12:19
concurrencia, concurrencia 00:12:21
significa es que hay dos cosas que están 00:12:23
chocando, eso es concurrencia 00:12:25
si concurrimos en algo hay varias cosas 00:12:27
que están chocando en algo 00:12:29
entonces lo que significa esto es que 00:12:31
hay 00:12:33
un problema 00:12:35
de que a un recurso 00:12:37
a un recurso de mi proceso, de mi programa 00:12:38
están tratando de acceder desde dos 00:12:41
partes a la vez 00:12:43
eso es un problema 00:12:44
cuando un programa se está ejecutando 00:12:47
pues tiene su proceso, sus variables 00:12:49
y los recursos del programa 00:12:51
que los recursos del programa son las variables 00:12:53
en nuestro caso, no pueden ser accedidas 00:12:55
a la vez, primero tiene que ser accedida por uno 00:12:58
y luego por otro 00:12:59
eso es importantísimo en la programación 00:13:01
multihilo, cuando tengo una aplicación 00:13:03
que son muchos hilos a la vez 00:13:05
¿vale? programación que veréis 00:13:07
el año que viene, nosotros hasta ahora 00:13:09
todos nuestros programas es un solo hilo de ejecución 00:13:11
hago esto, hago esto, hago esto, uno tras otro 00:13:13
son sentencias una tras otra 00:13:15
a lo mejor estoy llamando a métodos, pero da igual 00:13:17
yo entro en un método, hago lo que sea, salgo del método 00:13:18
vuelvo aquí, sigo, ahora me voy a otro método 00:13:21
sigo, todos los programas 00:13:23
que hemos hecho es una sentencia una tras otra 00:13:25
eso significa que es un solo hilo 00:13:27
pero podemos hacer programas 00:13:29
donde tenemos varios hilos a la vez 00:13:31
que se van haciendo a la vez 00:13:33
¿cuál es el problema 00:13:34
cuando tenemos varios hilos? 00:13:37
que si hay variables compartidas 00:13:39
como es el caso 00:13:41
y 2 quieren acceder a la vez 00:13:42
para hacer system.out.println 00:13:44
n o para hacer n igual a 7 00:13:46
2 a la vez quieren 00:13:49
saltaría este error 00:13:50
porque a un recurso no pueden acceder 00:13:52
2 a la vez 00:13:54
y por eso cuando se programa en multilo 00:13:55
hay que habilitar semáforos, historias 00:13:58
y rollos que es lo que se da 00:14:01
en un módulo de curso que viene 00:14:02
para evitar esto 00:14:03
para evitar que a un recurso lleguen 2 a la vez 00:14:05
entonces el error significa eso 00:14:08
que a un recurso han ido dos a la vez 00:14:11
claro, pero aquí solo tenemos un hilo 00:14:12
¿quiénes son los dos que han ido a la vez? 00:14:15
bueno, pues son 00:14:19
dos for en realidad 00:14:19
¿qué es lo que ha pasado aquí? 00:14:21
vámonos a nuestro método 00:14:24
peligroso, este 00:14:25
nosotros llamamos al remove 00:14:27
y el remove ya sabemos lo que hace 00:14:31
elimina de esta colección 00:14:33
un objeto igual a esto 00:14:35
pero para hacer eso tiene que hacer muchas cosas dentro 00:14:36
¿qué tendrá que hacer? 00:14:39
empezar a recorrer la colección 00:14:41
recorrerla uno por uno 00:14:43
cuando se encuentra a un objeto 00:14:45
que es igual a S lo elimina 00:14:47
aquí dentro está recorriendo 00:14:48
entonces tenemos un for dentro de otro for 00:14:50
y ambos for 00:14:52
están accediendo a la misma colección 00:14:54
pues esta situación 00:14:56
esta situación 00:14:59
da este error también 00:15:00
aunque no estemos en programación multihilo 00:15:02
es decir, este for each 00:15:04
este for each 00:15:06
ha bloqueado, por decirlo así 00:15:08
este recurso jugadores, lo ha bloqueado 00:15:11
y ha dicho hasta que yo no acabe con él 00:15:13
que nadie más lo modifique 00:15:14
lo puedes consultar 00:15:17
pero no lo puedes modificar 00:15:19
es lo que te está diciendo este for each 00:15:20
hasta que yo no acabe 00:15:22
lo siento pero que nadie lo puede modificar 00:15:24
pues bueno 00:15:27
él no ha acabado 00:15:29
y este remove 00:15:30
ha entrado en él 00:15:32
para quitar uno, eso es una modificación 00:15:34
si hubiéramos entrado para un 00:15:36
Contains o para algo que no modifica 00:15:39
Solo consulta, no habría habido ningún problema 00:15:41
Pero es que este remove está entrando 00:15:42
Dentro de esa colección 00:15:45
Para eliminar 00:15:47
Una cosa, eso es modificar 00:15:49
Estamos cambiando su estado, eliminando 00:15:50
Entonces este ha dicho, no, yo lo tengo bloqueado 00:15:52
Lo siento 00:15:55
Y por eso ha salido ese error 00:15:56
¿Vale? Entonces los for each 00:15:58
Bloquean 00:16:01
Las colecciones 00:16:02
Sobre las que están iterando 00:16:04
Las bloquean, entonces si dentro 00:16:06
de ese forEach, tú tratas de 00:16:09
modificarla, cambiar su estado 00:16:10
eliminando cosas 00:16:12
pues te va a decir no puedes 00:16:14
¿vale? luego no podemos 00:16:15
hacer esto así, esto no se puede hacer así 00:16:18
¿por qué no nos ha dado error antes? 00:16:20
no nos ha dado error antes 00:16:23
porque yo he provocado 00:16:24
un caso de prueba muy particular 00:16:26
que era en el que sólo teníamos estos dos 00:16:28
y he puesto eliminar el último 00:16:31
entonces 00:16:34
en la segunda iteración 00:16:36
el for each de arriba ya ha terminado 00:16:38
entonces ya ha soltado el recurso, ya ha terminado 00:16:40
cuando entra el remove a eliminar 00:16:43
este, el for each de arriba ya había 00:16:45
terminado porque ya esta era 00:16:47
su última iteración 00:16:49
entonces si coincide que el for each 00:16:50
ya ha terminado porque hasta la última 00:16:53
iteración no entra el remove en acción 00:16:55
no pasa nada, pero ese es un 00:16:57
caso muy particular 00:16:59
no es el caso general, yo tengo que poder 00:17:00
borrar de cualquier sitio 00:17:03
luego nunca lo haríamos así 00:17:05
que se hace mucho 00:17:07
y lo hacéis mucho porque a veces cuela 00:17:09
pero no cuela en general 00:17:11
no cuela, esto no está bien hecho por este error 00:17:12
que es difícil de entender 00:17:15
porque se debe a esta cosa tan extraña 00:17:17
se debe a esta cosa tan extraña 00:17:19
y es aquel for each bloquea 00:17:21
esta colección hasta que no ha terminado 00:17:23
con ella 00:17:26
la bloquea para modificaciones 00:17:26
para que otros la modifiquen 00:17:29
no la bloquea para que tú la consultes 00:17:31
o sea yo puedo hacer aquí un system out 00:17:33
de J, de hecho aquí estoy accediendo 00:17:34
para consultar, estoy accediendo 00:17:36
para hacer un getEquipo, aquí no lo ha bloqueado en absoluto 00:17:38
pero es que el remove sí que 00:17:41
modifica la colección, la modifica porque 00:17:42
saca uno, entonces este 00:17:44
bloquea para modificaciones, luego esto no 00:17:46
bueno, pues si 00:17:48
queremos hacer, eliminar jugadores de un equipo 00:17:50
y no podemos hacer esto, porque el forEach 00:17:52
no nos vale, pues ¿qué 00:17:54
tenemos que hacer? pues 00:17:56
iterar de la otra 00:17:58
manera que dijimos que siempre se puede iterar 00:18:00
en las colecciones, que son los iteradores 00:18:02
que de hecho todas las clases colección 00:18:04
implementan iterable 00:18:07
que es la raíz de la jerarquía 00:18:09
implementan iterable 00:18:11
y al implementar iterable 00:18:13
están obligadas a suministrar un método iterador 00:18:15
para sacar un iterador, etc. 00:18:18
Luego esto nunca lo haríamos así 00:18:20
porque el forEach bloquea 00:18:22
la colección 00:18:38
para evitar que sea modificada 00:18:41
Ficada 00:18:45
Hasta que no termine de iterar por ella 00:18:53
Cuando ha terminado de iterar por ella, ya no 00:18:55
¿Vale? Luego nunca lo haríamos 00:18:57
De esta manera 00:19:07
Así no lo haríamos 00:19:08
Es que no hay for de índice en un conjunto 00:19:10
Claro, no hay for de índice 00:19:15
Claro, vale 00:19:17
Vale, pues entonces, iteraríamos con un iterador 00:19:23
Bueno, pues iterar con un iterador 00:19:30
Ya sabemos que esto funciona 00:19:33
generamos el objeto iterador 00:19:35
uno lo llame como quiera 00:19:50
y este se generaba a través del método 00:19:51
iterator de la colección 00:19:54
vale, cuidado cuando importéis 00:19:56
iterator que es de java útil 00:20:05
estamos hablando de colecciones 00:20:06
luego el paquete java útil 00:20:08
y ahora este iterador tenía dos métodos 00:20:10
con los que trabajábamos, el hash next 00:20:12
para ver si había siguiente 00:20:14
y el next para ya 00:20:16
coger uno en concreto 00:20:18
entonces la forma de trabajar con el iterador 00:20:19
Pues siempre es esta 00:20:22
Mientras tenga un siguiente 00:20:24
Porque el iterador se queda colocado siempre antes del primero 00:20:26
Siempre antes del primero 00:20:29
Pues mientras tenga un siguiente 00:20:30
Pues nos colocamos 00:20:33
En el que toca 00:20:35
Y para colocarnos en él lo hacemos así 00:20:37
Ya estoy en el jugador J 00:20:43
Next 00:20:48
Cada uno 00:20:49
En el siguiente 00:20:51
Ahora, ¿qué queremos hacer con este jugador? 00:20:53
Ver si es uno de los que toca borrar 00:20:56
Si j.get 00:20:58
Equipo 00:21:01
Resulta que es igual 00:21:02
Al equipo de búsqueda 00:21:04
Si este es uno de los que toca borrar 00:21:09
Vale, pues aquí 00:21:11
No hacemos el remove ni hacemos nada 00:21:13
¿Por qué? Porque iterador nos ofrece precisamente 00:21:15
Un método 00:21:17
Pensado precisamente para esto 00:21:18
Nos ofrece pocos métodos 00:21:20
Están pensados para avanzar 00:21:23
Pues nos ofrece el método remove 00:21:24
el iterador nos ofrece el método remove 00:21:26
que nos dice, oye, borra 00:21:29
en el que estás colocado en ese momento 00:21:31
en el que estás colocado 00:21:34
después de haber hecho el next 00:21:35
¿en cuál estamos colocado? en este 00:21:36
bórralo 00:21:38
y esto ya el iterador ya está pensado 00:21:40
aquí no hay un for each 00:21:43
está ya coordinado con todo su funcionamiento 00:21:45
para que el iterador se actualice 00:21:47
y ahora ya se actualice 00:21:50
para que su siguiente sea el que toque 00:21:51
esto ya está todo coordinado 00:21:53
aquí no hay varios accediendo a lo mismo 00:21:54
entonces esto ya sí que nos va a funcionar 00:21:56
para cualquier caso de prueba 00:22:01
entonces la forma más genérica de iterar 00:22:02
un iterador que yo saco de aquí 00:22:06
mientras tenga siguiente, cojo el que toque 00:22:09
y hago con él lo que sea 00:22:12
con la ventaja de que si lo que quiero es borrar 00:22:13
pues lo borro así 00:22:17
a través del iterador, no lo borro así 00:22:19
Jolines, que no acierto con la R 00:22:24
¿Vale? No lo borro así como antes 00:22:33
Borrando este el J 00:22:39
Porque estaríamos en las mismas 00:22:40
Lo borro a través del propio iterador 00:22:44
Así lo borro, así no tengo 00:22:47
Dos recursos accediendo a lo mismo 00:22:52
El remove que accede con un for literador por otro 00:22:54
No, es el propio iterador 00:22:56
El que me lo gestiona todo 00:22:58
¿Vale? 00:22:59
¿Vale? Este código entendido 00:23:07
Entonces 00:23:09
Esta es la principal utilidad 00:23:10
del iterador, pues el poder 00:23:13
modificar a la vez 00:23:15
que vas iterando, que no puedes con un 00:23:18
for 00:23:19
entonces si ahora ejecutamos esto con todos 00:23:20
el caso de prueba que antes no nos ha ido 00:23:23
que era este dándole Madrid que tenía 00:23:25
entre medias, pues este sí que nos 00:23:27
los va a borrar, comprobamos 00:23:29
si hay jugadores en un equipo, este, no hay jugadores 00:23:34
si existe un jugador 00:23:36
este, no hay, vamos a eliminar 00:23:38
todos los jugadores de no sé dónde 00:23:40
eliminados, ah no, nombre 00:23:42
Eliminamos jugador, este, vale 00:23:44
Y ahora, esos son los que tenemos 00:23:46
Ahora vamos a eliminar todos los jugadores 00:23:49
De Madrid 00:23:51
Que con la versión anterior 00:23:52
La que nos daba el error de modificación 00:23:54
Ahora con esta versión 00:23:57
No nos da ningún error 00:23:58
Y efectivamente nos los ha eliminado a todos 00:24:00
¿Vale? Los ha eliminado a todos 00:24:02
Los que había 00:24:04
¿Vale? 00:24:06
Bueno, pues no os olvidéis del iterador 00:24:17
Más que nada porque es imprescindible 00:24:18
cuando queremos borrar varios 00:24:21
de una colección 00:24:23
es que para un solo dato 00:24:25
tienes el remove 00:24:30
tú le pasas el dato 00:24:31
que quieres borrar, pero completamente caracterizado 00:24:34
el equipo y el número, completamente caracterizado 00:24:36
porque si solamente tienes un dato 00:24:38
no tienes la garantía de que sea solo uno 00:24:40
entonces no lo puedes hacer con el remove 00:24:41
vale 00:24:43
vale, pues esto es un poco, más o menos 00:24:44
en realidad, todos los 00:24:48
vericuetos y detalles 00:24:51
uh, son los dos y cuarto ya 00:24:52
eso se ha pasado tan rápido como a mi 00:24:54
estos son un poco todos los 00:24:59
intríngulis del hashet 00:25:01
vale 00:25:03
el linked hashet 00:25:05
podemos cambiar este código 00:25:07
y todo lo que hemos dicho 00:25:10
todo aplica 00:25:11
exactamente igual al linked hashet 00:25:14
es que 00:25:16
exactamente igual 00:25:18
funcionan igual por dentro 00:25:19
igual, bueno con algún matiz que ahora decimos 00:25:21
necesitan hash code equals 00:25:24
porque el linked hash también es una tabla hash 00:25:26
todo lo mismo 00:25:28
si yo quiero eliminar y no puedo hacer el for 00:25:30
y todo igual, todo igual, puedo cambiar el linked 00:25:32
hash set y no he cambiado el programa 00:25:34
es igual 00:25:36
¿cuál es la única diferencia? que el linked hash set 00:25:37
mete un doble 00:25:40
enlace por dentro, mete 00:25:42
chorraditas para 00:25:44
conservar en la iteración 00:25:46
el mismo orden de la inserción 00:25:48
es lo único que cambia, lo único 00:25:50
entonces si hacemos este programa antes 00:25:52
cuando hemos visto lo que ocurría 00:25:55
no se conservaba el orden de iteración 00:25:57
con el que habíamos metido 00:25:59
no se conservaba, que nos daba igual 00:26:01
con el linked hash set 00:26:03
si ejecutamos 00:26:05
esto, veremos como a la hora de 00:26:07
mostrarlo, el orden 00:26:09
demostrado conserva el que yo he metido 00:26:11
simplemente conserva el orden 00:26:13
por si eso me importa a mi, me interesa 00:26:15
mi aplicación, nada más 00:26:17
vamos a comprobarlo 00:26:18
probarlo. 00:26:22
¿Veis? 00:26:24
Cambiándolo a linked hash set, 00:26:26
este es el orden en el que yo lo inserté. 00:26:28
Ya está. Es la única diferencia. 00:26:31
Que el funcionamiento por dentro 00:26:33
permite que cuando yo itero, 00:26:34
me lo muestra en el orden en el que inserté. 00:26:36
Si es que eso veo que es útil, porque la aplicación 00:26:38
está haciendo muchas veces recorridos y me gusta ese orden 00:26:40
o lo que sea. Nada más. 00:26:42
Venga, bueno, ahora vale. Ahora sí que lo vamos 00:26:44
a dejar aquí. 00:26:46
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
12
Fecha:
10 de marzo de 2024 - 14:23
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
26′ 48″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
143.01 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid