1
00:00:00,000 --> 00:00:15,669
Venga, vamos a completar esto, vale, pues podemos recorrer así, o también podemos recorrer, vamos, silencio, vamos a verlo por completitud, no quiero que os liéis, porque en realidad esto, en esencia es todo lo mismo.

2
00:00:15,669 --> 00:00:18,089
decidir una colección

3
00:00:18,089 --> 00:00:19,370
la que se adapta a mi situación

4
00:00:19,370 --> 00:00:21,129
y una vez que la he decidido

5
00:00:21,129 --> 00:00:23,969
usarla para meter

6
00:00:23,969 --> 00:00:26,030
cosas en ella, iterar por

7
00:00:26,030 --> 00:00:27,829
ella, eliminar cosas de ella

8
00:00:27,829 --> 00:00:30,089
y usarla obviamente

9
00:00:30,089 --> 00:00:32,009
con los requisitos que cada uno necesita

10
00:00:32,009 --> 00:00:33,390
pero siempre es lo mismo

11
00:00:33,390 --> 00:00:36,009
bueno, vamos a incorporar otro método de recorrer

12
00:00:36,009 --> 00:00:37,609
el mapa para que no suene a chino

13
00:00:37,609 --> 00:00:39,789
hacedme caso

14
00:00:39,789 --> 00:00:41,950
vamos a incorporar otro método de recorrer el mapa

15
00:00:41,950 --> 00:00:43,729
para que no suene a chino si lo ves por ahí

16
00:00:43,729 --> 00:00:48,109
bueno, pues dentro de los métodos que hemos visto

17
00:00:48,109 --> 00:00:55,020
vale, dentro de los métodos

18
00:00:55,020 --> 00:00:55,740
que hemos visto

19
00:00:55,740 --> 00:01:06,709
vale, dentro de los

20
00:01:06,709 --> 00:01:08,069
métodos que hemos visto, pues

21
00:01:08,069 --> 00:01:12,579
a ver, venga ya

22
00:01:12,579 --> 00:01:14,659
no quiero ruido

23
00:01:14,659 --> 00:01:15,159
de fondo

24
00:01:15,159 --> 00:01:20,209
vale, dentro de los métodos de map, había uno también por aquí

25
00:01:20,209 --> 00:01:23,379
que es

26
00:01:23,379 --> 00:01:24,159
este

27
00:01:24,159 --> 00:01:29,219
ah, pues así no veis nada

28
00:01:29,219 --> 00:01:29,719
obviamente

29
00:01:29,719 --> 00:01:33,480
ahora si veis

30
00:01:33,480 --> 00:01:42,319
vale, pues había otro

31
00:01:42,319 --> 00:01:42,859
este

32
00:01:42,859 --> 00:01:46,219
que también parece que convierte

33
00:01:46,219 --> 00:01:48,280
en set y al convertir en set

34
00:01:48,280 --> 00:01:50,260
ya podemos iterar, el problema nuestro del map

35
00:01:50,260 --> 00:01:51,859
es que al ser pares

36
00:01:51,859 --> 00:01:54,400
no había un for each por el que iterar

37
00:01:54,400 --> 00:01:56,439
ni un iterador, porque son pares, ¿cómo haremos eso?

38
00:01:56,480 --> 00:01:57,640
entonces tenemos que convertir a set

39
00:01:57,640 --> 00:02:00,359
pues dijimos, vale, sacamos un set

40
00:02:00,359 --> 00:02:02,200
de las claves e iteramos

41
00:02:02,200 --> 00:02:04,099
por las claves recuperando luego por clave

42
00:02:04,099 --> 00:02:05,060
que es lo que acabamos de hacer

43
00:02:05,060 --> 00:02:07,000
pues hay este otro método

44
00:02:07,000 --> 00:02:08,919
que también te devuelve un set

45
00:02:08,919 --> 00:02:10,719
por el que ya podemos iterar

46
00:02:10,719 --> 00:02:12,000
pero un set de qué

47
00:02:12,000 --> 00:02:14,599
de objetos entry de este tipo

48
00:02:14,599 --> 00:02:16,639
que son como objetos envolvente del map

49
00:02:16,639 --> 00:02:18,500
entonces este objeto

50
00:02:18,500 --> 00:02:20,080
te envuelve el map

51
00:02:20,080 --> 00:02:22,520
en un objeto único, ya no en un par

52
00:02:22,520 --> 00:02:25,000
y el entry set te devuelve

53
00:02:25,000 --> 00:02:26,840
un conjunto de esos

54
00:02:26,840 --> 00:02:29,000
envolventes del map, del par

55
00:02:29,000 --> 00:02:31,340
bueno, pues nos facilita el recorrido

56
00:02:31,340 --> 00:02:32,159
nos lo facilita

57
00:02:32,159 --> 00:02:34,560
¿cómo lo usaríamos? por ejemplo

58
00:02:34,560 --> 00:02:37,659
¿cómo lo usaríamos? pues por ejemplo así

59
00:02:37,659 --> 00:02:46,669
pues entonces

60
00:02:46,669 --> 00:02:53,250
yo me hago un set

61
00:02:53,250 --> 00:02:54,710
de este tipo raro

62
00:02:54,710 --> 00:03:06,889
set alumno

63
00:03:06,889 --> 00:03:15,849
por ejemplo así

64
00:03:15,849 --> 00:03:19,400
punto y coma

65
00:03:19,400 --> 00:03:29,139
entonces fijaos

66
00:03:29,139 --> 00:03:29,780
que es esto

67
00:03:29,780 --> 00:03:32,840
¿vale? no, tenéis que iros acostumbrando

68
00:03:32,840 --> 00:03:34,759
no os volváis locos por ver con las escritas

