Saltar navegación

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

Clase 08-03-24 - 2 - 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 00:00:00
Venga, pues nada 00:00:03
Vamos a meter jugadores en la colección 00:00:07
Bueno, como tenemos un constructor 00:00:09
Con parámetros 00:00:19
Podemos hasta hacerlo así 00:00:19
Jugador 1 00:00:22
Nombre 00:00:34
Luis 00:00:39
Vale 00:00:40
Entonces si metemos otro 00:00:54
En esta situación está claro 00:00:57
Que no va a haber ningún problema 00:01:04
Ya tenemos los dos jugadores 00:01:06
Y podemos hacer 00:01:08
Tranquilamente 00:01:13
En la colección 00:01:14
Ahí, vale 00:01:23
Si ejecutamos esto, pues nos va a decir dos 00:01:35
Obviamente, en la colección 00:01:41
Hay dos, vale 00:01:43
Bueno, lo que nos podíamos esperar 00:02:01
Vale, si metemos a este dos veces 00:02:05
Pues hombre, os podéis 00:02:13
Esperar ya con todo lo que sabemos 00:02:20
De clases y objetos 00:02:21
Que en contra de todas nuestras 00:02:23
Intuiciones 00:02:26
me va a seguir diciendo que hay dos 00:02:26
¿por qué? 00:02:29
porque para él no son iguales 00:02:32
no son iguales 00:02:34
la clase jugador 00:02:36
es una clase de la que instanciamos objetos 00:02:37
entonces jugador 00:02:41
yo no le he puesto dentro ningún criterio de igualdad 00:02:43
entonces como no le he puesto dentro ningún criterio de igualdad 00:02:45
tiene el de object 00:02:47
y el de object es 00:02:49
solo son iguales dos objetos 00:02:51
cuando están directamente en la misma dirección de memoria 00:02:53
en la misma 00:02:56
entonces efectivamente para este set 00:02:57
estos objetos 00:03:00
son distintos porque están en direcciones 00:03:01
distintas de memoria 00:03:04
pero eso no se corresponde con la interpretación 00:03:05
real de las aplicaciones 00:03:09
si uno se ha equivocado 00:03:11
y ha metido 00:03:13
dos veces el mismo 00:03:15
lo normal es que esto 00:03:16
lo haya hecho por error 00:03:19
porque si has elegido un objeto 00:03:20
si has elegido un conjunto como colección 00:03:22
tú lo que no querías era que hubiera duplicados 00:03:25
porque no los necesitas, entonces si estás 00:03:27
metiendo al mismo dos veces, lo normal es que lo hayas 00:03:29
hecho por error porque no quieres eso 00:03:31
y este y este son el mismo 00:03:32
y lo tienen que ser porque si tú has decidido 00:03:34
que los jugadores se caracterizan 00:03:37
por número, nombre y equipo 00:03:39
has decidido que eso lo caracteriza 00:03:42
y dos jugadores tienen 00:03:43
el mismo número, nombre y equipo 00:03:45
es que son el mismo 00:03:47
porque si no son el mismo, entonces 00:03:48
has hecho mal el diseño, entonces te falta una cuarta 00:03:51
propiedad, te falta una cuarta 00:03:53
que es la que los caracteriza, si has 00:03:55
decidido esas tres, es porque esas tres 00:03:57
lo identifican, o las tres 00:03:59
o una de ellas o dos 00:04:01
pero no en cualquier caso si las tres son iguales 00:04:03
vale 00:04:05
entonces no queremos que funcione así la aplicación 00:04:07
si yo he escrito esto dos veces es porque 00:04:09
es el mismo obviamente 00:04:11
claro, lo que nos ha faltado como ya sabemos 00:04:12
es que aquí no hay ningún criterio de igualdad 00:04:15
vale, pero aquí ahora 00:04:17
tenemos el problema de que 00:04:19
estos objetos 00:04:21
jugadores van a un 00:04:23
haset, no van a una lista 00:04:25
van a un haset 00:04:27
entonces al ir a un haset 00:04:29
el haset los va a ir ubicando 00:04:31
en una tabla has 00:04:33
con dos pasos, primero le hace una función de has 00:04:35
para ir a una posición de la tabla 00:04:37
y luego a partir de ahí 00:04:38
si ya hay alguien ahí lo va desbordando 00:04:40
con una lista enlazada, lo hace a través de dos pasos 00:04:43
entonces él para 00:04:45
ubicar el objeto 00:04:46
y también para ver si ese objeto 00:04:48
ya existe o no ha pasado 00:04:51
hace función de has 00:04:52
y luego equals, pues hay que ofrecerle esas dos cosas 00:04:54
hay que decirle esas dos cosas, cuál es la función de hash que tiene que aplicar 00:04:58
y cuál es el equals, hay que decírsela, hay que decírsela porque si no el hash 00:05:02
no va a funcionar correctamente, vale, va a usar el de object 00:05:06
y el de object tira de que objetos en direcciones 00:05:10
de memoria distintas son distintos, aunque las propiedades sean iguales 00:05:14
entonces aquí lo que nos faltaría para hacer bien 00:05:18
esta aplicación es en jugador 00:05:22
dado que es un hash set 00:05:24
en jugador, poner esos 00:05:26
dos pasos, el hashCode y el idPath, los dos 00:05:28
entonces ahora 00:05:30
ya sí, pues 00:05:32
nosotros tendríamos que hacer este método 00:05:33
y cuando hacemos el 00:05:38
método, tenemos que decidir 00:05:42
qué es lo que identifica de forma unívoca 00:05:44
a los objetos de mi aplicación 00:05:46
eso de nuevo, es un tema de 00:05:48
análisis de la aplicación, de análisis de la realidad 00:05:50
mis jugadores 00:05:52
si tienen el mismo número son el mismo 00:05:54
no, porque pueden estar en equipos distintos 00:05:56
si tienen el mismo número 00:05:59
entonces que los caracteriza para que sean igual 00:06:00
si tienen el mismo número y el mismo 00:06:03
nombre, son el mismo 00:06:05
nombre no, porque puede haber en diferentes 00:06:06
equipos dos jugadores con mismo 00:06:08
número que se llamen igual, entonces que les 00:06:10
identifica, el mismo número y el mismo 00:06:12
equipo 00:06:15
pues sí, podríamos decidir 00:06:15
podría ser otro, es que esto ya depende 00:06:18
de nuestra aplicación, tendríamos que analizarla 00:06:20
con que estamos trabajando, pero imaginaos que en esta 00:06:22
decimos, vale, pues 00:06:25
cuando yo tengo dos jugadores con el mismo 00:06:27
número y en el mismo equipo, es el mismo 00:06:29
porque no tengo en un equipo 00:06:31
dos jugadores con el mismo número, es imposible 00:06:33
porque así me lo está diciendo el que me ha pedido la aplicación 00:06:35
me está diciendo que no puede 00:06:37
haber en un equipo dos jugadores con el mismo número 00:06:39
pues entonces yo concluiría 00:06:41
vale, pues venga 00:06:43
mi igualdad va a estar basada 00:06:44
en equipo y en número 00:06:47
va a estar basada en equipo y en número, nombre 00:06:48
no hace falta 00:06:51
Pues nada, marcamos las dos 00:06:51
Y él ya me ha generado aquí el hashCode y el equals 00:06:55
El equals lo sabemos de memoria 00:06:59
Ya sabemos que es un método que él sobrescribe de la clase object 00:07:01
Por tanto, respeta su cabecera idéntica de object 00:07:04
Respeta su cabecera 00:07:08
Y ya sabemos lo que hace 00:07:09
¿Vale? 00:07:11
Entonces, usa el método equals este 00:07:13
Al que le pasa equipo 00:07:17
Y este método equals, pues si uno lo mira aquí 00:07:18
ahora ya compara las dos propiedades 00:07:21
la A y la B 00:07:24
vale 00:07:25
entonces 00:07:27
el equals 00:07:30
y el object 00:07:33
que hace, pues llama 00:07:35
él nos implementa esta por defecto 00:07:36
esta por defecto, que uno quiere implementar 00:07:39
otra función de hash 00:07:41
también puede, nos implementa esta 00:07:42
por defecto basada en equipo y en número 00:07:45
nos implementa esta 00:07:48
que uno podría entrar aquí 00:07:49
que es esta de aquí y uno apuntará aquí 00:07:51
a ver cómo lo ha hecho 00:07:54
que lo hace usando este numerito 00:07:56
porque es un número primo que optimiza 00:07:58
no sé qué historia 00:08:01
bueno, usa esta implementación 00:08:02
por defecto basada en el número 31 00:08:06
que el número 31 00:08:07
es que cumple una propiedad interesante 00:08:09
no recuerdo la cual es, en matemáticas 00:08:11
de números primos 00:08:13
y usa este porque optimiza no sé qué historias 00:08:14
vale, bueno 00:08:17
nosotros a efectos prácticos nos quedamos 00:08:19
siempre con esta implementación 00:08:21
y ya está 00:08:22
nos quedamos con esta 00:08:24
y ahora ya sí 00:08:26
mi clase jugador 00:08:28
tiene fijado su criterio de igualdad 00:08:31
pero no sólo 00:08:33
el de igualdad genérico 00:08:35
para listas y para todo, sino el de 00:08:37
el hash set, porque el del hash set 00:08:39
es el único que va a dos pasos 00:08:41
el del hash set 00:08:42
usa primero esta y luego esta 00:08:44
cualquier otra 00:08:47
aplicación de java para ver si dos objetos 00:08:49
son iguales, lo que hace es llamar al 00:08:51
equals y ya está, llamar al equals 00:08:53
pero el hashSet 00:08:55
por como está hecha por dentro, necesita 00:08:57
las dos, necesita las dos 00:08:59
luego el hashSet es la única clase que hemos 00:09:01
visto hasta ahora, la única 00:09:03
que para ver si dos 00:09:04
objetos son iguales, necesita 00:09:07
llamar en cadena los dos métodos 00:09:09
jasco de equals, bueno pues 00:09:11
como ya lo tenemos implementado 00:09:13
pues ahora ya 00:09:15
este main, ya sí que no 00:09:17
meterá el segundo, aunque le cambiáramos 00:09:19
de nombre, imaginaos que 00:09:21
le cambiamos de nombre 00:09:25
para el hasher, ahora 00:09:26
este y este son iguales 00:09:29
porque comparten número y equipo 00:09:31
entonces él ya interpreta que 00:09:33
bueno, este puedes meterlo, pero es que 00:09:35
te has equivocado, porque estás metiendo al mismo 00:09:37
otra vez, aunque le des otro nombre 00:09:39
pues si le das otro nombre es porque te has 00:09:41
equivocado, porque le has cogido el nombre de otra manera 00:09:43
pero es que es el mismo 00:09:45
entonces si ahora ejecutamos esto 00:09:46
Pues efectivamente ahora solo ha metido uno 00:09:49
El segundo le ha ignorado 00:09:54
¿Vale? 00:09:56
Pero tenemos que tener los dos métodos implementados 00:09:58
Vamos a quitar el hashCode 00:10:01
¿Vale? 00:10:03
Entonces si quitamos el hashCode 00:10:18
Y volvemos a ejecutar esto 00:10:20
No ha detectado la igualdad 00:10:21
Y el equals está 00:10:26
Pero al hashSet no le vale el equals 00:10:27
Si no tiene el hashCode 00:10:31
Usa el hashCode de object 00:10:33
Y el hashCode de object 00:10:35
objetos diferentes, me da igual 00:10:37
cuáles sean sus propiedades, se van a sitios 00:10:39
diferentes, con lo cual 00:10:41
luego ya ni usaría el equals 00:10:44
entonces, si yo no tengo el hashCode 00:10:45
aunque tenga un equals muy bien hecho 00:10:49
el hashSet me va a funcionar mal 00:10:51
me va a funcionar mal 00:10:53
¿vale? 00:10:55
el hashSet necesita que estén 00:10:56
los dos para detectar la igualdad 00:10:59
los dos, si no tengo 00:11:01
este, nada 00:11:03
¿vale? vale, el hashCode 00:11:04
en realidad 00:11:11
podría ser, repito, cualquier función 00:11:11
de hash que uno haga, siempre y cuando 00:11:16
sea inyectiva 00:11:18
cualquiera 00:11:19
es decir, inyectiva significa 00:11:21
pues bueno, que aún 00:11:24
en el dominio origen 00:11:26
te dé solo un valor, no te puede dar varios 00:11:27
es decir, si a mí me da la gana 00:11:30
hacer una función de hash que sea esta 00:11:32
por ejemplo 00:11:33
pues es una función de hash válida también 00:11:34
pero es muy mala 00:11:37
porque todos los objetos 00:11:40
van a una única posición 00:11:42
con lo cual es como 00:11:44
yo meto el primero ahí 00:11:46
y los demás ya van desbordando 00:11:48
todos son a lista enlazada, entonces esta 00:11:50
combinación 00:11:52
computacionalmente es como una lista enlazada en realidad 00:11:53
pero como 00:11:56
válida es 00:11:58
porque es una función de hash 00:11:59
válida, y si yo ejecuto 00:12:02
esto, pues como veis ha funcionado 00:12:04
perfectamente 00:12:08
solo hay uno, he detectado que son 00:12:09
iguales 00:12:11
vale, solo hay uno aquí, estupendo 00:12:12
ha funcionado bien 00:12:16
lo que pasa es que es una función de hash 00:12:17
repito, que lo que 00:12:20
implica por dentro es que 00:12:22
todos los elementos 00:12:24
van al mismo numerito y a partir de ahí 00:12:25
cuelgan todos de la mano en lista enlazada 00:12:28
pues vaya, no 00:12:30
computacionalmente es una lista 00:12:31
enlazada, ¿para qué? 00:12:34
entonces hombre, mejor usamos la función 00:12:36
de hash 00:12:38
que me ofrece él, que está optimizada 00:12:38
para los casos genéricos 00:12:42
bueno, pues entonces 00:12:44
aquí solamente habría uno 00:12:52
por tanto, si yo a este le cambio el equipo 00:12:56
ahora ya sí que lo metería, porque como es de otro equipo 00:12:57
ahora ya sí que interpreta que hay dos 00:13:03
bueno, pues esto es lo más crítico 00:13:07
en conjuntos, el tener claro 00:13:09
que no admite elementos iguales 00:13:13
y no es que te vaya a dar un error, es simplemente 00:13:15
que no lo mete, no lo mete, ya está 00:13:17
y tú puedes contar con que sí y luego 00:13:19
siete horas después 00:13:21
la aplicación no te ha funcionado 00:13:23
te llega un error y no tienes ni idea de por qué 00:13:25
bueno, porque lleva arrastrando 00:13:26
un error de partida que tú crees que hay unos datos 00:13:28
que no hay, pues hay que saber 00:13:31
cómo funciona, ¿vale? 00:13:32
pues esto es lo más crítico 00:13:35
esto y que para que el headset 00:13:37
interprete la igualdad correctamente 00:13:39
tienen que ser los dos 00:13:41
los que estén, este 00:13:43
y este 00:13:44
porque si no usa los 00:13:46
de object y los de object son 00:13:49
igualdad es la misma dirección de memoria 00:13:50
vale 00:13:52
bueno 00:13:54
vamos a meterle algún 00:13:59
otro para poder recorrer un poquito 00:14:04
más, vale 00:14:05
bueno 00:14:27
entonces esto, si yo quiero recorrer 00:14:30
para consultar solamente 00:14:32
pues puedo 00:14:33
Podemos ser vagos y hacerlo con un for each 00:14:35
¿Vale? Que ya sabéis 00:14:38
Cómo funciona esto 00:14:46
Pues la variable j en cada iteración va siendo 00:14:47
Cada uno de los elementos 00:14:50
Entonces aquí efectivamente me mostrará 00:14:51
Pues 00:14:54
Si mostramos 00:14:55
El nombre y el equipo 00:14:57
Pues me mostrará 00:15:00
Los tres, claro 00:15:09
¿Vale? Esos son los tres jugadores que ha metido 00:15:10
Vale 00:15:20
Aquí no puedo recorrer 00:15:21
No puedo recorrer con un get 00:15:25
ya lo dijimos el otro día final de clase 00:15:27
aquí 00:15:30
jugadores 00:15:31
.get no existe 00:15:33
no existe 00:15:36
jugadores.get por posición, por qué posición 00:15:37
no existe 00:15:40
yo aquí lo que puedo hacer es recorrer y mostrar 00:15:41
lo que hay, pero recuperar el que hay 00:15:44
en una posición no existe, yo los tengo todos ahí 00:15:46
y lo que puedo hacer es 00:15:48
recorrer para ver los que hay 00:15:50
tengo otros métodos para hacer otras cosas 00:15:51
que quiero ver 00:15:54
Si hay un jugador 00:15:56
Que 00:15:58
Que sea de un equipo 00:16:01
Por ejemplo 00:16:04
¿Vale? Vamos a suponer que queremos hacer esto 00:16:05
¿Existe algún jugador de un equipo dado? 00:16:17
Bueno, pues entonces podríamos 00:16:20
No quiero 00:16:23
Se me ha ido esto 00:16:28
Pues por ejemplo, podríamos decir 00:16:31
Introduzca 00:16:40
Nombre equipo 00:16:44
y ahora leemos el nombre del equipo 00:16:46
vamos a ponerle 00:16:52
lo de leer 00:16:54
y ahora pues 00:16:55
podríamos hacer 00:17:23
tenemos el método contains que funciona exactamente 00:17:24
igual que en listas 00:17:27
si jugadores.contiene 00:17:28
ah no, perdón 00:17:32
contains no porque 00:17:35
para ver si hay un jugador 00:17:36
puede haber más de uno 00:17:40
si contiene un nombre con un equipo 00:17:41
la igualdad no va por equipos 00:17:43
Entonces aquí para hacer esta funcionalidad tendríamos que recorrer, y ahora ya sí, haríamos si j.getEquipo equals el equipo que me han dado, pues entonces ya podríamos poner está igual a true, y ya está, y lo de siempre, y si está, ¿vale? 00:17:45
Entonces, jugadores de este equipo de aquí, puede haber más de uno, puede haber más de uno, ¿vale? Entonces, aquí el contains no aplica, porque el contains es para ver si existe un jugador igual a ese, un jugador igual a ese, y es un conjunto, si existe solo puede haber uno, ¿vale? 00:18:46
entonces, en este caso la igualdad 00:19:08
venía dada por equipo 00:19:10
y número, el contain 00:19:12
se aplicará cuando queremos ver si existe 00:19:14
un jugador de un equipo y un número 00:19:16
concreto, porque ese sí que solamente va a haber uno 00:19:18
vale, entonces 00:19:20
un momento, vamos a probar esto, dándole 00:19:24
Sevilla 00:19:26
por ejemplo 00:19:28
existe 00:19:29
porque me sale, ah 00:19:42
he puesto el ELSE 00:19:44
vale 00:19:45
ahí, vale, efectivamente 00:19:47
me salía así este jugador, luego me decía esto 00:19:52
pero no lo había puesto en el else, claro 00:19:53
vale 00:19:55
entonces ahora 00:19:57
si queremos ver si existe un jugador 00:20:00
con número y equipo 00:20:02
esto ya es otra cosa 00:20:03
número y equipo es lo que define a un jugador 00:20:05
univocamente 00:20:19
es lo que define a un jugador univocamente 00:20:20
entonces aquí sí que podemos usar el contains 00:20:22
porque el contains le das un objeto 00:20:24
y te dice si existe uno igual a ese 00:20:26
igual a ese 00:20:29
y la igualdad se hace 00:20:30
en virtud de número y equipo 00:20:33
entonces aquí 00:20:35
pues si leyéramos 00:20:37
le pidiéramos las dos cosas 00:20:38
número y equipo 00:20:41
le pediríamos las dos cosas 00:20:43
nombre equipo 00:20:45
y ahora pedimos aquí 00:20:47
un tolerante 00:20:48
vale, pues ahora aquí sí que podríamos hacer 00:21:13
nos hacemos 00:21:16
un objeto jugador 00:21:18
no me gusta 00:21:20
Nos hacemos un objeto jugador 00:21:29
Con esos dos valores 00:21:32
Set equipo 00:21:36
Y el número 00:21:44
Y ahora ya sí que podemos hacer 00:21:50
No hace falta recorrer nada 00:21:52
Si jugadores contiene 00:21:54
Uno igual a este 00:21:58
Pues puedo poner el jugador está 00:22:02
Y si no 00:22:06
¿Vale? 00:22:10
Entonces aquí se aplica el contains 00:22:25
El contains ¿Qué hace? 00:22:26
Coge este objeto y mira a ver si hay 00:22:28
alguno igual a ese en esta colección 00:22:30
si lo hay devuelve true 00:22:32
igual a ese que significa que sean 00:22:33
iguales en equipo y en número 00:22:37
nada más, en nombre no 00:22:39
por eso solamente le he fijado el equipo y el número 00:22:40
solo, porque el nombre me da igual 00:22:43
para mirar si es igual a este 00:22:45
solamente va a mirar el equipo y el número 00:22:48
entonces si yo le paso 00:22:49
uno y Madrid me va a decir que sí 00:22:52
y si luego le paso otra cosa me va a decir que no 00:22:55
bueno, esto es para lo primero 00:22:57
que hemos hecho, el jugador está 00:23:05
y era nombre de equipo 00:23:07
pues Madrid y 1, el jugador está 00:23:08
pero si hiciera esto mismo 00:23:14
con cualquier equipo 00:23:15
y ahora introduzca nombre equipo 00:23:19
cualquier equipo 1 00:23:21
pues no está 00:23:22
¿vale? porque este sí pero este no 00:23:24
¿vale? entonces 00:23:27
en cuanto a borrados 00:23:33
el remove 00:23:35
tenemos, por ejemplo 00:23:37
vamos a 00:23:39
eliminar 00:23:40
un jugador 00:23:44
eliminar un jugador 00:23:46
como cada jugador se caracteriza 00:23:48
por 00:23:50
número y equipo, pues vamos a hacer 00:23:51
esta primera versión dado 00:23:54
número y equipo, que es lo que caracteriza 00:23:55
cada jugador, pues vamos a borrar 00:23:58
al jugador 1 del equipo tal 00:23:59
pues vamos a 00:24:02
volver a pedir los datos 00:24:04
vale 00:24:06
y ahora ya podemos 00:24:24
hacer perfectamente 00:24:27
jugadores 00:24:28
punto remove 00:24:30
habría que hacer un jugador con estos datos 00:24:34
vamos a volver a 00:24:36
hacer esto otra vez 00:24:38
como esta variable ya está declarada 00:24:40
no hace falta que la declare, la reutilizo 00:24:46
vale, entonces este método 00:24:48
eliminará 00:24:59
un jugador igual a este 00:25:00
según el criterio de igualdad 00:25:03
que es equipo y número, con lo cual el nombre 00:25:05
no se lo hemos fijado aquí porque no lo necesitamos 00:25:07
nuestros datos de entrada eran equipo y número 00:25:09
Entonces este borrará un jugador 00:25:10
Igual a ese, si es que existe 00:25:13
Y si no, no 00:25:15
Entonces vamos a volver a recorrerla aquí 00:25:16
Vamos a volver a recorrer la colección 00:25:19
Para ver si lo ha borrado 00:25:23
Perdón, no era esto lo que yo quería 00:25:24
Copiar 00:25:37
Venga, pues vamos a 00:25:39
A volver a recorrerla 00:25:41
Esto, perdón 00:25:43
Es que no lo tengo hecho 00:26:09
Este método lo puse solo para 00:26:15
poner la situación en la cual esto importaba 00:26:18
aquí era importante ponerlo 00:26:20
pero es que no lo tengo hecho 00:26:21
vale, pues nada, si hacemos esto 00:26:23
esto era 00:26:26
lo del principio para ver si 00:26:32
existe jugador de este equipo o no, que va a decir que no existe 00:26:33
esto es para 00:26:36
decirme si existe uno 00:26:37
con ese número 00:26:39
y ese equipo que vamos a ponerle 00:26:41
cualquier cosa que va a decir no está 00:26:43
y ahora venía lo de borrar 00:26:45
pues vamos a borrar 00:26:48
de Madrid 00:26:49
al jugador 1 00:26:53
que sí que existía, de Madrid al jugador 1 00:26:55
y efectivamente cuando luego me muestra 00:26:58
lo que hay, no está ya el primero que metimos 00:27:00
porque lo he eliminado 00:27:02
luego el remove me vale para borrar 00:27:03
un objeto igual a otro 00:27:07
si es que existe, si no nada 00:27:09
un objeto igual a otro y se acabó, punto pelota 00:27:11
vale 00:27:13
pero qué pasa si quiero borrar 00:27:15
por ejemplo todos los 00:27:18
jugadores de un equipo 00:27:19
Todos los jugadores de un equipo 00:27:20
No los puedo usar con el remove 00:27:23
El remove es para borrar un jugador igual al que yo le doy 00:27:25
Y el criterio de igualdad exige equipo y número 00:27:28
Entonces si yo quiero borrar todos los de un equipo 00:27:30
No puedo borrar así 00:27:33
¿Vale? 00:27:35
Bueno, vamos a hacer eso 00:27:37
Vamos a suponer que ahora queremos 00:27:38
Eliminar, más que borrar, que queda feo 00:27:40
Todos los jugadores de un equipo 00:27:43
Vale, pues entonces 00:27:50
¿Qué nos podríamos plantear hacer? 00:27:55
¿Qué os plantearíais hacer? 00:27:57
Pues 00:28:00
Podríamos hacer 00:28:01
A ver, lo que pasa es que como 00:28:05
Ya empieza a ser un main muy largo y si luego lo vamos a subir 00:28:06
Para que lo tengáis como ejemplo de set 00:28:09
Lo vamos a sacar a métodos 00:28:10
De añadir, borrar, para que quede más 00:28:12
Más claro todo 00:28:15
¿Vale? Entonces vamos a hacernos 00:28:16
Primero el método 00:28:19
De mostrar jugadores 00:28:21
Para tener el for 00:28:22
Y así dejamos este proyecto colocado 00:28:25
Y repasamos 00:28:27
Venga, pues para mostrar jugadores 00:28:28
Le paso un set 00:28:31
Y que me va a hacer este método 00:28:32
Pues me va a recorrer el set 00:28:33
Para cada jugador 00:28:34
En el set que yo le paso 00:28:39
Que me muestre 00:28:42
J.todo 00:28:45
Venga, el número 00:28:47
Nombre 00:28:57
Y el equipo 00:29:01
Ala, ya tengo mostrar jugadores 00:29:05
Vale 00:29:11
Vamos a hacer el de 00:29:12
¿Qué más hemos hecho por aquí? 00:29:18
El de insertar jugador 00:29:21
El de insertar jugador 00:29:23
Pues venga 00:29:27
Vamos a hacer 00:29:29
Dado un objeto jugador 00:29:30
Este 00:29:42
Obviamente tiene poco que hacer 00:29:42
Ya lo hemos probado 00:29:47
Que es, ah, y le pasamos la colección 00:29:49
en la que tiene que insertarlo, claro 00:29:52
insertar jugador en esta colección 00:29:53
pues este método 00:29:59
cortito, pero así lo tenemos 00:30:00
aparte, será en la colección 00:30:02
que me han pasado, en la colección 00:30:04
jugadores.add 00:30:06
el jugador j 00:30:08
ya está, vale 00:30:09
ya sabemos como funciona 00:30:12
no inserta los 00:30:14
duplicados, siendo el criterio 00:30:16
de duplicado que el hashCode y el equals 00:30:18
den lo mismo 00:30:20
vale, que más 00:30:22
hemos hecho en el main 00:30:24
pues en el main hemos insertado 00:30:26
y después de insertar hemos mostrado 00:30:29
que ya lo tenemos 00:30:31
puesto en dos métodos 00:30:32
vale, ahora hemos 00:30:34
hecho ver si existe de un 00:30:37
equipo dado, vamos a hacerlo en un método aparte también 00:30:39
aquí static, porque si no voy a poder llamar 00:30:41
pues vamos a hacer 00:30:45
un método boolean, static 00:30:50
también, que sea 00:30:52
existen jugadores 00:30:58
en el equipo que yo le dé 00:31:00
entonces, a este le pasamos 00:31:02
y el set 00:31:06
claro, vale, y aquí 00:31:14
¿qué hemos hecho? pues vamos a 00:31:29
copiar y pegar lo que hemos hecho, ahora lo 00:31:31
repasamos todo para que 00:31:33
vale, pues 00:31:35
hemos pedido nombre de equipo 00:31:37
y hemos hecho este código 00:31:38
vale, o sea, hemos pedido 00:31:43
nombre de equipo 00:31:49
ah, bueno, no, es que se lo estamos pasando por parámetro 00:31:49
perdón, perdón, que se lo estamos pasando por parámetro 00:31:56
Vale, pues hacíamos esto 00:31:58
Y ahora ya return 00:32:01
Está 00:32:02
Este es nuestro método de existir jugadores 00:32:04
Hace el boolean 00:32:07
Y si detecta uno cuyo equipo es igual que el que le paso 00:32:09
True, devuelve 00:32:12
Vale, esto sería para 00:32:13
Ver si existen jugadores de ese equipo 00:32:15
Vale, que más cosas hemos hecho en el main 00:32:17
¿Existe un jugador con número y equipo dado? 00:32:18
Esto hemos hecho 00:32:24
Pues vamos a 00:32:25
Hacer este método 00:32:27
Existe 00:32:31
Jugador, que le vamos a llamar 00:32:41
Al jugador habría que, a este método 00:32:48
Habría que pasarle el número 00:32:49
El equipo, porque son las dos 00:32:51
Cosas que lo caracterizan de forma única 00:32:53
Y luego el set 00:32:55
En el que tiene que mirar 00:32:57
Vale, pues este mucho más fácil 00:32:59
Porque este 00:33:14
Aquí ya sí que se podía hacer el contains 00:33:16
Luego aquí hacemos directamente 00:33:18
Devuelve 00:33:20
Jugadores 00:33:23
Contains 00:33:24
El auxiliar que me he hecho aquí 00:33:26
Vale 00:33:33
Y aquí me falta 00:33:49
Declararlo 00:33:51
Y esto es número 00:33:54
Vale, pues ya tenemos estos cuatro métodos 00:33:57
Mostrar jugadores 00:34:04
Nada 00:34:07
Te recorre el set de jugadores 00:34:08
Y te muestra nombre, equipo, etc 00:34:11
Vale, insertar jugador 00:34:13
Le das un jugador y te lo mete en el set 00:34:15
Vale 00:34:18
¿Existen jugadores en este equipo? 00:34:18
Pues recorremos el array 00:34:23
El set de jugadores 00:34:25
Y avisamos con el boolean si encuentro uno 00:34:27
O no encuentro ninguno 00:34:29
Y devolvemos, vale 00:34:30
¿Existe un jugador igual que este? 00:34:32
Pues creamos un jugador con esos datos 00:34:35
Y devolvemos el resultado del contains 00:34:38
Que será true, si existe uno 00:34:40
Igual a este, falso si no 00:34:41
Vale 00:34:42
Eran estas las cuatro funcionalidades que habíamos hecho en el main 00:34:43
Entonces ahora ya vamos a retocar este main, creamos nuestro haset con estos valores, por ejemplo, mostramos los que hay y ahora ya podríamos, para probar, vamos a ponerle, mostramos datos. 00:34:47
Pues para mostrar los datos 00:35:16
Simplemente tenemos que hacer llamar al método 00:35:20
Que se llamaba 00:35:22
Mostrar jugadores 00:35:25
Ala, ya está 00:35:28
Mostramos datos, esto es lo primero que hicimos 00:35:30
Vale, ¿existe jugador en un equipo dado? 00:35:32
Pues vamos a avisar aquí 00:35:37
Vale, leemos el nombre del equipo 00:35:39
Y ahora ya en lugar de hacerlo de esta manera 00:35:51
Llamamos al método correspondiente 00:35:53
Que el método correspondiente se llama main.existeJugadorDeEseEquipo. 00:35:58
No, no se llamaba así, este era el otro. 00:36:08
ExistenJugadoresEquipos, este era. 00:36:14
Entonces, comprobamos si hay jugadores en un equipo. 00:36:25
Vale, esto es lo siguiente que hemos hecho. 00:36:47
Vale, leemos y ya está. 00:36:51
Ahora, ¿qué es lo siguiente que hemos hecho? 00:36:53
Ver si existe jugador con un número 00:36:54
Y equipo dado 00:36:57
Pues venga, lo ponemos 00:36:59
Vale, y esto como lo hacíamos 00:37:01
Pues en lugar de todo esto 00:37:12
Aquí llamamos 00:37:20
Al método correspondiente 00:37:23
Existe jugador 00:37:25
Ya está 00:37:29
Vale, si existe jugador con este número de equipos jugadores 00:37:29
El jugador está, si no, no está 00:37:36
Eliminar un jugador 00:37:37
Eliminamos jugador 00:37:41
Pues eliminamos jugador 00:37:51
De nuevo, no hay que hacer esto 00:37:55
Si no lo hay que hacer 00:37:57
Eliminamos jugador 00:37:59
Es llamar al método correspondiente 00:38:01
Que era 00:38:02
Existe 00:38:04
Ah, ese no lo tenemos hecho 00:38:08
Eliminar jugador todavía 00:38:12
Venga, eliminar un jugador 00:38:13
Este será 00:38:16
Public static 00:38:18
void 00:38:20
eliminar 00:38:22
jugador 00:38:25
pasándole el número 00:38:26
de jugador y el equipo 00:38:28
que son los dos datos 00:38:30
que lo caracterizaban 00:38:36
y el set 00:38:37
pues eliminar jugador con estos datos 00:38:42
era 00:38:49
ya lo hicimos, nos hacemos un auxiliar 00:38:51
con estos datos 00:38:53
y ahora lo borramos 00:38:57
jugadores 00:38:59
punto remove 00:39:01
hala, ya está 00:39:04
y ahora ya sí creo que tenemos todo lo que hemos 00:39:07
hecho hasta ahora, pero metido en métodos separados 00:39:10
entonces 00:39:12
eliminamos jugador 00:39:15
pues sería main.eliminarJugador 00:39:17
pasándole el número, el equipo 00:39:21
y jugadores, hala, ya está 00:39:24
vale, vamos rápidamente a 00:39:25
probarlo todo por si algo lo hemos escrito mal 00:39:32
ejecutamos nuestro main 00:39:34
vale, hemos metido 00:39:35
los datos, en la colección hay tres 00:39:41
está claro, los que hemos metido, ¿cuáles son? 00:39:43
este, vale, comprobamos 00:39:45
si hay jugadores en un equipo, vamos a ver 00:39:49
si hay jugadores 00:39:51
en Madrid 00:39:53
existe jugador 00:39:55
vamos a ver si existe un jugador 00:39:56
concreto, introduzca 00:39:59
nombre Madrid y 00:40:01
número uno, el jugador está, vale 00:40:03
y ahora vamos a eliminar 00:40:05
un jugador 00:40:06
eliminamos jugador 00:40:07
De nombre equipo 00:40:10
Y uno 00:40:16
Vale, se supone que lo ha eliminado 00:40:16
Pero nos faltaría un de nuevo mostrar datos 00:40:19
Después 00:40:21
Nos falta un de nuevo mostrar datos 00:40:22
Para 00:40:25
Para asegurarnos de que lo ha eliminado 00:40:26
Vale, vamos a volverlo a ejecutar 00:40:36
Con un mostrar jugadores 00:40:41
Después de eliminar jugador 00:40:42
Vale, los tres que hemos metido 00:40:44
Los datos son estos 00:40:52
Vamos a ver si hay jugadores 00:40:54
En este 00:40:56
No existe 00:40:57
No existe este equipo 00:40:59
Vamos a ver si existen jugadores 00:41:01
Aquí 00:41:04
Si existe un jugador como este 00:41:05
Pues no, no existe un jugador así 00:41:09
Y ahora vamos a eliminar este otro 00:41:11
Madrid 1 00:41:13
Efectivamente lo ha eliminado 00:41:15
Vale, pues ya lo tenemos todo ahí recogido 00:41:17
Y ahora 00:41:21
La siguiente cosa que nos queríamos plantear 00:41:26
Ahora en lugar de eliminar uno 00:41:27
Concreto, uno solo 00:41:29
dado número y equipo, que para eso tenemos el remove 00:41:31
ya está, remove 00:41:33
le paso al jugador y me borra uno igual 00:41:35
ahora vamos a hacer otra funcionalidad 00:41:37
que es eliminar todos los jugadores de un equipo 00:41:39
eso no lo podemos hacer 00:41:42
con este método así 00:41:44
porque a este método hay que pasarle 00:41:45
un objeto para que te borre el que sea igual 00:41:47
no el que comparta equipo 00:41:49
el que comparta número, no 00:41:51
el que sea igual a ese 00:41:53
el que sea igual 00:41:55
entonces si quiero borrar todos los de un equipo 00:41:56
no puedo usar este método 00:41:59
Porque tengo que pasarle 00:42:00
Un equipo y un número 00:42:02
Para que me borre el que sea igual según equipo y número 00:42:04
Bueno, vamos a hacer ese método 00:42:06
Eliminar jugadores 00:42:08
De un equipo concreto 00:42:16
Entonces a este 00:42:17
Habrá que pasarle 00:42:20
Un equipo 00:42:21
Y el set de jugadores con los que trabajar 00:42:23
Porque como es local al main 00:42:26
Se lo tenemos que pasar 00:42:27
Vale, venga 00:42:29
Vamos a parar aquí un momentito 00:42:43
Bueno 00:42:46
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
12
Fecha:
10 de marzo de 2024 - 14:22
Visibilidad:
Público
Centro:
IES ROSA CHACEL
Duración:
42′ 48″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
224.12 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid