1
00:00:00,000 --> 00:00:03,899
Vale

2
00:00:03,899 --> 00:00:07,080
Venga, pues nada

3
00:00:07,080 --> 00:00:09,919
Vamos a meter jugadores en la colección

4
00:00:09,919 --> 00:00:19,059
Bueno, como tenemos un constructor

5
00:00:19,059 --> 00:00:19,820
Con parámetros

6
00:00:19,820 --> 00:00:22,079
Podemos hasta hacerlo así

7
00:00:22,079 --> 00:00:34,689
Jugador 1

8
00:00:34,689 --> 00:00:39,509
Nombre

9
00:00:39,509 --> 00:00:40,229
Luis

10
00:00:40,229 --> 00:00:54,609
Vale

11
00:00:54,609 --> 00:00:57,689
Entonces si metemos otro

12
00:00:57,689 --> 00:01:04,579
En esta situación está claro

13
00:01:04,579 --> 00:01:06,040
Que no va a haber ningún problema

14
00:01:06,040 --> 00:01:08,459
Ya tenemos los dos jugadores

15
00:01:08,459 --> 00:01:13,859
Y podemos hacer

16
00:01:13,859 --> 00:01:14,840
Tranquilamente

17
00:01:14,840 --> 00:01:23,829
En la colección

18
00:01:23,829 --> 00:01:35,890
Ahí, vale

19
00:01:35,890 --> 00:01:41,109
Si ejecutamos esto, pues nos va a decir dos

20
00:01:41,109 --> 00:01:43,209
Obviamente, en la colección

21
00:01:43,209 --> 00:02:01,799
Hay dos, vale

22
00:02:01,799 --> 00:02:05,390
Bueno, lo que nos podíamos esperar

23
00:02:05,390 --> 00:02:13,240
Vale, si metemos a este dos veces

24
00:02:13,240 --> 00:02:20,259
Pues hombre, os podéis

25
00:02:20,259 --> 00:02:21,840
Esperar ya con todo lo que sabemos

26
00:02:21,840 --> 00:02:23,120
De clases y objetos

27
00:02:23,120 --> 00:02:26,139
Que en contra de todas nuestras

28
00:02:26,139 --> 00:02:26,840
Intuiciones

29
00:02:26,840 --> 00:02:29,479
me va a seguir diciendo que hay dos

30
00:02:29,479 --> 00:02:31,400
¿por qué?

31
00:02:32,039 --> 00:02:34,099
porque para él no son iguales

32
00:02:34,099 --> 00:02:36,000
no son iguales

33
00:02:36,000 --> 00:02:37,699
la clase jugador

34
00:02:37,699 --> 00:02:41,080
es una clase de la que instanciamos objetos

35
00:02:41,080 --> 00:02:43,259
entonces jugador

36
00:02:43,259 --> 00:02:45,659
yo no le he puesto dentro ningún criterio de igualdad

37
00:02:45,659 --> 00:02:47,919
entonces como no le he puesto dentro ningún criterio de igualdad

38
00:02:47,919 --> 00:02:49,300
tiene el de object

39
00:02:49,300 --> 00:02:51,340
y el de object es

40
00:02:51,340 --> 00:02:53,340
solo son iguales dos objetos

41
00:02:53,340 --> 00:02:56,560
cuando están directamente en la misma dirección de memoria

42
00:02:56,560 --> 00:02:57,159
en la misma

43
00:02:57,159 --> 00:03:00,219
entonces efectivamente para este set

44
00:03:00,219 --> 00:03:01,680
estos objetos

45
00:03:01,680 --> 00:03:04,219
son distintos porque están en direcciones

46
00:03:04,219 --> 00:03:05,199
distintas de memoria

47
00:03:05,199 --> 00:03:09,740
pero eso no se corresponde con la interpretación

48
00:03:09,740 --> 00:03:11,039
real de las aplicaciones

49
00:03:11,039 --> 00:03:13,960
si uno se ha equivocado

50
00:03:13,960 --> 00:03:15,879
y ha metido

51
00:03:15,879 --> 00:03:16,860
dos veces el mismo

52
00:03:16,860 --> 00:03:19,740
lo normal es que esto

53
00:03:19,740 --> 00:03:20,620
lo haya hecho por error

54
00:03:20,620 --> 00:03:22,759
porque si has elegido un objeto

55
00:03:22,759 --> 00:03:25,240
si has elegido un conjunto como colección

56
00:03:25,240 --> 00:03:27,659
tú lo que no querías era que hubiera duplicados

57
00:03:27,659 --> 00:03:29,599
porque no los necesitas, entonces si estás

58
00:03:29,599 --> 00:03:31,539
metiendo al mismo dos veces, lo normal es que lo hayas

59
00:03:31,539 --> 00:03:32,919
hecho por error porque no quieres eso

60
00:03:32,919 --> 00:03:34,860
y este y este son el mismo

61
00:03:34,860 --> 00:03:37,780
y lo tienen que ser porque si tú has decidido

62
00:03:37,780 --> 00:03:39,319
que los jugadores se caracterizan

63
00:03:39,319 --> 00:03:42,020
por número, nombre y equipo

64
00:03:42,020 --> 00:03:43,879
has decidido que eso lo caracteriza

65
00:03:43,879 --> 00:03:45,620
y dos jugadores tienen

66
00:03:45,620 --> 00:03:47,060
el mismo número, nombre y equipo

67
00:03:47,060 --> 00:03:48,919
es que son el mismo

68
00:03:48,919 --> 00:03:51,560
porque si no son el mismo, entonces

69
00:03:51,560 --> 00:03:53,520
has hecho mal el diseño, entonces te falta una cuarta

70
00:03:53,520 --> 00:03:55,020
propiedad, te falta una cuarta

71
00:03:55,020 --> 00:03:57,460
que es la que los caracteriza, si has

72
00:03:57,460 --> 00:03:59,639
decidido esas tres, es porque esas tres

73
00:03:59,639 --> 00:04:01,759
lo identifican, o las tres

74
00:04:01,759 --> 00:04:03,099
o una de ellas o dos

75
00:04:03,099 --> 00:04:05,960
pero no en cualquier caso si las tres son iguales

76
00:04:05,960 --> 00:04:07,520
vale

77
00:04:07,520 --> 00:04:09,740
entonces no queremos que funcione así la aplicación

78
00:04:09,740 --> 00:04:11,560
si yo he escrito esto dos veces es porque

79
00:04:11,560 --> 00:04:12,599
es el mismo obviamente

80
00:04:12,599 --> 00:04:15,439
claro, lo que nos ha faltado como ya sabemos

81
00:04:15,439 --> 00:04:17,379
es que aquí no hay ningún criterio de igualdad

82
00:04:17,379 --> 00:04:19,519
vale, pero aquí ahora

83
00:04:19,519 --> 00:04:21,420
tenemos el problema de que

84
00:04:21,420 --> 00:04:23,160
estos objetos

85
00:04:23,160 --> 00:04:25,439
jugadores van a un

86
00:04:25,439 --> 00:04:27,399
haset, no van a una lista

87
00:04:27,399 --> 00:04:29,500
van a un haset

88
00:04:29,500 --> 00:04:31,180
entonces al ir a un haset

89
00:04:31,180 --> 00:04:33,579
el haset los va a ir ubicando

90
00:04:33,579 --> 00:04:35,319
en una tabla has

91
00:04:35,319 --> 00:04:37,500
con dos pasos, primero le hace una función de has

92
00:04:37,500 --> 00:04:38,639
para ir a una posición de la tabla

93
00:04:38,639 --> 00:04:40,199
y luego a partir de ahí

94
00:04:40,199 --> 00:04:43,139
si ya hay alguien ahí lo va desbordando

95
00:04:43,139 --> 00:04:45,180
con una lista enlazada, lo hace a través de dos pasos

96
00:04:45,180 --> 00:04:46,560
entonces él para

97
00:04:46,560 --> 00:04:48,480
ubicar el objeto

98
00:04:48,480 --> 00:04:51,000
y también para ver si ese objeto

99
00:04:51,000 --> 00:04:52,180
ya existe o no ha pasado

100
00:04:52,180 --> 00:04:54,620
hace función de has

101
00:04:54,620 --> 00:04:58,339
y luego equals, pues hay que ofrecerle esas dos cosas

102
00:04:58,339 --> 00:05:02,899
hay que decirle esas dos cosas, cuál es la función de hash que tiene que aplicar

103
00:05:02,899 --> 00:05:06,620
y cuál es el equals, hay que decírsela, hay que decírsela porque si no el hash

104
00:05:06,620 --> 00:05:10,579
no va a funcionar correctamente, vale, va a usar el de object

105
00:05:10,579 --> 00:05:14,639
y el de object tira de que objetos en direcciones

106
00:05:14,639 --> 00:05:18,199
de memoria distintas son distintos, aunque las propiedades sean iguales

107
00:05:18,199 --> 00:05:22,579
entonces aquí lo que nos faltaría para hacer bien

108
00:05:22,579 --> 00:05:24,879
esta aplicación es en jugador

109
00:05:24,879 --> 00:05:26,800
dado que es un hash set

110
00:05:26,800 --> 00:05:28,620
en jugador, poner esos

111
00:05:28,620 --> 00:05:30,720
dos pasos, el hashCode y el idPath, los dos

112
00:05:30,720 --> 00:05:32,519
entonces ahora

113
00:05:32,519 --> 00:05:33,680
ya sí, pues

114
00:05:33,680 --> 00:05:38,810
nosotros tendríamos que hacer este método

115
00:05:38,810 --> 00:05:42,370
y cuando hacemos el

116
00:05:42,370 --> 00:05:44,689
método, tenemos que decidir

117
00:05:44,689 --> 00:05:46,629
qué es lo que identifica de forma unívoca

118
00:05:46,629 --> 00:05:48,269
a los objetos de mi aplicación

119
00:05:48,269 --> 00:05:50,509
eso de nuevo, es un tema de

120
00:05:50,509 --> 00:05:52,790
análisis de la aplicación, de análisis de la realidad

121
00:05:52,790 --> 00:05:54,230
mis jugadores

122
00:05:54,230 --> 00:05:56,730
si tienen el mismo número son el mismo

123
00:05:56,730 --> 00:05:59,149
no, porque pueden estar en equipos distintos

124
00:05:59,149 --> 00:06:00,050
si tienen el mismo número

125
00:06:00,050 --> 00:06:03,009
entonces que los caracteriza para que sean igual

126
00:06:03,009 --> 00:06:05,149
si tienen el mismo número y el mismo

127
00:06:05,149 --> 00:06:06,629
nombre, son el mismo

128
00:06:06,629 --> 00:06:08,970
nombre no, porque puede haber en diferentes

129
00:06:08,970 --> 00:06:10,970
equipos dos jugadores con mismo

130
00:06:10,970 --> 00:06:12,930
número que se llamen igual, entonces que les

131
00:06:12,930 --> 00:06:15,009
identifica, el mismo número y el mismo

132
00:06:15,009 --> 00:06:15,430
equipo

133
00:06:15,430 --> 00:06:18,889
pues sí, podríamos decidir

134
00:06:18,889 --> 00:06:20,790
podría ser otro, es que esto ya depende

135
00:06:20,790 --> 00:06:22,670
de nuestra aplicación, tendríamos que analizarla

136
00:06:22,670 --> 00:06:25,250
con que estamos trabajando, pero imaginaos que en esta

137
00:06:25,250 --> 00:06:27,170
decimos, vale, pues

138
00:06:27,170 --> 00:06:29,290
cuando yo tengo dos jugadores con el mismo

139
00:06:29,290 --> 00:06:31,490
número y en el mismo equipo, es el mismo

140
00:06:31,490 --> 00:06:33,290
porque no tengo en un equipo

141
00:06:33,290 --> 00:06:35,310
dos jugadores con el mismo número, es imposible

142
00:06:35,310 --> 00:06:37,569
porque así me lo está diciendo el que me ha pedido la aplicación

143
00:06:37,569 --> 00:06:39,329
me está diciendo que no puede

144
00:06:39,329 --> 00:06:41,089
haber en un equipo dos jugadores con el mismo número

145
00:06:41,089 --> 00:06:43,129
pues entonces yo concluiría

146
00:06:43,129 --> 00:06:44,730
vale, pues venga

147
00:06:44,730 --> 00:06:47,170
mi igualdad va a estar basada

148
00:06:47,170 --> 00:06:48,889
en equipo y en número

149
00:06:48,889 --> 00:06:51,149
va a estar basada en equipo y en número, nombre

150
00:06:51,149 --> 00:06:51,829
no hace falta

151
00:06:51,829 --> 00:06:55,069
Pues nada, marcamos las dos

152
00:06:55,069 --> 00:06:59,170
Y él ya me ha generado aquí el hashCode y el equals

153
00:06:59,170 --> 00:07:01,470
El equals lo sabemos de memoria

154
00:07:01,470 --> 00:07:04,829
Ya sabemos que es un método que él sobrescribe de la clase object

155
00:07:04,829 --> 00:07:08,050
Por tanto, respeta su cabecera idéntica de object

156
00:07:08,050 --> 00:07:09,110
Respeta su cabecera

157
00:07:09,110 --> 00:07:11,050
Y ya sabemos lo que hace

158
00:07:11,050 --> 00:07:12,290
¿Vale?

159
00:07:13,310 --> 00:07:17,350
Entonces, usa el método equals este

160
00:07:17,350 --> 00:07:18,490
Al que le pasa equipo

161
00:07:18,490 --> 00:07:21,129
Y este método equals, pues si uno lo mira aquí

162
00:07:21,129 --> 00:07:24,129
ahora ya compara las dos propiedades

163
00:07:24,129 --> 00:07:25,170
la A y la B

164
00:07:25,170 --> 00:07:27,129
vale

165
00:07:27,129 --> 00:07:30,750
entonces

166
00:07:30,750 --> 00:07:33,449
el equals

167
00:07:33,449 --> 00:07:35,750
y el object

168
00:07:35,750 --> 00:07:36,949
que hace, pues llama

169
00:07:36,949 --> 00:07:39,910
él nos implementa esta por defecto

170
00:07:39,910 --> 00:07:41,990
esta por defecto, que uno quiere implementar

171
00:07:41,990 --> 00:07:42,949
otra función de hash

172
00:07:42,949 --> 00:07:45,750
también puede, nos implementa esta

173
00:07:45,750 --> 00:07:48,009
por defecto basada en equipo y en número

174
00:07:48,009 --> 00:07:49,430
nos implementa esta

175
00:07:49,430 --> 00:07:51,949
que uno podría entrar aquí

176
00:07:51,949 --> 00:07:54,189
que es esta de aquí y uno apuntará aquí

177
00:07:54,189 --> 00:07:56,129
a ver cómo lo ha hecho

178
00:07:56,129 --> 00:07:58,230
que lo hace usando este numerito

179
00:07:58,230 --> 00:07:58,829
31

180
00:07:58,829 --> 00:08:01,990
porque es un número primo que optimiza

181
00:08:01,990 --> 00:08:02,910
no sé qué historia

182
00:08:02,910 --> 00:08:06,110
bueno, usa esta implementación

183
00:08:06,110 --> 00:08:07,889
por defecto basada en el número 31

184
00:08:07,889 --> 00:08:09,949
que el número 31

185
00:08:09,949 --> 00:08:11,509
es que cumple una propiedad interesante

186
00:08:11,509 --> 00:08:13,310
no recuerdo la cual es, en matemáticas

187
00:08:13,310 --> 00:08:14,370
de números primos

188
00:08:14,370 --> 00:08:17,889
y usa este porque optimiza no sé qué historias

189
00:08:17,889 --> 00:08:19,269
vale, bueno

190
00:08:19,269 --> 00:08:21,529
nosotros a efectos prácticos nos quedamos

191
00:08:21,529 --> 00:08:22,990
siempre con esta implementación

192
00:08:22,990 --> 00:08:24,009
y ya está

193
00:08:24,009 --> 00:08:26,029
nos quedamos con esta

194
00:08:26,029 --> 00:08:28,310
y ahora ya sí

195
00:08:28,310 --> 00:08:31,310
mi clase jugador

196
00:08:31,310 --> 00:08:33,669
tiene fijado su criterio de igualdad

197
00:08:33,669 --> 00:08:35,129
pero no sólo

198
00:08:35,129 --> 00:08:37,129
el de igualdad genérico

199
00:08:37,129 --> 00:08:39,409
para listas y para todo, sino el de

200
00:08:39,409 --> 00:08:41,570
el hash set, porque el del hash set

201
00:08:41,570 --> 00:08:42,929
es el único que va a dos pasos

202
00:08:42,929 --> 00:08:44,470
el del hash set

203
00:08:44,470 --> 00:08:47,649
usa primero esta y luego esta

204
00:08:47,649 --> 00:08:49,490
cualquier otra

205
00:08:49,490 --> 00:08:51,549
aplicación de java para ver si dos objetos

206
00:08:51,549 --> 00:08:53,450
son iguales, lo que hace es llamar al

207
00:08:53,450 --> 00:08:55,269
equals y ya está, llamar al equals

208
00:08:55,269 --> 00:08:57,090
pero el hashSet