69
00:03:34,759 --> 00:03:36,580
podéis ver una aplicación

70
00:03:36,580 --> 00:03:38,960
y veis escrito 200.000 cosas

71
00:03:38,960 --> 00:03:41,300
aquí que se abren, que se cierran, que parametrizan

72
00:03:41,300 --> 00:03:43,379
Da igual, es lo de siempre, pero ya lo conocéis.

73
00:03:43,500 --> 00:03:44,199
Vale, pues, ¿esto qué es?

74
00:03:44,620 --> 00:03:47,240
Un conjunto de este tipo de datos.

75
00:03:47,699 --> 00:03:48,060
Muy bien.

76
00:03:48,620 --> 00:03:50,379
¿Y este tipo de datos cuál es?

77
00:03:51,219 --> 00:03:58,500
Pues, es un tipo entry que a su vez depende de string y alumno.

78
00:03:59,219 --> 00:04:00,659
¿Este tipo entry qué es?

79
00:04:01,080 --> 00:04:02,680
Es un tipo que envuelve el par.

80
00:04:03,099 --> 00:04:07,439
Envuelve el par de clave string, valor alumno.

81
00:04:08,180 --> 00:04:11,259
Bueno, pues, ya tengo un conjunto que he sacado.

82
00:04:11,300 --> 00:04:13,400
paso aquí debajo lo del igual

83
00:04:13,400 --> 00:04:14,319
para que se vea mejor

84
00:04:14,319 --> 00:04:17,699
que he sacado a través del entry set

85
00:04:17,699 --> 00:04:19,740
entonces el entry set me saca

86
00:04:19,740 --> 00:04:21,779
un conjunto de este tipo

87
00:04:21,779 --> 00:04:22,480
de datos tan raro

88
00:04:22,480 --> 00:04:25,720
y ahora como esto es un conjunto ya puedo iterar

89
00:04:25,720 --> 00:04:26,040
por él

90
00:04:26,040 --> 00:04:29,259
y dentro de cada uno de los objetos

91
00:04:29,259 --> 00:04:31,500
de este conjunto tengo un objeto

92
00:04:31,500 --> 00:04:32,540
que me envuelve el par

93
00:04:32,540 --> 00:04:35,459
y lo saco, por ejemplo así

94
00:04:35,459 --> 00:04:37,600
vamos a iterar

95
00:04:37,600 --> 00:04:39,100
por él por ejemplo con un for each

96
00:04:39,100 --> 00:04:40,379
para que sea más fácil

97
00:04:40,379 --> 00:04:42,939
Pues para cada objeto de este tipo

98
00:04:42,939 --> 00:04:45,740
Para cada objeto de este tipo

99
00:04:45,740 --> 00:04:48,420
E

100
00:04:48,420 --> 00:04:50,220
Dentro de

101
00:04:50,220 --> 00:04:52,480
Este set

102
00:04:52,480 --> 00:04:53,540
De alums

103
00:04:53,540 --> 00:04:55,579
¿E qué tiene?

104
00:04:56,060 --> 00:04:58,319
Pues E tiene un get key

105
00:04:58,319 --> 00:04:59,639
Para sacar la clave

106
00:04:59,639 --> 00:05:01,120
Y un get value para sacar el valor

107
00:05:01,120 --> 00:05:02,819
Pues ya está, ya tengo lo que quería

108
00:05:02,819 --> 00:05:06,959
Lo vamos a escribir y ahora repetimos otra vez lo que es esto

109
00:05:06,959 --> 00:05:08,980
Sí, por eso

110
00:05:08,980 --> 00:05:10,480
Lo escribo y lo volvemos a repetir

111
00:05:10,480 --> 00:05:34,100
Lo paso aquí debajo, lo del system out para que... punto get value. Vale, a ver, pues repetimos otra vez desde el principio.

112
00:05:35,399 --> 00:05:44,199
A ver, el problema que tenemos para iterar por un map es que son pares, no es un conjunto de objetos sencillos ni una lista.

113
00:05:44,680 --> 00:05:51,720
Entonces el for each no nos vale porque el for each solo vale para recorrer colecciones de objetos sencillos, no de pares.

114
00:05:51,740 --> 00:05:54,680
y el iterator igual

115
00:05:54,680 --> 00:05:56,579
eso no nos vale para iterar por set

116
00:05:56,579 --> 00:05:58,579
por colecciones, por set o por list

117
00:05:58,579 --> 00:06:00,480
¿vale? entonces

118
00:06:00,480 --> 00:06:02,040
tenemos que conseguir

119
00:06:02,040 --> 00:06:04,420
algo aquí para el forEach

120
00:06:04,420 --> 00:06:06,759
que sea una colección de objetos sencillos

121
00:06:06,759 --> 00:06:07,339
no de pares

122
00:06:07,339 --> 00:06:10,259
bueno, pues para eso tenemos el método

123
00:06:10,259 --> 00:06:12,860
entrySet, que se lo aplicamos a un map

124
00:06:12,860 --> 00:06:14,699
este ya es el conjunto de pares

125
00:06:14,699 --> 00:06:16,800
el map, el conjunto de pares, clave, valor

126
00:06:16,800 --> 00:06:18,399
stream, alumno, stream, alumno

127
00:06:18,399 --> 00:06:20,060
pues se lo aplicamos al map

128
00:06:20,060 --> 00:06:22,060
y ese ya me devuelve un conjunto

129
00:06:22,060 --> 00:06:23,519
un set

130
00:06:23,519 --> 00:06:26,000
ya me devuelve un conjunto de valores sencillos

131
00:06:26,000 --> 00:06:27,579
pero ¿de qué tipo de valor?

132
00:06:28,100 --> 00:06:28,839
¿de qué tipo de valor?