209
00:08:57,090 --> 00:08:59,490
por como está hecha por dentro, necesita

210
00:08:59,490 --> 00:09:01,029
las dos, necesita las dos

211
00:09:01,029 --> 00:09:03,450
luego el hashSet es la única clase que hemos

212
00:09:03,450 --> 00:09:04,809
visto hasta ahora, la única

213
00:09:04,809 --> 00:09:07,549
que para ver si dos

214
00:09:07,549 --> 00:09:09,669
objetos son iguales, necesita

215
00:09:09,669 --> 00:09:11,409
llamar en cadena los dos métodos

216
00:09:11,409 --> 00:09:13,570
jasco de equals, bueno pues

217
00:09:13,570 --> 00:09:15,009
como ya lo tenemos implementado

218
00:09:15,009 --> 00:09:17,490
pues ahora ya

219
00:09:17,490 --> 00:09:19,389
este main, ya sí que no

220
00:09:19,389 --> 00:09:21,590
meterá el segundo, aunque le cambiáramos

221
00:09:21,590 --> 00:09:25,830
de nombre, imaginaos que

222
00:09:25,830 --> 00:09:26,669
le cambiamos de nombre

223
00:09:26,669 --> 00:09:29,409
para el hasher, ahora

224
00:09:29,409 --> 00:09:31,350
este y este son iguales

225
00:09:31,350 --> 00:09:33,570
porque comparten número y equipo

226
00:09:33,570 --> 00:09:35,289
entonces él ya interpreta que

227
00:09:35,289 --> 00:09:37,809
bueno, este puedes meterlo, pero es que

228
00:09:37,809 --> 00:09:39,730
te has equivocado, porque estás metiendo al mismo

229
00:09:39,730 --> 00:09:41,909
otra vez, aunque le des otro nombre

230
00:09:41,909 --> 00:09:43,809
pues si le das otro nombre es porque te has

231
00:09:43,809 --> 00:09:45,669
equivocado, porque le has cogido el nombre de otra manera

232
00:09:45,669 --> 00:09:46,529
pero es que es el mismo

233
00:09:46,529 --> 00:09:49,330
entonces si ahora ejecutamos esto

234
00:09:49,330 --> 00:09:54,740
Pues efectivamente ahora solo ha metido uno

235
00:09:54,740 --> 00:09:56,200
El segundo le ha ignorado

236
00:09:56,200 --> 00:09:58,340
¿Vale?

237
00:09:58,620 --> 00:10:01,440
Pero tenemos que tener los dos métodos implementados

238
00:10:01,440 --> 00:10:03,559
Vamos a quitar el hashCode

239
00:10:03,559 --> 00:10:18,019
¿Vale?

240
00:10:18,580 --> 00:10:20,360
Entonces si quitamos el hashCode

241
00:10:20,360 --> 00:10:21,620
Y volvemos a ejecutar esto

242
00:10:21,620 --> 00:10:26,720
No ha detectado la igualdad

243
00:10:26,720 --> 00:10:27,899
Y el equals está

244
00:10:27,899 --> 00:10:31,519
Pero al hashSet no le vale el equals

245
00:10:31,519 --> 00:10:33,039
Si no tiene el hashCode

246
00:10:33,039 --> 00:10:35,720
Usa el hashCode de object

247
00:10:35,720 --> 00:10:37,500
Y el hashCode de object

248
00:10:37,500 --> 00:10:39,820
objetos diferentes, me da igual

249
00:10:39,820 --> 00:10:41,980
cuáles sean sus propiedades, se van a sitios

250
00:10:41,980 --> 00:10:44,019
diferentes, con lo cual

251
00:10:44,019 --> 00:10:45,399
luego ya ni usaría el equals

252
00:10:45,399 --> 00:10:49,309
entonces, si yo no tengo el hashCode

253
00:10:49,309 --> 00:10:51,009
aunque tenga un equals muy bien hecho

254
00:10:51,009 --> 00:10:53,750
el hashSet me va a funcionar mal

255
00:10:53,750 --> 00:10:55,389
me va a funcionar mal

256
00:10:55,389 --> 00:10:56,450
¿vale?

257
00:10:56,970 --> 00:10:59,450
el hashSet necesita que estén

258
00:10:59,450 --> 00:11:01,549
los dos para detectar la igualdad

259
00:11:01,549 --> 00:11:03,549
los dos, si no tengo

260
00:11:03,549 --> 00:11:04,090
este, nada

261
00:11:04,090 --> 00:11:11,059
¿vale? vale, el hashCode

262
00:11:11,059 --> 00:11:11,620
en realidad

263
00:11:11,620 --> 00:11:16,379
podría ser, repito, cualquier función

264
00:11:16,379 --> 00:11:18,220
de hash que uno haga, siempre y cuando

265
00:11:18,220 --> 00:11:19,659
sea inyectiva

266
00:11:19,659 --> 00:11:21,320
cualquiera

267
00:11:21,320 --> 00:11:24,240
es decir, inyectiva significa

268
00:11:24,240 --> 00:11:26,120
pues bueno, que aún

269
00:11:26,120 --> 00:11:27,919
en el dominio origen

270
00:11:27,919 --> 00:11:30,059
te dé solo un valor, no te puede dar varios

271
00:11:30,059 --> 00:11:32,399
es decir, si a mí me da la gana

272
00:11:32,399 --> 00:11:33,960
hacer una función de hash que sea esta

273
00:11:33,960 --> 00:11:34,620
por ejemplo

274
00:11:34,620 --> 00:11:37,940
pues es una función de hash válida también

275
00:11:37,940 --> 00:11:40,480
pero es muy mala

276
00:11:40,480 --> 00:11:42,159
porque todos los objetos

277
00:11:42,159 --> 00:11:44,080
van a una única posición

278
00:11:44,080 --> 00:11:46,340
con lo cual es como

279
00:11:46,340 --> 00:11:48,360
yo meto el primero ahí

280
00:11:48,360 --> 00:11:50,220
y los demás ya van desbordando

281
00:11:50,220 --> 00:11:52,360
todos son a lista enlazada, entonces esta

282
00:11:52,360 --> 00:11:53,100
combinación

283
00:11:53,100 --> 00:11:56,539
computacionalmente es como una lista enlazada en realidad

284
00:11:56,539 --> 00:11:58,240
pero como

285
00:11:58,240 --> 00:11:59,100
válida es

286
00:11:59,100 --> 00:12:02,059
porque es una función de hash

287
00:12:02,059 --> 00:12:04,320
válida, y si yo ejecuto

288
00:12:04,320 --> 00:12:08,330
esto, pues como veis ha funcionado

289
00:12:08,330 --> 00:12:09,210
perfectamente

290
00:12:09,210 --> 00:12:11,990
solo hay uno, he detectado que son

291
00:12:11,990 --> 00:12:12,850
iguales

292
00:12:12,850 --> 00:12:16,070
vale, solo hay uno aquí, estupendo

293
00:12:16,070 --> 00:12:17,070
ha funcionado bien

294
00:12:17,070 --> 00:12:20,269
lo que pasa es que es una función de hash

295
00:12:20,269 --> 00:12:22,149
repito, que lo que

296
00:12:22,149 --> 00:12:24,350
implica por dentro es que

297
00:12:24,350 --> 00:12:25,730
todos los elementos

298
00:12:25,730 --> 00:12:28,210
van al mismo numerito y a partir de ahí

299
00:12:28,210 --> 00:12:30,350
cuelgan todos de la mano en lista enlazada

300
00:12:30,350 --> 00:12:31,730
pues vaya, no

301
00:12:31,730 --> 00:12:34,389
computacionalmente es una lista

302
00:12:34,389 --> 00:12:35,269
enlazada, ¿para qué?

303
00:12:36,110 --> 00:12:38,289
entonces hombre, mejor usamos la función

304
00:12:38,289 --> 00:12:38,809
de hash

305
00:12:38,809 --> 00:12:42,250
que me ofrece él, que está optimizada

306
00:12:42,250 --> 00:12:44,529
para los casos genéricos

307
00:12:44,529 --> 00:12:52,120
bueno, pues entonces

308
00:12:52,120 --> 00:12:56,139
aquí solamente habría uno

309
00:12:56,139 --> 00:12:57,940
por tanto, si yo a este le cambio el equipo

310
00:12:57,940 --> 00:13:03,220
ahora ya sí que lo metería, porque como es de otro equipo

311
00:13:03,220 --> 00:13:07,000
ahora ya sí que interpreta que hay dos

312
00:13:07,000 --> 00:13:09,559
bueno, pues esto es lo más crítico

313
00:13:09,559 --> 00:13:13,220
en conjuntos, el tener claro

314
00:13:13,220 --> 00:13:15,100
que no admite elementos iguales

315
00:13:15,100 --> 00:13:17,159
y no es que te vaya a dar un error, es simplemente

316
00:13:17,159 --> 00:13:19,159
que no lo mete, no lo mete, ya está

317
00:13:19,159 --> 00:13:21,340
y tú puedes contar con que sí y luego

318
00:13:21,340 --> 00:13:23,360
siete horas después

319
00:13:23,360 --> 00:13:25,059
la aplicación no te ha funcionado

320
00:13:25,059 --> 00:13:26,840
te llega un error y no tienes ni idea de por qué

321
00:13:26,840 --> 00:13:28,580
bueno, porque lleva arrastrando

322
00:13:28,580 --> 00:13:31,360
un error de partida que tú crees que hay unos datos

323
00:13:31,360 --> 00:13:32,759
que no hay, pues hay que saber

324
00:13:32,759 --> 00:13:34,919
cómo funciona, ¿vale?

325
00:13:35,840 --> 00:13:37,159
pues esto es lo más crítico

326
00:13:37,159 --> 00:13:39,080
esto y que para que el headset

327
00:13:39,080 --> 00:13:41,539
interprete la igualdad correctamente

328
00:13:41,539 --> 00:13:43,179
tienen que ser los dos

329
00:13:43,179 --> 00:13:44,659
los que estén, este

330
00:13:44,659 --> 00:13:46,580
y este

331
00:13:46,580 --> 00:13:49,139
porque si no usa los

332
00:13:49,139 --> 00:13:50,679
de object y los de object son

333
00:13:50,679 --> 00:13:52,519
igualdad es la misma dirección de memoria

334
00:13:52,519 --> 00:13:54,860
vale

335
00:13:54,860 --> 00:13:59,059
bueno

336
00:13:59,059 --> 00:14:04,059
vamos a meterle algún

337
00:14:04,059 --> 00:14:05,980
otro para poder recorrer un poquito

338
00:14:05,980 --> 00:14:27,779
más, vale

339
00:14:27,779 --> 00:14:30,159
bueno

340
00:14:30,159 --> 00:14:32,240
entonces esto, si yo quiero recorrer

341
00:14:32,240 --> 00:14:33,779
para consultar solamente

342
00:14:33,779 --> 00:14:35,860
pues puedo

343
00:14:35,860 --> 00:14:38,700
Podemos ser vagos y hacerlo con un for each

344
00:14:38,700 --> 00:14:46,259
¿Vale? Que ya sabéis

345
00:14:46,259 --> 00:14:47,279
Cómo funciona esto

346
00:14:47,279 --> 00:14:50,220
Pues la variable j en cada iteración va siendo

347
00:14:50,220 --> 00:14:51,259
Cada uno de los elementos

348
00:14:51,259 --> 00:14:54,620
Entonces aquí efectivamente me mostrará

349
00:14:54,620 --> 00:14:55,039
Pues

350
00:14:55,039 --> 00:14:57,600
Si mostramos

351
00:14:57,600 --> 00:15:00,639
El nombre y el equipo

352
00:15:00,639 --> 00:15:09,320
Pues me mostrará

353
00:15:09,320 --> 00:15:10,539
Los tres, claro

354
00:15:10,539 --> 00:15:20,590
¿Vale? Esos son los tres jugadores que ha metido

355
00:15:20,590 --> 00:15:21,470
Vale

356
00:15:21,470 --> 00:15:25,990
Aquí no puedo recorrer

357
00:15:25,990 --> 00:15:27,990
No puedo recorrer con un get

358
00:15:27,990 --> 00:15:30,669
ya lo dijimos el otro día final de clase

359
00:15:30,669 --> 00:15:31,850
aquí

360
00:15:31,850 --> 00:15:33,570
jugadores

361
00:15:33,570 --> 00:15:36,450
.get no existe

362
00:15:36,450 --> 00:15:37,529
no existe

363
00:15:37,529 --> 00:15:40,590
jugadores.get por posición, por qué posición

364
00:15:40,590 --> 00:15:41,149
no existe

365
00:15:41,149 --> 00:15:44,710
yo aquí lo que puedo hacer es recorrer y mostrar

366
00:15:44,710 --> 00:15:46,629
lo que hay, pero recuperar el que hay

367
00:15:46,629 --> 00:15:48,490
en una posición no existe, yo los tengo todos ahí

368
00:15:48,490 --> 00:15:50,690
y lo que puedo hacer es

369
00:15:50,690 --> 00:15:51,870
recorrer para ver los que hay

370
00:15:51,870 --> 00:15:54,549
tengo otros métodos para hacer otras cosas

371
00:15:54,549 --> 00:15:56,370
que quiero ver

372
00:15:56,370 --> 00:15:58,370
Si hay un jugador

373
00:15:58,370 --> 00:16:01,220
Que

374
00:16:01,220 --> 00:16:04,480
Que sea de un equipo

375
00:16:04,480 --> 00:16:05,440
Por ejemplo

376
00:16:05,440 --> 00:16:17,860
¿Vale? Vamos a suponer que queremos hacer esto

377
00:16:17,860 --> 00:16:19,779
¿Existe algún jugador de un equipo dado?

378
00:16:20,399 --> 00:16:22,019
Bueno, pues entonces podríamos

379
00:16:22,019 --> 00:16:23,320
Uy

380
00:16:23,320 --> 00:16:28,600
No quiero

381
00:16:28,600 --> 00:16:31,980
Se me ha ido esto

382
00:16:31,980 --> 00:16:40,840
Pues por ejemplo, podríamos decir

383
00:16:40,840 --> 00:16:44,220
Introduzca

384
00:16:44,220 --> 00:16:46,259
Nombre equipo

385
00:16:46,259 --> 00:16:52,750
y ahora leemos el nombre del equipo

386
00:16:52,750 --> 00:16:54,070
vamos a ponerle

387
00:16:54,070 --> 00:16:55,710
lo de leer

388
00:16:55,710 --> 00:17:23,579
y ahora pues

389
00:17:23,579 --> 00:17:24,519
podríamos hacer

390
00:17:24,519 --> 00:17:27,720
tenemos el método contains que funciona exactamente

391
00:17:27,720 --> 00:17:28,720
igual que en listas

392
00:17:28,720 --> 00:17:32,019
si jugadores.contiene

393
00:17:32,019 --> 00:17:35,559
ah no, perdón

394
00:17:35,559 --> 00:17:36,380
contains no porque

395
00:17:36,380 --> 00:17:40,119
para ver si hay un jugador

396
00:17:40,119 --> 00:17:41,259
puede haber más de uno

397
00:17:41,259 --> 00:17:43,039
si contiene un nombre con un equipo

398
00:17:43,039 --> 00:17:45,079
la igualdad no va por equipos

399
00:17:45,079 --> 00:18:46,569
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?

400
00:18:46,569 --> 00:19:08,720
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?

401
00:19:08,720 --> 00:19:10,680
entonces, en este caso la igualdad

402
00:19:10,680 --> 00:19:12,740
venía dada por equipo

403
00:19:12,740 --> 00:19:14,920
y número, el contain

404
00:19:14,920 --> 00:19:16,880
se aplicará cuando queremos ver si existe

405
00:19:16,880 --> 00:19:18,519
un jugador de un equipo y un número

406
00:19:18,519 --> 00:19:20,839
concreto, porque ese sí que solamente va a haber uno

407
00:19:20,839 --> 00:19:24,299
vale, entonces

408
00:19:24,299 --> 00:19:26,599
un momento, vamos a probar esto, dándole

409
00:19:26,599 --> 00:19:28,660
Sevilla

410
00:19:28,660 --> 00:19:29,359
por ejemplo

411
00:19:29,359 --> 00:19:42,740
existe

412
00:19:42,740 --> 00:19:44,019
porque me sale, ah

413
00:19:44,019 --> 00:19:45,660
he puesto el ELSE

414
00:19:45,660 --> 00:19:47,519
vale

415
00:19:47,519 --> 00:19:52,079
ahí, vale, efectivamente

416
00:19:52,079 --> 00:19:53,980
me salía así este jugador, luego me decía esto

417
00:19:53,980 --> 00:19:55,099
pero no lo había puesto en el else, claro

418
00:19:55,099 --> 00:19:57,319
vale

419
00:19:57,319 --> 00:20:00,240
entonces ahora

420
00:20:00,240 --> 00:20:02,319
si queremos ver si existe un jugador

421
00:20:02,319 --> 00:20:03,380
con número y equipo

422
00:20:03,380 --> 00:20:05,160
esto ya es otra cosa