133
00:06:29,319 --> 00:06:31,339
pues de un tipo de dato que se llama entry

134
00:06:31,339 --> 00:06:33,660
que es un envolvente del par

135
00:06:33,660 --> 00:06:36,279
es como si fuera un objeto

136
00:06:36,279 --> 00:06:37,560
en el que se meten dentro

137
00:06:37,560 --> 00:06:39,360
como si fueran dos propiedades suyas

138
00:06:39,360 --> 00:06:41,160
los dos elementos del par

139
00:06:41,160 --> 00:06:43,680
entonces el par que es así

140
00:06:43,680 --> 00:06:46,360
se mete dentro de un objeto entry

141
00:06:46,360 --> 00:06:47,939
como dos propiedades internas

142
00:06:47,939 --> 00:06:49,759
se mete un objeto entry

143
00:06:49,759 --> 00:06:52,779
y ya tengo un set

144
00:06:52,779 --> 00:06:54,360
de esos objetos entre

145
00:06:54,360 --> 00:06:56,779
que tienen cada uno de ellos dentro

146
00:06:56,779 --> 00:06:58,579
en la clave y el valor

147
00:06:58,579 --> 00:06:59,319
la clave y el valor

148
00:06:59,319 --> 00:07:02,360
pues este objeto set

149
00:07:02,360 --> 00:07:03,740
ya lo puedo recorrer

150
00:07:03,740 --> 00:07:05,000
ya lo recorro

151
00:07:05,000 --> 00:07:08,259
y cada objeto de estos C hemos dicho que tiene dentro

152
00:07:08,259 --> 00:07:09,620
la clave y el valor, la tiene dentro

153
00:07:09,620 --> 00:07:11,220
¿cómo la sacamos?

154
00:07:11,980 --> 00:07:13,980
pues con getKey sacamos la clave

155
00:07:13,980 --> 00:07:16,240
y con getValue sacamos el valor

156
00:07:16,240 --> 00:07:18,139
entonces

157
00:07:18,139 --> 00:07:20,399
esta sería una forma alternativa de recorrer

158
00:07:20,399 --> 00:07:22,439
mi conjunto de pares

159
00:07:22,439 --> 00:07:24,600
lo transformo

160
00:07:24,600 --> 00:07:26,540
a un conjunto de objetos sencillos

161
00:07:26,540 --> 00:07:28,540
donde cada objeto sencillo

162
00:07:28,540 --> 00:07:29,160
es de este tipo

163
00:07:29,160 --> 00:07:32,399
que es un objeto sencillo que tiene dentro

164
00:07:32,399 --> 00:07:33,540
como propiedades suyas

165
00:07:33,540 --> 00:07:35,660
la clave y el valor del mapa

166
00:07:35,660 --> 00:07:37,339
lo han vuelto dentro

167
00:07:37,339 --> 00:07:40,699
y ahora ya recorro ese conjunto

168
00:07:40,699 --> 00:07:42,439
y saco de cada uno

169
00:07:42,439 --> 00:07:43,639
de esos elementos

170
00:07:43,639 --> 00:07:46,459
su propiedad clave, su propiedad valor

171
00:07:46,459 --> 00:07:49,399
y claro

172
00:07:49,399 --> 00:07:51,660
este tipo entry

173
00:07:51,660 --> 00:07:54,240
es genérico también porque lo que envuelve

174
00:07:54,240 --> 00:07:55,980
dependerá del tipo

175
00:07:55,980 --> 00:07:57,459
de dato que sea en la clave y el valor

176
00:07:57,459 --> 00:07:59,639
en este caso la clave y el valor

177
00:07:59,639 --> 00:08:01,839
en string alumno, por eso este entry

178
00:08:01,839 --> 00:08:07,279
es string alumno, pero si

179
00:08:07,279 --> 00:08:09,019
quisiéramos recorrer de esta manera

180
00:08:09,019 --> 00:08:10,939
esa otra colección que hemos hecho

181
00:08:10,939 --> 00:08:13,639
¿vale? por ejemplo esta otra colección

182
00:08:13,639 --> 00:08:14,339
que hicimos

183
00:08:14,339 --> 00:08:16,259
que era la colección

184
00:08:16,259 --> 00:08:18,579
esta asignación

185
00:08:18,579 --> 00:08:20,660
vamos a recorrerla ahora

186
00:08:20,660 --> 00:08:22,339
esta es de

187
00:08:22,339 --> 00:08:23,980
un map de alumno stream

188
00:08:23,980 --> 00:08:26,939
pues para recorrerla haríamos esto mismo

189
00:08:26,939 --> 00:08:27,860
pero de esta otra manera

190
00:08:27,860 --> 00:08:34,720
haríamos, primero

191
00:08:34,720 --> 00:08:41,519
sacamos el entry set

192
00:08:41,519 --> 00:08:43,159
de esa colección

193
00:08:43,159 --> 00:08:44,399
que era asignaciones

194
00:08:44,399 --> 00:08:46,860
creo que se llamaba

195
00:08:46,860 --> 00:08:48,759
asignación

196
00:08:48,759 --> 00:08:49,600
se llamaba el map

197
00:08:49,600 --> 00:08:51,940
asignación

198
00:08:51,940 --> 00:08:54,360
vale, pero claro

199
00:08:54,360 --> 00:08:56,700
el objeto entry que envuelve

200
00:08:56,700 --> 00:08:58,559
a cada par de asignaciones

201
00:08:58,559 --> 00:08:59,480
ese objeto entry

202
00:08:59,480 --> 00:09:01,419
a lo que envuelve es

203
00:09:01,419 --> 00:09:03,659
a una clave de tipo alumno