423
00:20:05,160 --> 00:20:19,420
número y equipo es lo que define a un jugador

424
00:20:19,420 --> 00:20:20,099
univocamente

425
00:20:20,099 --> 00:20:22,819
es lo que define a un jugador univocamente

426
00:20:22,819 --> 00:20:24,480
entonces aquí sí que podemos usar el contains

427
00:20:24,480 --> 00:20:26,940
porque el contains le das un objeto

428
00:20:26,940 --> 00:20:29,480
y te dice si existe uno igual a ese

429
00:20:29,480 --> 00:20:30,619
igual a ese

430
00:20:30,619 --> 00:20:33,220
y la igualdad se hace

431
00:20:33,220 --> 00:20:35,400
en virtud de número y equipo

432
00:20:35,400 --> 00:20:37,319
entonces aquí

433
00:20:37,319 --> 00:20:38,720
pues si leyéramos

434
00:20:38,720 --> 00:20:41,920
le pidiéramos las dos cosas

435
00:20:41,920 --> 00:20:43,799
número y equipo

436
00:20:43,799 --> 00:20:45,339
le pediríamos las dos cosas

437
00:20:45,339 --> 00:20:47,640
nombre equipo

438
00:20:47,640 --> 00:20:48,779
y ahora pedimos aquí

439
00:20:48,779 --> 00:21:13,680
un tolerante

440
00:21:13,680 --> 00:21:16,660
vale, pues ahora aquí sí que podríamos hacer

441
00:21:16,660 --> 00:21:18,619
nos hacemos

442
00:21:18,619 --> 00:21:20,000
un objeto jugador

443
00:21:20,000 --> 00:21:29,259
no me gusta

444
00:21:29,259 --> 00:21:32,259
Nos hacemos un objeto jugador

445
00:21:32,259 --> 00:21:36,420
Con esos dos valores

446
00:21:36,420 --> 00:21:44,319
Set equipo

447
00:21:44,319 --> 00:21:50,279
Y el número

448
00:21:50,279 --> 00:21:52,720
Y ahora ya sí que podemos hacer

449
00:21:52,720 --> 00:21:54,019
No hace falta recorrer nada

450
00:21:54,019 --> 00:21:58,880
Si jugadores contiene

451
00:21:58,880 --> 00:22:02,660
Uno igual a este

452
00:22:02,660 --> 00:22:06,329
Pues puedo poner el jugador está

453
00:22:06,329 --> 00:22:10,869
Y si no

454
00:22:10,869 --> 00:22:24,460
¿Vale?

455
00:22:25,200 --> 00:22:26,839
Entonces aquí se aplica el contains

456
00:22:26,839 --> 00:22:28,460
El contains ¿Qué hace?

457
00:22:28,460 --> 00:22:30,380
Coge este objeto y mira a ver si hay

458
00:22:30,380 --> 00:22:32,740
alguno igual a ese en esta colección

459
00:22:32,740 --> 00:22:33,759
si lo hay devuelve true

460
00:22:33,759 --> 00:22:37,829
igual a ese que significa que sean

461
00:22:37,829 --> 00:22:39,230
iguales en equipo y en número

462
00:22:39,230 --> 00:22:40,670
nada más, en nombre no

463
00:22:40,670 --> 00:22:43,529
por eso solamente le he fijado el equipo y el número

464
00:22:43,529 --> 00:22:45,569
solo, porque el nombre me da igual

465
00:22:45,569 --> 00:22:48,009
para mirar si es igual a este

466
00:22:48,009 --> 00:22:49,509
solamente va a mirar el equipo y el número

467
00:22:49,509 --> 00:22:52,130
entonces si yo le paso

468
00:22:52,130 --> 00:22:55,809
uno y Madrid me va a decir que sí

469
00:22:55,809 --> 00:22:57,609
y si luego le paso otra cosa me va a decir que no

470
00:22:57,609 --> 00:23:05,559
bueno, esto es para lo primero

471
00:23:05,559 --> 00:23:07,579
que hemos hecho, el jugador está

472
00:23:07,579 --> 00:23:08,579
y era nombre de equipo

473
00:23:08,579 --> 00:23:14,299
pues Madrid y 1, el jugador está

474
00:23:14,299 --> 00:23:15,819
pero si hiciera esto mismo

475
00:23:15,819 --> 00:23:19,779
con cualquier equipo

476
00:23:19,779 --> 00:23:21,680
y ahora introduzca nombre equipo

477
00:23:21,680 --> 00:23:22,960
cualquier equipo 1

478
00:23:22,960 --> 00:23:24,240
pues no está

479
00:23:24,240 --> 00:23:27,480
¿vale? porque este sí pero este no

480
00:23:27,480 --> 00:23:33,460
¿vale? entonces

481
00:23:33,460 --> 00:23:35,039
en cuanto a borrados

482
00:23:35,039 --> 00:23:37,240
el remove

483
00:23:37,240 --> 00:23:39,759
tenemos, por ejemplo

484
00:23:39,759 --> 00:23:40,680
vamos a

485
00:23:40,680 --> 00:23:44,539
eliminar

486
00:23:44,539 --> 00:23:46,539
un jugador

487
00:23:46,539 --> 00:23:48,160
eliminar un jugador

488
00:23:48,160 --> 00:23:50,160
como cada jugador se caracteriza

489
00:23:50,160 --> 00:23:51,339
por

490
00:23:51,339 --> 00:23:54,319
número y equipo, pues vamos a hacer

491
00:23:54,319 --> 00:23:55,720
esta primera versión dado

492
00:23:55,720 --> 00:23:58,460
número y equipo, que es lo que caracteriza

493
00:23:58,460 --> 00:23:59,880
cada jugador, pues vamos a borrar

494
00:23:59,880 --> 00:24:02,519
al jugador 1 del equipo tal

495
00:24:02,519 --> 00:24:04,519
pues vamos a

496
00:24:04,519 --> 00:24:06,339
volver a pedir los datos

497
00:24:06,339 --> 00:24:24,759
vale

498
00:24:24,759 --> 00:24:27,359
y ahora ya podemos

499
00:24:27,359 --> 00:24:28,480
hacer perfectamente

500
00:24:28,480 --> 00:24:30,299
jugadores

501
00:24:30,299 --> 00:24:32,140
punto remove

502
00:24:32,140 --> 00:24:34,279
y

503
00:24:34,279 --> 00:24:36,940
habría que hacer un jugador con estos datos

504
00:24:36,940 --> 00:24:38,680
vamos a volver a

505
00:24:38,680 --> 00:24:40,119
hacer esto otra vez

506
00:24:40,119 --> 00:24:46,420
como esta variable ya está declarada

507
00:24:46,420 --> 00:24:48,319
no hace falta que la declare, la reutilizo

508
00:24:48,319 --> 00:24:59,049
vale, entonces este método

509
00:24:59,049 --> 00:25:00,630
eliminará

510
00:25:00,630 --> 00:25:03,509
un jugador igual a este

511
00:25:03,509 --> 00:25:05,329
según el criterio de igualdad

512
00:25:05,329 --> 00:25:07,210
que es equipo y número, con lo cual el nombre

513
00:25:07,210 --> 00:25:09,089
no se lo hemos fijado aquí porque no lo necesitamos

514
00:25:09,089 --> 00:25:10,769
nuestros datos de entrada eran equipo y número

515
00:25:10,769 --> 00:25:13,430
Entonces este borrará un jugador

516
00:25:13,430 --> 00:25:15,349
Igual a ese, si es que existe

517
00:25:15,349 --> 00:25:16,829
Y si no, no

518
00:25:16,829 --> 00:25:19,130
Entonces vamos a volver a recorrerla aquí

519
00:25:19,130 --> 00:25:23,170
Vamos a volver a recorrer la colección

520
00:25:23,170 --> 00:25:24,230
Para ver si lo ha borrado

521
00:25:24,230 --> 00:25:37,680
Perdón, no era esto lo que yo quería

522
00:25:37,680 --> 00:25:39,880
Copiar

523
00:25:39,880 --> 00:25:41,500
Venga, pues vamos a

524
00:25:41,500 --> 00:25:43,640
A volver a recorrerla

525
00:25:43,640 --> 00:26:04,980
Esto, perdón

526
00:26:04,980 --> 00:26:09,430
Eh

527
00:26:09,430 --> 00:26:15,289
Es que no lo tengo hecho

528
00:26:15,289 --> 00:26:18,329
Este método lo puse solo para

529
00:26:18,329 --> 00:26:20,430
poner la situación en la cual esto importaba

530
00:26:20,430 --> 00:26:21,910
aquí era importante ponerlo

531
00:26:21,910 --> 00:26:23,430
pero es que no lo tengo hecho

532
00:26:23,430 --> 00:26:26,829
vale, pues nada, si hacemos esto

533
00:26:26,829 --> 00:26:32,000
esto era

534
00:26:32,000 --> 00:26:33,880
lo del principio para ver si

535
00:26:33,880 --> 00:26:36,140
existe jugador de este equipo o no, que va a decir que no existe

536
00:26:36,140 --> 00:26:37,160
esto es para

537
00:26:37,160 --> 00:26:39,799
decirme si existe uno

538
00:26:39,799 --> 00:26:41,339
con ese número

539
00:26:41,339 --> 00:26:43,859
y ese equipo que vamos a ponerle

540
00:26:43,859 --> 00:26:45,480
cualquier cosa que va a decir no está

541
00:26:45,480 --> 00:26:48,259
y ahora venía lo de borrar

542
00:26:48,259 --> 00:26:49,940
pues vamos a borrar

543
00:26:49,940 --> 00:26:53,859
de Madrid

544
00:26:53,859 --> 00:26:55,720
al jugador 1

545
00:26:55,720 --> 00:26:58,059
que sí que existía, de Madrid al jugador 1

546
00:26:58,059 --> 00:27:00,319
y efectivamente cuando luego me muestra

547
00:27:00,319 --> 00:27:02,599
lo que hay, no está ya el primero que metimos

548
00:27:02,599 --> 00:27:03,680
porque lo he eliminado

549
00:27:03,680 --> 00:27:07,759
luego el remove me vale para borrar

550
00:27:07,759 --> 00:27:09,700
un objeto igual a otro

551
00:27:09,700 --> 00:27:11,240
si es que existe, si no nada

552
00:27:11,240 --> 00:27:13,759
un objeto igual a otro y se acabó, punto pelota

553
00:27:13,759 --> 00:27:15,019
vale

554
00:27:15,019 --> 00:27:18,000
pero qué pasa si quiero borrar

555
00:27:18,000 --> 00:27:19,720
por ejemplo todos los

556
00:27:19,720 --> 00:27:20,799
jugadores de un equipo

557
00:27:20,799 --> 00:27:23,859
Todos los jugadores de un equipo

558
00:27:23,859 --> 00:27:25,119
No los puedo usar con el remove

559
00:27:25,119 --> 00:27:28,240
El remove es para borrar un jugador igual al que yo le doy

560
00:27:28,240 --> 00:27:30,079
Y el criterio de igualdad exige equipo y número

561
00:27:30,079 --> 00:27:33,900
Entonces si yo quiero borrar todos los de un equipo

562
00:27:33,900 --> 00:27:35,240
No puedo borrar así

563
00:27:35,240 --> 00:27:37,500
¿Vale?

564
00:27:37,740 --> 00:27:38,880
Bueno, vamos a hacer eso

565
00:27:38,880 --> 00:27:40,180
Vamos a suponer que ahora queremos

566
00:27:40,180 --> 00:27:43,980
Eliminar, más que borrar, que queda feo

567
00:27:43,980 --> 00:27:50,119
Todos los jugadores de un equipo

568
00:27:50,119 --> 00:27:55,859
Vale, pues entonces

569
00:27:55,859 --> 00:27:57,259
¿Qué nos podríamos plantear hacer?

570
00:27:57,359 --> 00:27:58,380
¿Qué os plantearíais hacer?

571
00:28:00,720 --> 00:28:01,079
Pues

572
00:28:01,079 --> 00:28:05,440
Podríamos hacer

573
00:28:05,440 --> 00:28:06,660
A ver, lo que pasa es que como

574
00:28:06,660 --> 00:28:09,359
Ya empieza a ser un main muy largo y si luego lo vamos a subir

575
00:28:09,359 --> 00:28:10,799
Para que lo tengáis como ejemplo de set

576
00:28:10,799 --> 00:28:12,779
Lo vamos a sacar a métodos

577
00:28:12,779 --> 00:28:15,259
De añadir, borrar, para que quede más

578
00:28:15,259 --> 00:28:16,720
Más claro todo

579
00:28:16,720 --> 00:28:19,559
¿Vale? Entonces vamos a hacernos

580
00:28:19,559 --> 00:28:21,460
Primero el método

581
00:28:21,460 --> 00:28:22,579
De mostrar jugadores

582
00:28:22,579 --> 00:28:25,180
Para tener el for

583
00:28:25,180 --> 00:28:27,160
Y así dejamos este proyecto colocado

584
00:28:27,160 --> 00:28:28,779
Y repasamos

585
00:28:28,779 --> 00:28:31,140
Venga, pues para mostrar jugadores

586
00:28:31,140 --> 00:28:32,019
Le paso un set

587
00:28:32,019 --> 00:28:33,339
Y que me va a hacer este método

588
00:28:33,339 --> 00:28:34,940
Pues me va a recorrer el set

589
00:28:34,940 --> 00:28:38,769
Para cada jugador

590
00:28:38,769 --> 00:28:39,150
J

591
00:28:39,150 --> 00:28:42,490
En el set que yo le paso

592
00:28:42,490 --> 00:28:45,529
Que me muestre

593
00:28:45,529 --> 00:28:47,549
J.todo

594
00:28:47,549 --> 00:28:49,269
Venga, el número

595
00:28:49,269 --> 00:28:57,920
El

596
00:28:57,920 --> 00:29:01,440
Nombre

597
00:29:01,440 --> 00:29:05,539
Y el equipo

598
00:29:05,539 --> 00:29:11,440
Ala, ya tengo mostrar jugadores

599
00:29:11,440 --> 00:29:12,380
Vale

600
00:29:12,380 --> 00:29:18,690
Vamos a hacer el de

601
00:29:18,690 --> 00:29:20,490
¿Qué más hemos hecho por aquí?

602
00:29:21,369 --> 00:29:23,309
El de insertar jugador

603
00:29:23,309 --> 00:29:27,430
El de insertar jugador

604
00:29:27,430 --> 00:29:29,309
Pues venga

605
00:29:29,309 --> 00:29:30,849
Vamos a hacer

606
00:29:30,849 --> 00:29:42,019
Dado un objeto jugador

607
00:29:42,019 --> 00:29:42,839
Este

608
00:29:42,839 --> 00:29:47,160
Obviamente tiene poco que hacer

609
00:29:47,160 --> 00:29:49,680
Ya lo hemos probado

610
00:29:49,680 --> 00:29:52,039
Que es, ah, y le pasamos la colección

611
00:29:52,039 --> 00:29:53,339
en la que tiene que insertarlo, claro

612
00:29:53,339 --> 00:29:59,079
insertar jugador en esta colección

613
00:29:59,079 --> 00:30:00,880
pues este método

614
00:30:00,880 --> 00:30:02,720
cortito, pero así lo tenemos

615
00:30:02,720 --> 00:30:04,980
aparte, será en la colección

616
00:30:04,980 --> 00:30:06,740
que me han pasado, en la colección

617
00:30:06,740 --> 00:30:08,339
jugadores.add

618
00:30:08,339 --> 00:30:09,519
el jugador j

619
00:30:09,519 --> 00:30:12,559
ya está, vale

620
00:30:12,559 --> 00:30:14,380
ya sabemos como funciona

621
00:30:14,380 --> 00:30:16,839
no inserta los

622
00:30:16,839 --> 00:30:18,759
duplicados, siendo el criterio

623
00:30:18,759 --> 00:30:20,980
de duplicado que el hashCode y el equals

624
00:30:20,980 --> 00:30:22,140
den lo mismo

625
00:30:22,140 --> 00:30:24,819
vale, que más

626
00:30:24,819 --> 00:30:26,500
hemos hecho en el main

627
00:30:26,500 --> 00:30:29,599
pues en el main hemos insertado

628
00:30:29,599 --> 00:30:31,140
y después de insertar hemos mostrado

629
00:30:31,140 --> 00:30:32,920
que ya lo tenemos

630
00:30:32,920 --> 00:30:34,440
puesto en dos métodos

631
00:30:34,440 --> 00:30:37,400
vale, ahora hemos

632
00:30:37,400 --> 00:30:39,279
hecho ver si existe de un

633
00:30:39,279 --> 00:30:41,599
equipo dado, vamos a hacerlo en un método aparte también

634
00:30:41,599 --> 00:30:45,460
aquí static, porque si no voy a poder llamar

635
00:30:45,460 --> 00:30:50,539
pues vamos a hacer

636
00:30:50,539 --> 00:30:52,480
un método boolean, static

637
00:30:52,480 --> 00:30:58,180
también, que sea

638
00:30:58,180 --> 00:31:00,640
existen jugadores

639
00:31:00,640 --> 00:31:02,279
en el equipo que yo le dé