204
00:09:03,659 --> 00:09:08,240
y a un valor de tipo string.

205
00:09:09,139 --> 00:09:10,659
Entonces tenemos que ponerlo correctamente.

206
00:09:11,980 --> 00:09:12,179
¿Vale?

207
00:09:13,519 --> 00:09:14,799
Asignación era un map

208
00:09:14,799 --> 00:09:16,519
de clave alumno

209
00:09:16,519 --> 00:09:18,419
valor string.

210
00:09:18,980 --> 00:09:20,139
Pues el objeto entry

211
00:09:20,139 --> 00:09:21,639
que envuelve ese par

212
00:09:21,639 --> 00:09:23,399
ese objeto entry

213
00:09:23,399 --> 00:09:25,840
entonces su tipo será

214
00:09:25,840 --> 00:09:28,659
alumno para la clave, string para el valor

215
00:09:28,659 --> 00:09:30,480
¿vale? y ahora ya

216
00:09:30,480 --> 00:09:31,659
pues lo recorremos

217
00:09:31,659 --> 00:09:37,669
así

218
00:09:37,669 --> 00:09:42,129
ah, es que no he puesto esto bien

219
00:09:42,129 --> 00:09:42,850
¿vale? así

220
00:09:42,850 --> 00:09:47,899
esto aquí, y ya está

221
00:09:47,899 --> 00:09:50,200
y con eso estaremos recorriendo el otro

222
00:09:50,200 --> 00:09:53,690
bueno, entonces es

223
00:09:53,690 --> 00:09:55,549
para recorrer el map, ya está

224
00:09:55,549 --> 00:09:57,350
recorremos el map si queremos recorrerlo

225
00:09:57,350 --> 00:09:59,789
pero normalmente un map no se usa

226
00:09:59,789 --> 00:10:01,590
para recorrerlo, un map se usa

227
00:10:01,590 --> 00:10:03,690
por la maravilla de la ventaja

228
00:10:03,690 --> 00:10:05,830
que tiene la clave, tú metes los pares

229
00:10:05,830 --> 00:10:07,649
y luego recuperas por clave

230
00:10:07,649 --> 00:10:09,409
eliminas por clave

231
00:10:09,409 --> 00:10:12,090
para eso se hace, más que para recorrerlo

232
00:10:12,090 --> 00:10:18,679
bueno, vamos a ejecutar

233
00:10:18,679 --> 00:10:20,980
por si acaso hemos escrito algo mal y nos salen cosas raras

234
00:10:20,980 --> 00:10:23,700
pero

235
00:10:23,700 --> 00:10:25,899
nos sale bien, ¿vale? este es

236
00:10:25,899 --> 00:10:28,539
el recorrido

237
00:10:28,539 --> 00:10:29,860
del primero

238
00:10:29,860 --> 00:10:32,320
y este es el recorrido

239
00:10:32,320 --> 00:10:33,879
de la segunda colección

240
00:10:33,879 --> 00:10:35,460
¿veis? me ha mostrado la clave

241
00:10:35,460 --> 00:10:37,919
que es esta, y el valor

242
00:10:37,919 --> 00:10:40,799
solo tenía un elemento, ese mapa

243
00:10:40,799 --> 00:10:44,440
este es el primer mapa

244
00:10:44,440 --> 00:10:46,860
clave, valor, clave, valor

245
00:10:46,860 --> 00:10:47,899
este es el segundo mapa

246
00:10:47,899 --> 00:10:50,019
clave

247
00:10:50,019 --> 00:10:52,179
valor

248
00:10:52,179 --> 00:10:53,639
¿vale?

249
00:10:54,960 --> 00:10:56,799
solo tenía dos, si le metemos

250
00:10:56,799 --> 00:10:58,000
otro más para ver que

251
00:10:58,000 --> 00:10:59,559
solo tenía uno, perdón

252
00:10:59,559 --> 00:11:03,879
así, era esta

253
00:11:03,879 --> 00:11:11,120
así, vale

254
00:11:11,120 --> 00:11:14,120
solo tenía uno porque Carlos al ser duplicado

255
00:11:14,120 --> 00:11:14,759
lo había metido

256
00:11:14,759 --> 00:11:16,440
Vamos a meterle dos

257
00:11:16,440 --> 00:11:19,639
Si le metemos dos

258
00:11:19,639 --> 00:11:20,759
Estos dos

259
00:11:20,759 --> 00:11:23,240
Que ahora ya al no ser duplicados los meterá

260
00:11:23,240 --> 00:11:25,120
Si le metemos dos

261
00:11:25,120 --> 00:11:26,500
Pues aquí están

262
00:11:26,500 --> 00:11:29,679
Este es el segundo mapa

263
00:11:29,679 --> 00:11:33,279
Su clave, su valor

264
00:11:33,279 --> 00:11:35,659
Su clave, su valor

265
00:11:35,659 --> 00:11:37,299
Estos alumnos ya son distintos

266
00:11:37,299 --> 00:11:38,899
Por eso los hemos metido los dos, etc

267
00:11:38,899 --> 00:11:45,159
Bueno, esos son los intríngulis del mapa

268
00:11:45,159 --> 00:11:48,840
Pero no me habéis preguntado

269
00:11:48,840 --> 00:11:50,919
Por

270
00:11:50,919 --> 00:11:55,210
Ay, he perdido

271
00:11:55,210 --> 00:11:57,049
Mi esta de

272
00:11:57,049 --> 00:11:58,490
Mapas, que pena

273
00:11:58,490 --> 00:12:29,500
Ay, que torpe soy

274
00:12:29,500 --> 00:12:30,820
Para ver las imágenes, de verdad

275
00:12:30,820 --> 00:12:34,620
Ahí está