640
00:31:02,279 --> 00:31:06,480
entonces, a este le pasamos

641
00:31:06,480 --> 00:31:14,069
y el set

642
00:31:14,069 --> 00:31:29,339
claro, vale, y aquí

643
00:31:29,339 --> 00:31:31,140
¿qué hemos hecho? pues vamos a

644
00:31:31,140 --> 00:31:33,079
copiar y pegar lo que hemos hecho, ahora lo

645
00:31:33,079 --> 00:31:35,460
repasamos todo para que

646
00:31:35,460 --> 00:31:37,460
vale, pues

647
00:31:37,460 --> 00:31:38,859
hemos pedido nombre de equipo

648
00:31:38,859 --> 00:31:43,440
y hemos hecho este código

649
00:31:43,440 --> 00:31:49,029
vale, o sea, hemos pedido

650
00:31:49,029 --> 00:31:49,829
nombre de equipo

651
00:31:49,829 --> 00:31:56,980
ah, bueno, no, es que se lo estamos pasando por parámetro

652
00:31:56,980 --> 00:31:58,839
perdón, perdón, que se lo estamos pasando por parámetro

653
00:31:58,839 --> 00:32:01,559
Vale, pues hacíamos esto

654
00:32:01,559 --> 00:32:02,740
Y ahora ya return

655
00:32:02,740 --> 00:32:04,700
Está

656
00:32:04,700 --> 00:32:07,119
Este es nuestro método de existir jugadores

657
00:32:07,119 --> 00:32:09,759
Hace el boolean

658
00:32:09,759 --> 00:32:12,140
Y si detecta uno cuyo equipo es igual que el que le paso

659
00:32:12,140 --> 00:32:13,420
True, devuelve

660
00:32:13,420 --> 00:32:15,619
Vale, esto sería para

661
00:32:15,619 --> 00:32:17,119
Ver si existen jugadores de ese equipo

662
00:32:17,119 --> 00:32:18,640
Vale, que más cosas hemos hecho en el main

663
00:32:18,640 --> 00:32:23,980
¿Existe un jugador con número y equipo dado?

664
00:32:24,440 --> 00:32:25,180
Esto hemos hecho

665
00:32:25,180 --> 00:32:27,519
Pues vamos a

666
00:32:27,519 --> 00:32:31,430
Hacer este método

667
00:32:31,430 --> 00:32:41,170
Existe

668
00:32:41,170 --> 00:32:48,210
Jugador, que le vamos a llamar

669
00:32:48,210 --> 00:32:49,910
Al jugador habría que, a este método

670
00:32:49,910 --> 00:32:51,150
Habría que pasarle el número

671
00:32:51,150 --> 00:32:53,930
El equipo, porque son las dos

672
00:32:53,930 --> 00:32:55,970
Cosas que lo caracterizan de forma única

673
00:32:55,970 --> 00:32:57,809
Y luego el set

674
00:32:57,809 --> 00:32:59,869
En el que tiene que mirar

675
00:32:59,869 --> 00:33:14,900
Vale, pues este mucho más fácil

676
00:33:14,900 --> 00:33:16,799
Porque este

677
00:33:16,799 --> 00:33:18,500
Aquí ya sí que se podía hacer el contains

678
00:33:18,500 --> 00:33:20,720
Luego aquí hacemos directamente

679
00:33:20,720 --> 00:33:22,799
Devuelve

680
00:33:23,539 --> 00:33:24,779
Jugadores

681
00:33:24,779 --> 00:33:26,099
Contains

682
00:33:26,099 --> 00:33:33,680
El auxiliar que me he hecho aquí

683
00:33:33,680 --> 00:33:49,509
Vale

684
00:33:49,509 --> 00:33:51,849
Y aquí me falta

685
00:33:51,849 --> 00:33:54,150
Declararlo

686
00:33:54,150 --> 00:33:57,980
Y esto es número

687
00:33:57,980 --> 00:34:04,250
Vale, pues ya tenemos estos cuatro métodos

688
00:34:04,250 --> 00:34:07,190
Mostrar jugadores

689
00:34:07,190 --> 00:34:08,550
Nada

690
00:34:08,550 --> 00:34:11,510
Te recorre el set de jugadores

691
00:34:11,510 --> 00:34:13,150
Y te muestra nombre, equipo, etc

692
00:34:13,150 --> 00:34:15,469
Vale, insertar jugador

693
00:34:15,469 --> 00:34:18,070
Le das un jugador y te lo mete en el set

694
00:34:18,070 --> 00:34:18,929
Vale

695
00:34:18,929 --> 00:34:21,690
¿Existen jugadores en este equipo?

696
00:34:23,510 --> 00:34:25,369
Pues recorremos el array

697
00:34:25,369 --> 00:34:27,050
El set de jugadores

698
00:34:27,050 --> 00:34:29,610
Y avisamos con el boolean si encuentro uno

699
00:34:29,610 --> 00:34:30,809
O no encuentro ninguno

700
00:34:30,809 --> 00:34:32,289
Y devolvemos, vale

701
00:34:32,289 --> 00:34:34,949
¿Existe un jugador igual que este?

702
00:34:35,949 --> 00:34:38,050
Pues creamos un jugador con esos datos

703
00:34:38,050 --> 00:34:40,010
Y devolvemos el resultado del contains

704
00:34:40,010 --> 00:34:41,550
Que será true, si existe uno

705
00:34:41,550 --> 00:34:42,829
Igual a este, falso si no

706
00:34:42,829 --> 00:34:43,869
Vale

707
00:34:43,869 --> 00:34:47,389
Eran estas las cuatro funcionalidades que habíamos hecho en el main

708
00:34:47,389 --> 00:35:16,619
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.

709
00:35:16,619 --> 00:35:20,619
Pues para mostrar los datos

710
00:35:20,619 --> 00:35:22,679
Simplemente tenemos que hacer llamar al método

711
00:35:22,679 --> 00:35:25,380
Que se llamaba

712
00:35:25,380 --> 00:35:28,280
Mostrar jugadores

713
00:35:28,280 --> 00:35:30,239
Ala, ya está

714
00:35:30,239 --> 00:35:32,019
Mostramos datos, esto es lo primero que hicimos

715
00:35:32,019 --> 00:35:34,280
Vale, ¿existe jugador en un equipo dado?

716
00:35:37,960 --> 00:35:39,539
Pues vamos a avisar aquí

717
00:35:39,539 --> 00:35:51,650
Vale, leemos el nombre del equipo

718
00:35:51,650 --> 00:35:53,869
Y ahora ya en lugar de hacerlo de esta manera

719
00:35:53,869 --> 00:35:58,449
Llamamos al método correspondiente

720
00:35:58,449 --> 00:36:05,449
Que el método correspondiente se llama main.existeJugadorDeEseEquipo.

721
00:36:08,579 --> 00:36:10,260
No, no se llamaba así, este era el otro.

722
00:36:14,900 --> 00:36:16,780
ExistenJugadoresEquipos, este era.

723
00:36:25,659 --> 00:36:44,940
Entonces, comprobamos si hay jugadores en un equipo.

724
00:36:47,139 --> 00:36:48,780
Vale, esto es lo siguiente que hemos hecho.

725
00:36:51,150 --> 00:36:53,190
Vale, leemos y ya está.

726
00:36:53,389 --> 00:36:54,670
Ahora, ¿qué es lo siguiente que hemos hecho?

727
00:36:54,670 --> 00:36:57,789
Ver si existe jugador con un número

728
00:36:57,789 --> 00:36:59,610
Y equipo dado

729
00:36:59,610 --> 00:37:01,269
Pues venga, lo ponemos

730
00:37:01,269 --> 00:37:12,719
Vale, y esto como lo hacíamos

731
00:37:12,719 --> 00:37:20,690
Pues en lugar de todo esto

732
00:37:20,690 --> 00:37:23,210
Aquí llamamos

733
00:37:23,210 --> 00:37:25,150
Al método correspondiente

734
00:37:25,150 --> 00:37:29,010
Existe jugador

735
00:37:29,010 --> 00:37:29,869
Ya está

736
00:37:29,869 --> 00:37:36,409
Vale, si existe jugador con este número de equipos jugadores

737
00:37:36,409 --> 00:37:37,889
El jugador está, si no, no está

738
00:37:37,889 --> 00:37:41,030
Eliminar un jugador

739
00:37:41,030 --> 00:37:51,119
Eliminamos jugador

740
00:37:51,119 --> 00:37:55,329
Pues eliminamos jugador

741
00:37:55,329 --> 00:37:57,869
De nuevo, no hay que hacer esto

742
00:37:57,869 --> 00:37:59,349
Si no lo hay que hacer

743
00:37:59,349 --> 00:38:01,250
Eliminamos jugador

744
00:38:01,250 --> 00:38:02,969
Es llamar al método correspondiente

745
00:38:02,969 --> 00:38:04,190
Que era

746
00:38:04,190 --> 00:38:08,500
Existe

747
00:38:08,500 --> 00:38:12,510
Ah, ese no lo tenemos hecho

748
00:38:12,510 --> 00:38:13,670
Eliminar jugador todavía

749
00:38:13,670 --> 00:38:16,909
Venga, eliminar un jugador

750
00:38:16,909 --> 00:38:18,150
Este será

751
00:38:18,150 --> 00:38:20,309
Public static

752
00:38:20,309 --> 00:38:22,590
void

753
00:38:22,590 --> 00:38:25,429
eliminar

754
00:38:25,429 --> 00:38:26,309
jugador

755
00:38:26,309 --> 00:38:28,949
pasándole el número

756
00:38:28,949 --> 00:38:30,929
de jugador y el equipo

757
00:38:30,929 --> 00:38:36,210
que son los dos datos

758
00:38:36,210 --> 00:38:37,769
que lo caracterizaban

759
00:38:37,769 --> 00:38:42,039
y el set

760
00:38:42,039 --> 00:38:49,719
pues eliminar jugador con estos datos

761
00:38:49,719 --> 00:38:51,219
era

762
00:38:51,219 --> 00:38:53,340
ya lo hicimos, nos hacemos un auxiliar

763
00:38:53,340 --> 00:38:57,599
con estos datos

764
00:38:57,599 --> 00:38:59,980
y ahora lo borramos

765
00:38:59,980 --> 00:39:01,780
jugadores

766
00:39:01,780 --> 00:39:04,760
punto remove

767
00:39:04,760 --> 00:39:07,960
hala, ya está

768
00:39:07,960 --> 00:39:10,239
y ahora ya sí creo que tenemos todo lo que hemos

769
00:39:10,239 --> 00:39:12,380
hecho hasta ahora, pero metido en métodos separados

770
00:39:12,380 --> 00:39:15,679
entonces

771
00:39:15,679 --> 00:39:17,500
eliminamos jugador

772
00:39:17,500 --> 00:39:20,440
pues sería main.eliminarJugador

773
00:39:21,079 --> 00:39:24,320
pasándole el número, el equipo

774
00:39:24,320 --> 00:39:25,800
y jugadores, hala, ya está

775
00:39:25,800 --> 00:39:32,360
vale, vamos rápidamente a

776
00:39:32,360 --> 00:39:34,159
probarlo todo por si algo lo hemos escrito mal

777
00:39:34,159 --> 00:39:35,699
ejecutamos nuestro main

778
00:39:35,699 --> 00:39:41,730
vale, hemos metido

779
00:39:41,730 --> 00:39:43,670
los datos, en la colección hay tres

780
00:39:43,670 --> 00:39:45,570
está claro, los que hemos metido, ¿cuáles son?

781
00:39:45,690 --> 00:39:49,159
este, vale, comprobamos

782
00:39:49,159 --> 00:39:51,059
si hay jugadores en un equipo, vamos a ver

783
00:39:51,059 --> 00:39:53,400
si hay jugadores

784
00:39:53,400 --> 00:39:55,159
en Madrid

785
00:39:55,159 --> 00:39:56,820
existe jugador

786
00:39:56,820 --> 00:39:59,179
vamos a ver si existe un jugador

787
00:39:59,179 --> 00:40:01,059
concreto, introduzca

788
00:40:01,059 --> 00:40:03,000
nombre Madrid y

789
00:40:03,000 --> 00:40:05,199
número uno, el jugador está, vale

790
00:40:05,199 --> 00:40:06,920
y ahora vamos a eliminar

791
00:40:06,920 --> 00:40:07,679
un jugador

792
00:40:07,679 --> 00:40:10,500
eliminamos jugador

793
00:40:10,500 --> 00:40:16,429
De nombre equipo

794
00:40:16,429 --> 00:40:16,869
Y uno

795
00:40:16,869 --> 00:40:19,849
Vale, se supone que lo ha eliminado

796
00:40:19,849 --> 00:40:21,909
Pero nos faltaría un de nuevo mostrar datos

797
00:40:21,909 --> 00:40:22,309
Después

798
00:40:22,309 --> 00:40:25,710
Nos falta un de nuevo mostrar datos

799
00:40:25,710 --> 00:40:26,530
Para

800
00:40:26,530 --> 00:40:36,519
Para asegurarnos de que lo ha eliminado

801
00:40:36,519 --> 00:40:41,530
Vale, vamos a volverlo a ejecutar

802
00:40:41,530 --> 00:40:42,769
Con un mostrar jugadores

803
00:40:42,769 --> 00:40:44,269
Después de eliminar jugador

804
00:40:44,269 --> 00:40:52,559
Vale, los tres que hemos metido

805
00:40:52,559 --> 00:40:54,219
Los datos son estos

806
00:40:54,219 --> 00:40:56,739
Vamos a ver si hay jugadores

807
00:40:56,739 --> 00:40:57,880
En este

808
00:40:57,880 --> 00:40:59,840
No existe

809
00:40:59,840 --> 00:41:01,559
No existe este equipo

810
00:41:01,559 --> 00:41:04,639
Vamos a ver si existen jugadores

811
00:41:04,639 --> 00:41:05,380
Aquí

812
00:41:05,380 --> 00:41:09,280
Si existe un jugador como este

813
00:41:09,280 --> 00:41:11,179
Pues no, no existe un jugador así

814
00:41:11,179 --> 00:41:13,699
Y ahora vamos a eliminar este otro

815
00:41:13,699 --> 00:41:15,320
Madrid 1

816
00:41:15,320 --> 00:41:17,460
Efectivamente lo ha eliminado

817
00:41:17,460 --> 00:41:21,750
Vale, pues ya lo tenemos todo ahí recogido

818
00:41:21,750 --> 00:41:26,019
Y ahora

819
00:41:26,019 --> 00:41:27,940
La siguiente cosa que nos queríamos plantear

820
00:41:27,940 --> 00:41:29,699
Ahora en lugar de eliminar uno

821
00:41:29,699 --> 00:41:31,679
Concreto, uno solo

822
00:41:31,679 --> 00:41:33,920
dado número y equipo, que para eso tenemos el remove

823
00:41:33,920 --> 00:41:35,639
ya está, remove

824
00:41:35,639 --> 00:41:37,119
le paso al jugador y me borra uno igual

825
00:41:37,119 --> 00:41:39,199
ahora vamos a hacer otra funcionalidad

826
00:41:39,199 --> 00:41:42,099
que es eliminar todos los jugadores de un equipo

827
00:41:42,099 --> 00:41:44,380
eso no lo podemos hacer

828
00:41:44,380 --> 00:41:45,519
con este método así

829
00:41:45,519 --> 00:41:47,880
porque a este método hay que pasarle

830
00:41:47,880 --> 00:41:49,780
un objeto para que te borre el que sea igual

831
00:41:49,780 --> 00:41:51,699
no el que comparta equipo

832
00:41:51,699 --> 00:41:53,460
el que comparta número, no

833
00:41:53,460 --> 00:41:55,139
el que sea igual a ese

834
00:41:55,139 --> 00:41:56,199
el que sea igual

835
00:41:56,199 --> 00:41:59,360
entonces si quiero borrar todos los de un equipo

836
00:41:59,360 --> 00:42:00,579
no puedo usar este método

837
00:42:00,579 --> 00:42:02,260
Porque tengo que pasarle

838
00:42:02,260 --> 00:42:04,039
Un equipo y un número

839
00:42:04,039 --> 00:42:06,320
Para que me borre el que sea igual según equipo y número

840
00:42:06,320 --> 00:42:08,300
Bueno, vamos a hacer ese método

841
00:42:08,300 --> 00:42:16,380
Eliminar jugadores

842
00:42:16,380 --> 00:42:17,800
De un equipo concreto

843
00:42:17,800 --> 00:42:20,179
Entonces a este

844
00:42:20,179 --> 00:42:21,340
Habrá que pasarle

845
00:42:21,340 --> 00:42:23,300
Un equipo

846
00:42:23,300 --> 00:42:26,260
Y el set de jugadores con los que trabajar

847
00:42:26,260 --> 00:42:27,440
Porque como es local al main

848
00:42:27,440 --> 00:42:29,500
Se lo tenemos que pasar

849
00:42:29,500 --> 00:42:43,900
Vale, venga

850
00:42:43,900 --> 00:42:46,320
Vamos a parar aquí un momentito

851
00:42:46,320 --> 00:42:46,739
Bueno