276
00:12:34,620 --> 00:12:35,620
Vale

277
00:12:35,620 --> 00:12:40,940
¿No me habéis preguntado por esta?

278
00:12:44,340 --> 00:12:45,360
¿Estáis ansiosos?

279
00:12:46,179 --> 00:12:47,899
Por preguntarme por esta, como no me da tiempo

280
00:12:47,899 --> 00:12:48,879
Si son las 2 y 3

281
00:12:48,879 --> 00:12:50,860
Digo que no ha dado tiempo a preguntarte

282
00:12:50,860 --> 00:12:52,720
Ah, vale

283
00:12:52,720 --> 00:12:54,519
Me he preguntado por esto

284
00:12:54,519 --> 00:12:56,279
Bueno, pues a ver

285
00:12:56,279 --> 00:12:59,419
Si HashMap y LinkedHashMap

286
00:12:59,419 --> 00:13:01,779
Guardaban las claves

287
00:13:01,779 --> 00:13:03,879
En un HashSet interno

288
00:13:03,879 --> 00:13:05,600
Y por eso la clase

289
00:13:05,600 --> 00:13:06,799
En la que pertenecían las claves

290
00:13:06,799 --> 00:13:08,740
Tenía que tener HashCodeEquals

291
00:13:08,740 --> 00:13:10,159
Tremap

292
00:13:10,159 --> 00:13:13,440
¿En qué estructura creéis que guardaba las claves?

293
00:13:17,120 --> 00:13:18,919
Su clave, su valor

294
00:13:18,919 --> 00:13:20,620
Y la clave del tipo

295
00:13:20,620 --> 00:13:23,860
¿Pero en qué tipo de colección guardará TRIMAP las claves?

296
00:13:24,200 --> 00:13:26,419
O sea, HASHMAP guarda las claves en un HASHET.

297
00:13:27,120 --> 00:13:33,940
Pues TRIMAP guarda las claves en un TRISET, efectivamente.

298
00:13:34,840 --> 00:13:37,399
Entonces, TRIMAP guarda las claves en un TRISET.

299
00:13:37,559 --> 00:13:38,500
Eso es lo que tenemos que saber.

300
00:13:38,919 --> 00:13:39,919
¿Qué implica eso?

301
00:13:40,460 --> 00:13:44,080
Que la clase a la que pertenecen las claves tiene que tener entonces el qué?

302
00:13:45,440 --> 00:13:46,460
El COMPARABLE.

303
00:13:46,460 --> 00:13:49,860
Y si no tiene el comparable,

304
00:13:49,980 --> 00:13:51,159
la clase le repite las claves,

305
00:13:51,279 --> 00:13:52,559
cuando instanciemos TRIMAP,

306
00:13:53,159 --> 00:13:55,299
hay que darle un comparejo.

307
00:13:57,500 --> 00:13:59,080
¿Vale? Por ejemplo, aquí.

308
00:14:00,899 --> 00:14:02,480
En nuestro ejemplito de aquí.

309
00:14:03,759 --> 00:14:05,259
Si a mí me diera la gana,

310
00:14:06,740 --> 00:14:07,519
de repente digo,

311
00:14:07,639 --> 00:14:09,120
oye, mis alumnos estos,

312
00:14:10,059 --> 00:14:12,100
en lugar de meterlos en un HASHMAP,

313
00:14:12,600 --> 00:14:14,399
voy a meterlos en un TRIMAP.

314
00:14:15,159 --> 00:14:16,120
Cállate, Miguel.

315
00:14:16,460 --> 00:14:18,080
ya los de atrás me cuento

316
00:14:18,080 --> 00:14:23,340
de repente a mí me da la gana

317
00:14:23,340 --> 00:14:24,240
cambiar un trimap

318
00:14:24,240 --> 00:14:30,399
pues nada, no ha cambiado nada, he cambiado la implementación

319
00:14:30,399 --> 00:14:32,299
sigue siendo un mapa igual, he cambiado un trimap

320
00:14:32,299 --> 00:14:34,179
porque es más bonito, más efectivo y más todo

321
00:14:34,179 --> 00:14:35,460
vale

322
00:14:35,460 --> 00:14:37,779
¿pasaría algo?

323
00:14:38,440 --> 00:14:40,799
¿mi aplicación que trabaja con alumnos

324
00:14:40,799 --> 00:14:41,919
se rompería?

325
00:14:42,039 --> 00:14:44,700
¿tendría yo algún problema con trimap?

326
00:14:46,980 --> 00:14:47,600
¿sí o no?

327
00:14:48,259 --> 00:14:49,000
no, ¿por qué no?

328
00:14:49,000 --> 00:14:55,220
ya, ¿por qué funciona?

329
00:14:55,480 --> 00:14:57,580
¿por qué no se ha enterado y sigue funcionando perfectamente?

330
00:15:00,259 --> 00:15:01,600
porque string

331
00:15:01,600 --> 00:15:03,740
que es la clase a la que pertenecen las claves

332
00:15:03,740 --> 00:15:05,559
string esa clase ya implementa

333
00:15:05,559 --> 00:15:07,320
comparable, tiene el compare to y todo

334
00:15:07,320 --> 00:15:08,740
string es una clase

335
00:15:08,740 --> 00:15:11,379
que nos hemos hecho nosotros, que ya está hecha

336
00:15:11,379 --> 00:15:13,879
y ya está, y es estupendísima

337
00:15:13,879 --> 00:15:15,000
tiene su equals

338
00:15:15,000 --> 00:15:17,980
tiene su implements de comparable

339
00:15:17,980 --> 00:15:20,700
los strings de hecho se pueden ordenar

340
00:15:20,700 --> 00:15:22,519
alfabéticamente con el compare tool

341
00:15:22,519 --> 00:15:24,720
con lo cual aquí el cambio

342
00:15:24,720 --> 00:15:26,480
ha sido estupendo, muy bien

343
00:15:26,480 --> 00:15:28,620
yo cambio al trimap y no pasa nada

344
00:15:28,620 --> 00:15:31,100
todo funciona igual, porque la clase

345
00:15:31,100 --> 00:15:32,379
a la que pertenecen las claves

346
00:15:32,379 --> 00:15:35,299
implementa el compare tool

347
00:15:35,299 --> 00:15:37,039
el comparable, con lo cual

348
00:15:37,039 --> 00:15:37,860
el trimap

349
00:15:37,860 --> 00:15:40,519
la va a manejar sin problema

350
00:15:40,519 --> 00:15:42,720
y además

351
00:15:42,720 --> 00:15:44,940
¿qué ocurre? pues ocurre

352
00:15:44,940 --> 00:15:46,659
que si ahora iteramos

353
00:15:46,659 --> 00:15:48,899
por el HashMap, además nos va a dar la ventaja

354
00:15:48,899 --> 00:15:50,620
añadida de que

355
00:15:50,620 --> 00:15:52,460
nos lo va a mostrar por orden alfabético

356
00:15:52,460 --> 00:15:54,539
de clave, si es que eso nos

357
00:15:54,539 --> 00:15:56,559
interesa, porque así funciona el tríceps

358
00:15:56,559 --> 00:15:58,960
vale, pero ¿qué ocurre?

359
00:16:00,919 --> 00:16:02,360
ahora nos vamos a esta otra

360
00:16:02,360 --> 00:16:06,740
a esta otra colección de aquí

361
00:16:06,740 --> 00:16:07,100
abajo

362
00:16:07,100 --> 00:16:11,289
a esta

363
00:16:11,289 --> 00:16:14,389
aquí yo decido

364
00:16:14,389 --> 00:16:16,230
uy, el HashMap no me gusta, me han dicho que

365
00:16:16,230 --> 00:16:18,330
el Trimap es mucho más eficiente y más estupendo

366
00:16:18,330 --> 00:16:20,149
cambiamos

367
00:16:20,149 --> 00:16:30,990
Trimap. Aquí ya pasan cosas raras. Sí pasan cosas raras. ¿Por qué? Ojo, la clave ahora es de tipo alumno.

368
00:16:32,289 --> 00:16:39,149
Entonces, Trimap necesita que las claves sean comparables porque las guarda internamente en un triset.

369
00:16:41,009 --> 00:16:47,830
Entonces, alumno tiene que implementar comparables. Si alumno no implementa comparables, Trimap no va a saber trabajar con las claves.

370
00:16:47,830 --> 00:16:49,289
no va a saber trabajar

371
00:16:49,289 --> 00:16:51,389
igual que hashMap

372
00:16:51,389 --> 00:16:53,789
necesita que alumno implementara

373
00:16:53,789 --> 00:16:55,250
hashCodeEqual, ahí daba

374
00:16:55,250 --> 00:16:56,950
porque hashMap

375
00:16:56,950 --> 00:16:59,149
guardaba las claves en un hashSet

376
00:16:59,149 --> 00:17:01,669
pues treeMap guarda en un triset

377
00:17:01,669 --> 00:17:03,450
con lo cual treeMap

378
00:17:03,450 --> 00:17:05,309
necesita que alumno implemente comparable

379
00:17:05,309 --> 00:17:07,650
si no, esto no va a funcionar

380
00:17:07,650 --> 00:17:09,650
que no podemos hacer

381
00:17:09,650 --> 00:17:11,329
que alumno implemente comparable

382
00:17:11,329 --> 00:17:12,690
¿qué hacemos?

383
00:17:13,150 --> 00:17:15,829
pues al treeMap le pasamos un criterio de comparación

384
00:17:15,829 --> 00:17:17,650
específico aquí, igual que para

385
00:17:17,650 --> 00:17:19,029
el tris, idéntico todo

386
00:17:19,029 --> 00:17:20,230
¿vale?

387
00:17:22,670 --> 00:17:23,809
entonces ahora mismo

388
00:17:23,809 --> 00:17:25,789
mi clase alumno que no implementa nada

389
00:17:25,789 --> 00:17:27,970
pues

390
00:17:27,970 --> 00:17:32,589
¿vale? si ejecutamos

391
00:17:32,589 --> 00:17:34,529
esto, la primera parte la he hecho

392
00:17:34,529 --> 00:17:36,690
bien, la del trimap del principio de stream

393
00:17:36,690 --> 00:17:38,630
pero cuando he llegado al otro lado

394
00:17:38,630 --> 00:17:40,650
me dice, alumno, lo siento, no puede

395
00:17:40,650 --> 00:17:42,410
ser comparable, no funciona

396
00:17:42,410 --> 00:17:44,549
entonces, que queremos

397
00:17:44,549 --> 00:17:46,549
que la aplicación siga funcionando igual

398
00:17:46,549 --> 00:17:48,750
con trimap

399
00:17:48,750 --> 00:18:00,460
Vale, no pasa nada, pues entonces le ponemos a este el criterio de comparación que queramos.

400
00:18:06,170 --> 00:18:22,990
Vale, ¿qué criterio le ponemos? Pues ordenamos por nombre, mejor que por nota, porque no nos olvidemos que cuando el comparable lo hacemos para trabajar con un triseto o un trimar, ese comparable se vuelve automáticamente en criterio de igualdad.

401
00:18:22,990 --> 00:18:25,690
entonces no tiene sentido que elegamos

402
00:18:25,690 --> 00:18:27,450
el nota para comparar unos con otros

403
00:18:27,450 --> 00:18:29,650
porque misma nota

404
00:18:29,650 --> 00:18:30,970
no significa mismos alumnos

405
00:18:30,970 --> 00:18:33,529
entonces aquí tendría sentido por nombre

406
00:18:33,529 --> 00:18:34,769
la igualdad

407
00:18:34,769 --> 00:18:39,200
entonces aquí

408
00:18:39,200 --> 00:18:40,539
tendríamos que hacer

409
00:18:40,539 --> 00:18:42,920
ah bueno, espera, el compare tú

410
00:18:42,920 --> 00:18:45,660
así

411
00:18:45,660 --> 00:18:49,460
y ahora para comparar

412
00:18:49,460 --> 00:18:50,519
por nombre

413
00:18:50,519 --> 00:18:53,240
pues nos aprovechamos

414
00:18:53,240 --> 00:18:53,799
de

415
00:18:53,799 --> 00:18:58,559
dis.nombre

416
00:18:58,559 --> 00:19:00,119
el compare to del equals

417
00:19:00,119 --> 00:19:01,339
perdón, del string

418
00:19:01,339 --> 00:19:05,960
o.nombre

419
00:19:05,960 --> 00:19:12,049
vale, este sería nuestro compare to

420
00:19:12,049 --> 00:19:12,970
basado en el nombre

421
00:19:12,970 --> 00:19:14,430
el nombre del objeto dis

422
00:19:14,430 --> 00:19:15,730
el nombre del objeto o

423
00:19:15,730 --> 00:19:19,329
ahora ya sí que tenemos un compare to

424
00:19:19,329 --> 00:19:20,670
ahora ya hacemos este main

425
00:19:20,670 --> 00:19:23,809
y este main ya funciona perfectamente

426
00:19:23,809 --> 00:19:26,650
porque ya alumno

427
00:19:26,650 --> 00:19:28,430
tiene un criterio de

428
00:19:28,430 --> 00:19:34,259
¿vale? esto ya ha funcionado

429
00:19:34,259 --> 00:19:36,279
exactamente igual que antes

430
00:19:36,279 --> 00:19:38,500
la aplicación ha funcionado igual

431
00:19:38,500 --> 00:19:40,500
me ha dado igual hash map que tree map

432
00:19:40,500 --> 00:19:41,960
ha funcionado igual, son mapas igual

433
00:19:41,960 --> 00:19:43,099
son mapas, ha funcionado igual

434
00:19:43,099 --> 00:19:45,700
lo único es que si uso hash map

435
00:19:45,700 --> 00:19:47,920
no me tengo que olvidar del hash code del equals

436
00:19:47,920 --> 00:19:49,380
en la clase de las claves

437
00:19:49,380 --> 00:19:51,900
y si uso tree map no me tengo que olvidar

438
00:19:51,900 --> 00:19:54,160
del comparable en la clase de las claves

439
00:19:54,160 --> 00:19:56,380
si no hago eso

440
00:19:56,380 --> 00:19:58,319
me da igual el mapa que elija, va a funcionar igual

441
00:19:58,319 --> 00:20:01,000
La única variante es que si he usado

442
00:20:01,000 --> 00:20:01,579
TRIMAP

443
00:20:01,579 --> 00:20:04,019
A la hora de iterar

444
00:20:04,019 --> 00:20:05,319
Me salen ordenados

445
00:20:05,319 --> 00:20:08,579
Pues bueno, pues sí, vale, me salen ordenados

446
00:20:08,579 --> 00:20:10,220
¿Vale?

447
00:20:10,799 --> 00:20:12,920
Alfabéticamente, es extraordinario alfabéticamente

448
00:20:12,920 --> 00:20:14,640
Y es extraordinario alfabéticamente

449
00:20:14,640 --> 00:20:15,960
Uno va antes que el cinco

450
00:20:15,960 --> 00:20:18,660
Es extraordinario alfabéticamente por claves

451
00:20:18,660 --> 00:20:20,019
Orden alfabético aquí

452
00:20:20,019 --> 00:20:21,980
Y orden alfabético aquí

453
00:20:21,980 --> 00:20:24,559
Aunque yo lo haya insertado de la otra manera

454
00:20:24,559 --> 00:20:26,259
Aunque lo haya insertado de la otra manera

455
00:20:26,259 --> 00:20:28,599
me lo pasa por orden alfabético

456
00:20:28,599 --> 00:20:30,279
vale

457
00:20:30,279 --> 00:20:32,640
y lo mismo que el triset

458
00:20:32,640 --> 00:20:34,920
que no podemos alterar

459
00:20:34,920 --> 00:20:36,259
la clase alumno

460
00:20:36,259 --> 00:20:38,619
que no hay forma de poner el comparable

461
00:20:38,619 --> 00:20:39,819
aquí, que no hay manera

462
00:20:39,819 --> 00:20:43,079
bueno, pues le hacemos el comparator y se lo damos al trimap

463
00:20:43,079 --> 00:20:44,900
por ejemplo, voy a copiar

464
00:20:44,900 --> 00:20:46,480
el comparator del ejemplo triset

465
00:20:46,480 --> 00:20:47,180
que nos vale

466
00:20:47,180 --> 00:20:50,900
orden ciudades

467
00:20:51,680 --> 00:20:55,789
luego lo cambio

468
00:20:55,789 --> 00:20:56,690
con orden alumnos

469
00:20:56,690 --> 00:20:59,069
Paste, vale

470
00:20:59,069 --> 00:21:03,890
Orden ciudades, orden alumnos

471
00:21:03,890 --> 00:21:09,019
Orden alumnos

472
00:21:09,019 --> 00:21:13,240
Con un comparator de alumno

473
00:21:13,240 --> 00:21:17,680
Y ahora esto será alumno

474
00:21:17,680 --> 00:21:26,180
Alumno y alumno

475
00:21:26,180 --> 00:21:31,170
Vale

476
00:21:31,170 --> 00:21:35,250
Y tengo que cambiar este nombre

477
00:21:35,250 --> 00:21:40,769
Esperad, lo repetimos todo

478
00:21:40,769 --> 00:21:48,240
Vale

479
00:21:48,240 --> 00:21:50,500
Alumno 1 o 2

480
00:21:50,500 --> 00:21:52,019
¿Por qué me dice que no encuentra nombre?

481
00:21:52,099 --> 00:21:52,880
¿Alumno no tiene nombre?

482
00:21:55,539 --> 00:21:57,200
Ah, bueno, porque es privado

483
00:21:57,200 --> 00:21:59,779
Vale, ordena alumnos

484
00:21:59,779 --> 00:22:01,339
Pues no pasa nada, le ponemos

485
00:22:01,339 --> 00:22:07,240
GetNombre

486
00:22:07,240 --> 00:22:12,170
Y GetNombre

487
00:22:12,170 --> 00:22:14,490
Vale, pues entonces

488
00:22:14,490 --> 00:22:17,230
Este es un criterio de ordenación de alumnos

489
00:22:17,230 --> 00:22:18,289
Me dice

490
00:22:18,289 --> 00:22:20,930
¿Te doy dos alumnos o uno o dos?

491
00:22:21,410 --> 00:22:26,009
y el criterio de ordenación que tú quieras, por nombre, criterio de ordenación, vale,

492
00:22:26,809 --> 00:22:29,829
pues resulta que a alumno no le podemos poner el comparable,

493
00:22:30,130 --> 00:22:32,410
porque no nos dejan, porque no podemos alterar esa clase,

494
00:22:33,490 --> 00:22:38,319
no podemos ponérsela, no podemos ponerle el comparable,

495
00:22:38,680 --> 00:22:49,950
con lo cual esto de aquí tampoco estaría, esto de aquí no estaría,

496
00:22:50,690 --> 00:22:52,130
entonces como no le puedo poner el comparable,

497
00:22:52,309 --> 00:22:55,890
efectivamente aquí me va a salir, cuando trate de ejecutar esto,

498
00:22:55,890 --> 00:22:58,950
me va a decir al TRIMAP, eh, alumno no puedo.

499
00:23:00,910 --> 00:23:02,430
¿Vale? Es lo que me está diciendo.

500
00:23:02,589 --> 00:23:03,809
Lo siento, alumno no puedo.

501
00:23:04,930 --> 00:23:06,589
Me dice, no puedo, alumno no puedo.

502
00:23:07,369 --> 00:23:11,250
No puedes trabajar con un TRIMAP con clave alumno

503
00:23:11,250 --> 00:23:13,549
porque alumno no es comparable.

504
00:23:14,369 --> 00:23:16,849
No puedo tocar alumno, no puedo ponerle comparable.

505
00:23:17,470 --> 00:23:18,230
No pasa nada.

506
00:23:19,029 --> 00:23:22,410
Le pasas a TRIMAP un criterio de ordenación específico

507
00:23:22,410 --> 00:23:23,990
para ese uso tuyo.

508
00:23:23,990 --> 00:23:25,450
pues venga

509
00:23:25,450 --> 00:23:27,230
le pasamos

510
00:23:27,230 --> 00:23:33,359
uno de estos

511
00:23:33,359 --> 00:23:36,539
y ya está, ya el trimap ya se queda tranquilo

512
00:23:36,539 --> 00:23:38,660
me dice, vale, pues para trabajar

513
00:23:38,660 --> 00:23:40,619
con las claves alumno en este

514
00:23:40,619 --> 00:23:42,799
map mío, voy a usar este criterio

515
00:23:42,799 --> 00:23:44,759
de orden, voy a usar este, que me estás pasando

516
00:23:44,759 --> 00:23:45,740
y ya está

517
00:23:45,740 --> 00:23:48,720
y ahora ya nos vuelve a funcionar esto

518
00:23:48,720 --> 00:23:49,220
pues bien

519
00:23:49,220 --> 00:23:52,099
exactamente igual que nos estaba funcionando

520
00:23:52,099 --> 00:24:06,069
bueno, pues esta es más o menos

521
00:24:06,069 --> 00:24:08,210
toda la historia y todo lo que está

522
00:24:08,210 --> 00:24:10,230
en relación a las colecciones

523
00:24:10,230 --> 00:24:13,509
de nuevo no es tanto su uso

524
00:24:13,509 --> 00:24:17,289
es sencillo, si es que es llamar a tres métodos

525
00:24:17,289 --> 00:24:18,769
declarar cuatro cosas

526
00:24:18,769 --> 00:24:23,390
de nuevo la complejidad de la programación no es escribir el código

527
00:24:23,390 --> 00:24:26,650
es entender bien la aplicación

528
00:24:26,650 --> 00:24:28,049
con la que queremos trabajar

529
00:24:28,049 --> 00:24:30,529
y tomar las decisiones correctas

530
00:24:30,529 --> 00:24:32,690
para diseñarla, tomar las decisiones correctas

531
00:24:32,690 --> 00:24:36,390
y luego ya usamos esos recursos que hemos seleccionado

532
00:24:36,390 --> 00:24:38,910
y esos requisitos de uso

533
00:24:38,910 --> 00:24:41,970
esas formas de uso pues son las que hemos estado un poco viendo

534
00:24:41,970 --> 00:24:43,849
vale

535
00:24:43,849 --> 00:24:47,140
vale, pues venga

536
00:24:47,140 --> 00:24:48,980
lo dejamos aquí