1
00:00:00,180 --> 00:00:03,720
Vale, pues entonces

2
00:00:03,720 --> 00:00:05,459
Como a nadie se le ocurre más

3
00:00:05,459 --> 00:00:07,559
A mí es que solo me vienen Bini y Entidad a la cabeza

4
00:00:07,559 --> 00:00:10,000
Como a nadie se os ocurre más

5
00:00:10,000 --> 00:00:11,619
Términos

6
00:00:11,619 --> 00:00:13,720
Y nos da pereza preguntarle a esa gente

7
00:00:13,720 --> 00:00:15,759
Que le tenemos agobiado de tantas preguntas

8
00:00:15,759 --> 00:00:18,260
Ya tendremos tiempo de preguntarle

9
00:00:18,260 --> 00:00:19,719
Pues vamos a llamar

10
00:00:19,719 --> 00:00:21,780
A nuestro paquete, pues Bins, por ejemplo

11
00:00:21,780 --> 00:00:23,440
Aunque le podríamos llamar Modelo

12
00:00:23,440 --> 00:00:25,500
Modelo es un nombre o Model es un nombre

13
00:00:25,500 --> 00:00:27,399
Vale

14
00:00:27,399 --> 00:00:29,719
Vale, y no nos habíamos puesto

15
00:00:29,719 --> 00:00:31,219
de acuerdo en que íbamos a gestionar

16
00:00:31,219 --> 00:00:34,060
vamos a gestionar

17
00:00:34,060 --> 00:00:37,560
venga

18
00:00:37,560 --> 00:00:41,289
el alumno

19
00:00:41,289 --> 00:00:43,969
y el alumno

20
00:00:43,969 --> 00:00:44,890
va a tener

21
00:00:44,890 --> 00:00:47,850
esto también

22
00:00:47,850 --> 00:00:50,109
nos va a servir como recordatorio general de programación

23
00:00:50,109 --> 00:00:52,229
pero ya va a ser el último recordatorio

24
00:00:52,229 --> 00:00:54,090
que hagamos porque no hace falta recordar nada

25
00:00:54,090 --> 00:00:54,530
en realidad

26
00:00:54,530 --> 00:00:58,490
el alumno va a tener

27
00:00:58,490 --> 00:00:59,450
su

28
00:00:59,450 --> 00:01:01,649
nombre

29
00:01:01,670 --> 00:01:11,890
Su NIF, su nombre y su lista de asignatura.

30
00:01:12,170 --> 00:01:19,310
Como asignatura es una palabra muy larga, vamos a poner módulo.

31
00:01:22,799 --> 00:01:32,620
Vale, lo que suele ocurrir es que si suspendéis este módulo mío,

32
00:01:32,620 --> 00:01:35,879
No suele ser tanto por los contenidos

33
00:01:35,879 --> 00:01:37,180
Propios suyos

34
00:01:37,180 --> 00:01:39,900
Que ya veréis, que no tienen mayor dificultad

35
00:01:39,900 --> 00:01:41,079
Sino

36
00:01:41,079 --> 00:01:43,480
Por cuestiones en general de Java

37
00:01:43,480 --> 00:01:45,239
De desarrollo y programación en Java

38
00:01:45,239 --> 00:01:47,280
Entonces

39
00:01:47,280 --> 00:01:49,280
Pues es importante que

40
00:01:49,280 --> 00:01:51,579
¿Quién?

41
00:01:52,060 --> 00:01:52,739
No

42
00:01:52,739 --> 00:01:56,469
Es muy completo

43
00:01:56,469 --> 00:01:58,090
Y muy estupendo

44
00:01:58,090 --> 00:02:00,689
Y por eso no hay manera de echarle del mercado

45
00:02:00,689 --> 00:02:02,269
Pese a lo rígido

46
00:02:02,269 --> 00:02:04,109
Que es y lo puñetero

47
00:02:04,109 --> 00:02:06,030
que tienes que tiparlo, todo que tienes

48
00:02:06,030 --> 00:02:07,390
que no sé cuántos, etc.

49
00:02:08,750 --> 00:02:10,110
Pero claro, eso le da

50
00:02:10,110 --> 00:02:11,770
mucha robustez

51
00:02:11,770 --> 00:02:13,270
y mucha flexibilidad.

52
00:02:13,990 --> 00:02:15,990
Venga, pues a ver, tenemos esto, aquí

53
00:02:15,990 --> 00:02:16,789
hacemos siempre

54
00:02:16,789 --> 00:02:22,229
yo para los constructores, como ya sabéis

55
00:02:22,229 --> 00:02:24,050
soy muy vaga y no los pongo a menos que

56
00:02:24,050 --> 00:02:26,090
sea imprescindible. Dejo el por defecto y luego

57
00:02:26,090 --> 00:02:27,650
seteo las propiedades y ya está.

58
00:02:28,629 --> 00:02:29,750
Pero eso no significa

59
00:02:29,750 --> 00:02:32,150
que sea lo habitual.

60
00:02:33,169 --> 00:02:33,490
Luego,

61
00:02:33,490 --> 00:02:35,689
si una vez que hago la aplicación

62
00:02:35,689 --> 00:02:37,530
ya veo que

63
00:02:37,530 --> 00:02:39,449
necesito un constructor, pues en ese momento lo creo

64
00:02:39,449 --> 00:02:40,889
y listo

65
00:02:40,889 --> 00:02:46,099
bueno, pues tendríamos

66
00:02:46,099 --> 00:02:48,259
un bin básico, y tan básico

67
00:02:48,259 --> 00:02:49,939
porque es que por tener no tiene ni

68
00:02:49,939 --> 00:02:52,120
toString, ni tiene equals, ni tiene nada

69
00:02:52,120 --> 00:02:53,439
pero ya sabemos

70
00:02:53,439 --> 00:02:56,039
en qué situaciones puede hacer falta

71
00:02:56,039 --> 00:02:57,800
el equals, en cuál es el toString

72
00:02:57,800 --> 00:03:00,139
si aparecen

73
00:03:00,139 --> 00:03:01,500
lo ponemos

74
00:03:01,500 --> 00:03:03,280
si aparecen lo ponemos

75
00:03:03,280 --> 00:03:05,340
aquí si hiciéramos un equals

76
00:03:05,340 --> 00:03:08,939
si sobre escribiéramos equals, ese equals

77
00:03:08,939 --> 00:03:12,319
sobre qué propiedad lo apoyaríais

78
00:03:12,319 --> 00:03:16,120
sobre nil, claro, ¿verdad? porque un alumno será igual a otro

79
00:03:16,120 --> 00:03:20,639
por su nil, no por su nombre, porque Adrián es Alonso, pues hay muchos

80
00:03:20,639 --> 00:03:24,780
ni por su módulo, ¿vale? y ahora

81
00:03:24,780 --> 00:03:28,039
el módulo este, pues la lista de módulos que tiene

82
00:03:28,039 --> 00:03:31,080
pues le vamos a poner

83
00:03:31,080 --> 00:03:34,740
el nombre del módulo

84
00:03:34,740 --> 00:03:37,439
Y siempre es muy socorrida

85
00:03:37,439 --> 00:03:38,020
La nota

86
00:03:38,020 --> 00:03:41,139
Que este modelo de datos

87
00:03:41,139 --> 00:03:43,000
Lo habremos hecho mil veces, seguro

88
00:03:43,000 --> 00:03:43,419
Porque

89
00:03:43,419 --> 00:03:45,900
Imaginación

90
00:03:45,900 --> 00:03:49,219
Justo imaginación no es lo que nos sobra

91
00:03:49,219 --> 00:03:52,650
A mí por lo menos

92
00:03:52,650 --> 00:03:54,389
Vale

93
00:03:54,389 --> 00:03:59,699
De nuevo

94
00:03:59,699 --> 00:04:01,719
Pues un poco vago

95
00:04:01,719 --> 00:04:03,460
El bin, ni equals, ni toString

96
00:04:03,460 --> 00:04:05,639
Ni constructores, si nos va haciendo falta

97
00:04:05,639 --> 00:04:07,439
Lo hacemos aparecer, vale

98
00:04:07,439 --> 00:04:10,319
hala pues modelo de datos

99
00:04:10,319 --> 00:04:12,259
de dos entidades y ya está

100
00:04:12,259 --> 00:04:14,479
esta aplicación solo gestiona alumnos

101
00:04:14,479 --> 00:04:15,979
con los módulos que tiene y sus notas

102
00:04:15,979 --> 00:04:16,839
se acabó

103
00:04:16,839 --> 00:04:19,019
entonces

104
00:04:19,019 --> 00:04:21,899
como fruto del análisis de la aplicación

105
00:04:21,899 --> 00:04:24,920
uno habrá sacado cuáles son los requisitos

106
00:04:24,920 --> 00:04:26,620
funcionales de la aplicación

107
00:04:26,620 --> 00:04:28,779
¿vale? los requisitos funcionales de la aplicación

108
00:04:28,779 --> 00:04:30,779
es lo que

109
00:04:30,779 --> 00:04:31,620
tiene que hacer

110
00:04:31,620 --> 00:04:32,759
eh

111
00:04:32,759 --> 00:04:36,139
insertar un nuevo alumno

112
00:04:36,139 --> 00:04:39,220
eliminar un alumno, recuperar un alumno

113
00:04:39,220 --> 00:04:40,740
dado su NIF

114
00:04:40,740 --> 00:04:42,639
agregar un módulo

115
00:04:42,639 --> 00:04:45,000
a un alumno, quitarle un módulo

116
00:04:45,000 --> 00:04:46,899
a un alumno, ver las notas

117
00:04:46,899 --> 00:04:48,540
de un alumno en tal módulo

118
00:04:48,540 --> 00:04:50,560
esas serían los requisitos funcionales

119
00:04:50,560 --> 00:04:52,800
que después de habernos entrevistado ahí

120
00:04:52,800 --> 00:04:54,019
todos juntos

121
00:04:54,019 --> 00:04:56,639
hemos hecho un documento en el que dice

122
00:04:56,639 --> 00:04:58,959
requisito funcional 1, tatatí

123
00:04:58,959 --> 00:05:00,879
requisito funcional 2, tatatí, requisito funcional 3

124
00:05:00,879 --> 00:05:01,759
tatatí, vale

125
00:05:01,759 --> 00:05:04,939
entonces parte de esos requisitos funcionales que hemos dicho

126
00:05:04,939 --> 00:05:07,060
aluden precisamente al hecho

127
00:05:07,060 --> 00:05:08,819
de insertar alumno,

128
00:05:08,899 --> 00:05:10,819
eliminar alumno. Claro, sale la pregunta

129
00:05:10,819 --> 00:05:12,779
¿de dónde? ¿Dónde van a estar

130
00:05:12,779 --> 00:05:14,060
esos alumnos guardaditos?

131
00:05:15,100 --> 00:05:16,759
Bueno, pues hemos dicho

132
00:05:16,759 --> 00:05:18,759
que ahora mismo los vamos a guardar en un

133
00:05:18,759 --> 00:05:20,819
fichero, no en una base de datos,

134
00:05:20,980 --> 00:05:21,699
sino en un fichero.

135
00:05:23,500 --> 00:05:24,019
Luego,

136
00:05:25,579 --> 00:05:28,120
de alguna manera,

137
00:05:28,800 --> 00:05:30,220
tendremos que gestionar ese fichero.

138
00:05:31,360 --> 00:05:31,579
¿Vale?

139
00:05:33,139 --> 00:05:33,660
Entonces,

140
00:05:33,660 --> 00:05:36,319
Podemos hacer

141
00:05:36,319 --> 00:05:37,920
Por ejemplo

142
00:05:37,920 --> 00:05:41,970
El paquete ya de lógica

143
00:05:41,970 --> 00:05:43,089
¿Vale?

144
00:05:44,089 --> 00:05:45,750
El paquete de lógica

145
00:05:45,750 --> 00:05:47,209
Donde va nuestra aplicación

146
00:05:47,209 --> 00:05:48,810
¡Hala!

147
00:05:50,310 --> 00:05:51,329
Así a lo bestia

148
00:05:51,329 --> 00:05:52,529
Entonces

149
00:05:52,529 --> 00:05:54,189
El paquete de lógica

150
00:05:54,189 --> 00:05:55,470
Donde va nuestra aplicación

151
00:05:55,470 --> 00:05:57,730
Pues vamos a hacer

152
00:05:57,730 --> 00:05:58,610
Nuestra

153
00:05:58,610 --> 00:06:01,029
Aplicación

154
00:06:01,029 --> 00:06:02,370
De gestión

155
00:06:02,370 --> 00:06:04,149
De alumnos

156
00:06:04,149 --> 00:06:05,209
Vale

157
00:06:05,209 --> 00:06:10,500
Nuestra aplicación de gestión de alumnos

158
00:06:10,500 --> 00:06:12,399
Se me ha olvidado

159
00:06:12,399 --> 00:06:13,540
Ponerle esto

160
00:06:13,540 --> 00:06:22,139
No lleva corchetes

161
00:06:22,139 --> 00:06:23,500
¿El qué?

162
00:06:23,899 --> 00:06:24,459
El stream

163
00:06:24,459 --> 00:06:26,540
Ah, sí

164
00:06:26,540 --> 00:06:30,519
Lleva corchetes o lleva esto

165
00:06:30,519 --> 00:06:32,399
Que es más bonito

166
00:06:32,399 --> 00:06:33,980
Pero bueno, de esto ya

167
00:06:33,980 --> 00:06:36,100
Como no llegamos a hablar el año pasado

168
00:06:36,100 --> 00:06:38,800
A ver esto

169
00:06:38,800 --> 00:06:40,540
Por si alguien le inspira curiosidad

170
00:06:40,540 --> 00:06:45,660
Esto permite

171
00:06:45,660 --> 00:06:49,339
que un método tenga un número de parámetros variable

172
00:06:49,339 --> 00:06:52,379
que es algo que no llegamos a mencionar el año pasado

173
00:06:52,379 --> 00:06:54,779
porque es meter demasiadas cosas

174
00:06:54,779 --> 00:06:57,240
y uno se lo puede estudiar en 10 minutos

175
00:06:57,240 --> 00:07:00,779
entonces nosotros cuando hablamos de métodos el año pasado

176
00:07:00,779 --> 00:07:03,480
dijimos que cuando uno declara un método

177
00:07:03,480 --> 00:07:06,959
tiene que poner exactamente

178
00:07:06,959 --> 00:07:10,420
todos los parámetros que va a recibir con su tipo

179
00:07:10,420 --> 00:07:12,860
vale, eso está bien, no pasa nada

180
00:07:12,860 --> 00:07:14,800
podemos vivir así el resto de nuestra vida

181
00:07:14,800 --> 00:07:20,220
pero a veces a lo mejor nos da un poquito más de libertad

182
00:07:20,220 --> 00:07:23,519
el que un método pueda recibir a veces un int

183
00:07:23,519 --> 00:07:25,800
o a veces dos int o a veces tres int

184
00:07:25,800 --> 00:07:29,000
o a veces una cantidad variable de int

185
00:07:29,000 --> 00:07:31,600
y luego siempre un double

186
00:07:31,600 --> 00:07:34,040
es decir una cantidad de parámetros variable

187
00:07:34,040 --> 00:07:38,540
entonces estos tres puntos aquí en medio

188
00:07:38,540 --> 00:07:42,779
significan este método puede recibir

189
00:07:42,779 --> 00:07:45,660
un string o dos o tres

190
00:07:45,660 --> 00:07:47,459
o cuatro, depende de la situación

191
00:07:47,459 --> 00:07:49,379
no es igual que poner

192
00:07:49,379 --> 00:07:51,480
unos corchetes, cuando pones unos

193
00:07:51,480 --> 00:07:53,379
corchetes dices, este método recibe

194
00:07:53,379 --> 00:07:54,980
un array, vale

195
00:07:54,980 --> 00:07:57,180
este puede recibir un string suelto

196
00:07:57,180 --> 00:07:59,199
o dos string sueltos o tres string sueltos

197
00:07:59,199 --> 00:08:01,279
esa es la idea, y luego también podría

198
00:08:01,279 --> 00:08:03,399
tener este método, bueno ya no sería el main

199
00:08:03,399 --> 00:08:04,680
porque lo estoy convirtiendo en otro

200
00:08:04,680 --> 00:08:07,319
pues podría recibir

201
00:08:07,319 --> 00:08:08,040
vale

202
00:08:08,040 --> 00:08:13,480
bueno, es que como le

203
00:08:13,480 --> 00:08:21,800
Tiene que ser el

204
00:08:21,800 --> 00:08:24,519
Vale, tendría que ser el último

205
00:08:24,519 --> 00:08:26,639
Para que luego en la llamada no hubiera confusión

206
00:08:26,639 --> 00:08:28,519
Sobre lo que tú le estás pasando

207
00:08:28,519 --> 00:08:36,340
Por ejemplo, esta sería una declaración válida

208
00:08:36,340 --> 00:08:37,039
Para el método

209
00:08:37,039 --> 00:08:40,059
Siempre le tienes que pasar un entero

210
00:08:40,059 --> 00:08:41,100
Siempre un entero

211
00:08:41,100 --> 00:08:44,179
Y luego le puedes pasar un string solo

212
00:08:44,179 --> 00:08:45,799
O también le podrías llamar

213
00:08:45,799 --> 00:08:47,399
Pasándole dos strings o tres

214
00:08:47,399 --> 00:08:49,399
Bueno, solo para que os suenen

215
00:08:49,399 --> 00:08:51,080
Los tres puntitos

216
00:08:51,080 --> 00:09:01,899
Vale, solo para que suenen

217
00:09:01,899 --> 00:09:03,679
No es algo que nos importe a nosotros

218
00:09:03,679 --> 00:09:05,440
Pero como ahora ya no suenan

219
00:09:05,440 --> 00:09:08,120
Si alguien, sobre todo si alguien lo ve

220
00:09:08,120 --> 00:09:09,480
Ya no se asusta

221
00:09:09,480 --> 00:09:11,440
Y si alguien quiere los detalles

222
00:09:11,440 --> 00:09:12,960
Pues ya se lo mira en

223
00:09:12,960 --> 00:09:15,360
En 15 minutos

224
00:09:15,360 --> 00:09:16,919
Y ya domina todo lo

225
00:09:16,919 --> 00:09:19,419
Relacionado con esos tres puntitos

226
00:09:19,419 --> 00:09:23,720
¿Con los tres puntitos le puedes enviar nada?

227
00:09:25,840 --> 00:09:26,360
No

228
00:09:26,360 --> 00:09:28,740
estoy, no lo sé

229
00:09:28,740 --> 00:09:31,519
creo que le tienes

230
00:09:31,519 --> 00:09:33,480
que, creo que le puedes enviar

231
00:09:33,480 --> 00:09:35,240
nada, creo, pero no estoy segura

232
00:09:35,240 --> 00:09:37,500
no estoy segura, habría, esa es la diferencia

233
00:09:37,500 --> 00:09:39,600
entre si tú le pones un array, que tienes que poner null

234
00:09:39,600 --> 00:09:41,620
en el caso de que no hayas enviado nada, null

235
00:09:41,620 --> 00:09:43,620
o el array, un array vacío

236
00:09:43,620 --> 00:09:45,659
ahí creo que puedes no enviar

237
00:09:45,659 --> 00:09:46,019
nada

238
00:09:46,019 --> 00:09:49,720
vale, pues entonces

239
00:09:49,720 --> 00:09:51,419
aquí estamos gestionando

240
00:09:51,419 --> 00:09:52,600
los alumnos estos

241
00:09:52,600 --> 00:09:55,659
y en algún sitio

242
00:09:55,659 --> 00:09:57,980
tenemos que decidir donde van nuestros alumnos

243
00:09:57,980 --> 00:09:59,120
pues hemos dicho un fichero

244
00:09:59,120 --> 00:10:01,340
entonces como solo tenemos un fichero

245
00:10:01,340 --> 00:10:03,799
ese fichero

246
00:10:03,799 --> 00:10:05,820
puede ser una variable estática que pongamos

247
00:10:05,820 --> 00:10:06,639
aquí fuera, verdad

248
00:10:06,639 --> 00:10:09,480
static pues

249
00:10:09,480 --> 00:10:13,500
file fichero

250
00:10:13,500 --> 00:10:14,320
alumnos

251
00:10:14,320 --> 00:10:17,279
vale, este va a ser donde van

252
00:10:17,279 --> 00:10:18,220
nuestros ficheros

253
00:10:18,220 --> 00:10:25,220
y ahora nuestra aplicación lo primero que tendrá que

254
00:10:25,220 --> 00:10:26,059
hacer es

255
00:10:26,059 --> 00:10:29,360
dime el nombre fichero alumnos

256
00:10:29,360 --> 00:10:37,860
para que la aplicación ya cargue los que hubiera

257
00:10:37,860 --> 00:10:39,580
y ahora ya

258
00:10:39,580 --> 00:10:41,139
pues puede instanciar

259
00:10:41,139 --> 00:10:43,820
fichero alumnos

260
00:10:43,820 --> 00:10:47,799
con new file

261
00:10:47,799 --> 00:10:53,460
ahora ponemos

262
00:10:53,460 --> 00:10:54,120
el scanner

263
00:10:54,120 --> 00:11:07,830
que next

264
00:11:07,830 --> 00:11:09,750
next line para

265
00:11:09,750 --> 00:11:10,789
en el salto de línea

266
00:11:10,789 --> 00:11:13,529
y next para en el token de separación

267
00:11:13,529 --> 00:11:15,009
y ese token tú lo puedes cambiar

268
00:11:15,009 --> 00:11:17,669
El token de separación por defecto es el espacio

269
00:11:17,669 --> 00:11:19,090
Entonces con next

270
00:11:19,090 --> 00:11:20,809
No puede ser una línea con espacios

271
00:11:20,809 --> 00:11:23,669
A menos que previamente cambies el token de separación

272
00:11:23,669 --> 00:11:24,730
Que habrá un método para cambiarlo

273
00:11:24,730 --> 00:11:34,580
Hombre, como el fichero no tendrá espacios

274
00:11:34,580 --> 00:11:36,620
Pues podríamos poner aquí

275
00:11:36,620 --> 00:11:37,620
El next y ya está

276
00:11:37,620 --> 00:11:40,600
El nombre del fichero no tendrá espacios

277
00:11:40,600 --> 00:11:41,059
Perdón

278
00:11:41,059 --> 00:11:46,600
Y ahora aquí ya nos podríamos plantear

279
00:11:46,600 --> 00:11:48,419
Hacer la aplicación, vamos a hacer un menú

280
00:11:48,419 --> 00:11:49,879
De dos opciones, porque si no nos estamos

281
00:11:49,879 --> 00:11:52,340
Mil años, ¿vale? Solamente

282
00:11:52,340 --> 00:12:26,389
Pues por ejemplo vamos a insertar alumno y recuperar alumno, para ver que verdaderamente el alumno se ha insertado y todo eso, insertar alumno y recuperar alumno, vale, esta sería la opción 1 por ejemplo y esta la opción 2

283
00:12:26,389 --> 00:12:31,000
Y vamos a ponerle

284
00:12:31,000 --> 00:12:32,259
La cero

285
00:12:32,259 --> 00:12:35,539
Salir

286
00:12:35,539 --> 00:12:38,220
Y ahora la opción

287
00:12:38,220 --> 00:12:42,879
Para no tener problemas

288
00:12:42,879 --> 00:12:44,720
Con el salto de línea y todo eso

289
00:12:44,720 --> 00:12:47,299
La vamos a leer como string directamente

290
00:12:47,299 --> 00:12:49,539
Porque si empezamos a mezclar

291
00:12:49,539 --> 00:12:51,179
Next in con next line

292
00:12:51,179 --> 00:12:53,320
Recordad que el next in deja el salto de línea

293
00:12:53,320 --> 00:12:53,860
En el buffer

294
00:12:53,860 --> 00:12:57,059
Luego el next line siguiente se va a comer el salto de línea

295
00:12:57,059 --> 00:12:59,980
Y entonces habría que limpiar el buffer

296
00:12:59,980 --> 00:13:01,159
Si hacemos todo next line

297
00:13:01,159 --> 00:13:02,659
No hay ningún problema con eso

298
00:13:02,659 --> 00:13:04,940
Entonces vamos a leer

299
00:13:04,940 --> 00:13:06,379
Esto así

300
00:13:06,379 --> 00:13:13,610
Y ahora ya pasemos rápidamente el switch

301
00:13:13,610 --> 00:13:19,759
En el caso

302
00:13:19,759 --> 00:13:20,679
De que

303
00:13:20,679 --> 00:13:26,500
Tengamos una

304
00:13:26,500 --> 00:13:31,610
Lo que sea

305
00:13:31,610 --> 00:13:34,730
En el caso

306
00:13:34,730 --> 00:13:36,190
Uy una A no, un 1

307
00:13:36,190 --> 00:13:37,309
Un 1

308
00:13:37,309 --> 00:13:40,809
A sacar errores y nos despertamos

309
00:13:40,809 --> 00:13:41,029
¿Eh?

310
00:13:41,029 --> 00:13:41,470
Pero

311
00:13:41,470 --> 00:13:46,940
Luego habla de la verdad

312
00:13:46,940 --> 00:13:48,299
Entonces ya y dormimos

313
00:13:48,299 --> 00:13:58,559
El switch termina

314
00:13:58,559 --> 00:14:02,090
Esto sería

315
00:14:02,090 --> 00:14:09,220
Y aquí siempre poníamos

316
00:14:09,220 --> 00:14:10,679
Un default, verdad

317
00:14:10,679 --> 00:14:13,059
Con

318
00:14:13,059 --> 00:14:17,909
Opción incorrecta

319
00:14:17,909 --> 00:14:18,350
Joder

320
00:14:18,350 --> 00:14:29,860
Este es el final del switch

321
00:14:29,860 --> 00:14:31,659
Este es el final

322
00:14:31,659 --> 00:14:32,320
Del do

323
00:14:32,320 --> 00:14:35,179
Vale, con lo cual aquí lógicamente

324
00:14:35,179 --> 00:14:36,200
Nos falta el while

325
00:14:36,200 --> 00:14:38,779
mientras la opción

326
00:14:38,779 --> 00:14:40,919
sea distinta

327
00:14:40,919 --> 00:14:46,519
de la cero, vale

328
00:14:46,519 --> 00:14:48,620
mientras la opción sea distinta de la cero

329
00:14:48,620 --> 00:14:52,370
todo eso, este sería

330
00:14:52,370 --> 00:14:54,149
el esqueleto de nuestra aplicación

331
00:14:54,149 --> 00:14:56,850
solo tiene dos funcionalidades

332
00:14:56,850 --> 00:14:58,289
vale

333
00:14:58,289 --> 00:15:04,820
y ahora ya aquí

334
00:15:04,820 --> 00:15:06,139
ahora ya aquí

335
00:15:06,139 --> 00:15:08,179
para insertar alumno

336
00:15:08,179 --> 00:15:09,559
pues tendríamos que

337
00:15:09,559 --> 00:15:12,299
pedir los datos del alumno

338
00:15:12,299 --> 00:15:15,659
para no engrosar un switch case que queda muy feo

339
00:15:15,659 --> 00:15:19,639
vamos a hacerlo mediante un método de solicita datos

340
00:15:19,639 --> 00:15:24,059
alumno igual a solicita

341
00:15:24,059 --> 00:15:29,690
datos, vale, importamos

342
00:15:29,690 --> 00:15:33,769
alumno, bueno, solicita datos

343
00:15:33,769 --> 00:15:36,389
pues es este método que tendremos que hacer ahora

344
00:15:36,389 --> 00:15:41,870
que me va a devolver un alumno, importamos la clase alumno

345
00:15:41,870 --> 00:15:44,250
y ahora ya

346
00:15:44,250 --> 00:15:46,370
alumno

347
00:15:46,370 --> 00:15:48,470
pues tendríamos que meterlo

348
00:15:48,470 --> 00:15:49,830
en nuestro fichero

349
00:15:49,830 --> 00:15:52,429
tendríamos que meterlo en nuestro fichero

350
00:15:52,429 --> 00:15:58,269
no es necesario

351
00:15:58,269 --> 00:16:00,210
que recordemos mapas y nada de eso

352
00:16:00,210 --> 00:16:01,190
porque podríamos

353
00:16:01,190 --> 00:16:04,190
vamos a hacer una cosa, por si alguien tiene los

354
00:16:04,190 --> 00:16:05,590
mapas olvidados

355
00:16:05,590 --> 00:16:07,909
como esta es la versión patatera

356
00:16:07,909 --> 00:16:10,330
luego en la versión buena podemos hacerlo

357
00:16:10,330 --> 00:16:12,350
directamente con el fichero

358
00:16:12,350 --> 00:16:14,070
vamos a hacer la versión vaga

359
00:16:14,070 --> 00:16:15,210
que es

360
00:16:15,210 --> 00:16:17,870
la aplicación cuando arranca

361
00:16:17,870 --> 00:16:20,250
coge todos los alumnos

362
00:16:20,250 --> 00:16:21,090
y los lleva a un map

363
00:16:21,090 --> 00:16:23,230
si hago eso

364
00:16:23,230 --> 00:16:26,049
esto de meter el alumno

365
00:16:26,049 --> 00:16:28,409
recuperar el alumno, trabaja sobre el map

366
00:16:28,409 --> 00:16:30,230
se hacen dos patadas en una línea

367
00:16:30,230 --> 00:16:31,830
entonces

368
00:16:31,830 --> 00:16:36,320
¿qué tendríamos que hacer aquí?

369
00:16:36,320 --> 00:16:37,639
yo tengo mi fichero

370
00:16:37,639 --> 00:16:40,220
y tengo

371
00:16:40,220 --> 00:16:41,419
una estructura map

372
00:16:41,419 --> 00:16:43,559
que es la que va a tener los datos

373
00:16:43,559 --> 00:16:45,879
vale, mi estructura map

374
00:16:45,879 --> 00:16:49,440
es un diccionario

375
00:16:49,440 --> 00:16:52,440
y el diccionario ya sabéis que la utilidad

376
00:16:52,440 --> 00:16:55,120
que tiene respecto a una colección normal

377
00:16:55,120 --> 00:16:58,860
es que te saca la clave del objeto

378
00:16:58,860 --> 00:17:00,220
te la saca aquí fuera

379
00:17:00,220 --> 00:17:02,879
y al tener la clave del objeto fuera

380
00:17:02,879 --> 00:17:05,900
puedes hacer las búsquedas, las modificaciones

381
00:17:05,900 --> 00:17:07,759
los borrados mucho más fácil

382
00:17:07,759 --> 00:17:08,920
sin tener que recorrer

383
00:17:08,920 --> 00:17:12,039
Si tú tienes una colección con los objetos así

384
00:17:12,039 --> 00:17:13,880
Para hacer cualquier cosa

385
00:17:13,880 --> 00:17:15,579
Tienes que recorrer hasta que lo encuentres

386
00:17:15,579 --> 00:17:17,140
En un mapa

387
00:17:17,140 --> 00:17:19,519
La clave primaria de cada objeto

388
00:17:19,519 --> 00:17:20,640
La has sacado fuera

389
00:17:20,640 --> 00:17:23,660
Con lo cual puedes usar directamente

390
00:17:23,660 --> 00:17:25,579
La clave para localizarlo

391
00:17:25,579 --> 00:17:26,539
Sin tener que recorrer

392
00:17:26,539 --> 00:17:28,220
Bueno, pues en este caso

393
00:17:28,220 --> 00:17:29,660
Lo que vamos a guardar en el mapa

394
00:17:29,660 --> 00:17:31,339
Son alumnos, ¿verdad?

395
00:17:32,240 --> 00:17:33,359
Primero tenemos que pensar

396
00:17:33,359 --> 00:17:35,220
¿Cuál es la clave de nuestros alumnos?

397
00:17:35,339 --> 00:17:36,680
Pues nos vamos a nuestros alumnos

398
00:17:36,680 --> 00:17:38,279
La clave es el NIF, que es un string

399
00:17:38,279 --> 00:17:41,799
Luego nuestro map va a tener como clave string

400
00:17:41,799 --> 00:17:44,200
Y como valor alumno

401
00:17:44,200 --> 00:17:44,880
¿Verdad?

402
00:17:45,680 --> 00:17:47,240
Entonces inicialmente

403
00:17:47,240 --> 00:17:48,759
Esto va a ser

404
00:17:48,759 --> 00:17:50,799
Un mapa vacío

405
00:17:50,799 --> 00:17:58,160
Luego lo primero que tendremos que hacer

406
00:17:58,160 --> 00:18:01,799
Una vez que nos han dado el nombre del fichero de alumnos

407
00:18:01,799 --> 00:18:03,700
Es, bueno, ni lo he llamado

408
00:18:03,700 --> 00:18:05,380
No le he dado ni nombre

409
00:18:05,380 --> 00:18:06,559
Alumnos

410
00:18:06,559 --> 00:18:10,240
Y vamos a importar tanto map como hashmap

411
00:18:10,240 --> 00:18:17,869
Vale

412
00:18:17,869 --> 00:18:19,589
Entonces

413
00:18:19,589 --> 00:18:25,650
Recordad que había varias implementaciones

414
00:18:25,650 --> 00:18:27,329
De diccionarios o mapas

415
00:18:27,329 --> 00:18:29,230
Como lo queráis llamar, diccionario o mapa

416
00:18:29,230 --> 00:18:33,650
HashMap, Trimap y LinkedHashMap

417
00:18:34,210 --> 00:18:36,869
¿Cuál era la diferencia entre ellas?

418
00:18:37,490 --> 00:18:40,289
La diferencia era en qué tipo de estructura

419
00:18:40,289 --> 00:18:41,509
Se guardaba la clave

420
00:18:41,509 --> 00:18:43,369
Esa era la diferencia entre ellas

421
00:18:43,369 --> 00:18:45,390
En qué tipo de estructura

422
00:18:45,390 --> 00:18:47,269
Se guardaban las claves

423
00:18:47,269 --> 00:18:50,309
porque las claves son las que hay que manejar

424
00:18:50,309 --> 00:18:52,029
de alguna manera, las que Java

425
00:18:52,029 --> 00:18:54,170
tiene que manejar con más

426
00:18:54,170 --> 00:18:56,049
soltura, porque son las que

427
00:18:56,049 --> 00:18:57,730
usa para localizar los objetos

428
00:18:57,730 --> 00:18:59,390
etcétera, entonces

429
00:18:59,390 --> 00:19:02,069
si las claves se guardan en un hash set

430
00:19:02,069 --> 00:19:03,769
entonces tenemos un hash map

431
00:19:03,769 --> 00:19:05,869
si yo quiero que las claves se guarden

432
00:19:05,869 --> 00:19:07,789
en un tree set, entonces tendremos

433
00:19:07,789 --> 00:19:10,069
un tree map, vale, a su vez

434
00:19:10,069 --> 00:19:11,910
cuál es la diferencia entre guardar en un

435
00:19:11,910 --> 00:19:13,849
hash set y guardar

436
00:19:13,849 --> 00:19:18,130
en un tree set, en un

437
00:19:18,130 --> 00:19:20,589
HashSet se guardaban

438
00:19:20,589 --> 00:19:21,430
los elementos

439
00:19:21,430 --> 00:19:24,430
atendiendo

440
00:19:24,430 --> 00:19:26,049
se generaba un código de hash

441
00:19:26,049 --> 00:19:28,150
y se guardaban internamente, todo eso

442
00:19:28,150 --> 00:19:30,230
luego nos era transparente a la hora de usarlo

443
00:19:30,230 --> 00:19:32,069
pero si explicamos

444
00:19:32,069 --> 00:19:33,230
como funcionaba por dentro

445
00:19:33,230 --> 00:19:35,970
para poder elegir con criterio

446
00:19:35,970 --> 00:19:37,150
una estructura u otra

447
00:19:37,150 --> 00:19:39,829
vale, ambas son muy eficientes

448
00:19:39,829 --> 00:19:41,730
sobre todo la HashSet

449
00:19:41,730 --> 00:19:44,109
quizás es la que más se usa, entonces cuando

450
00:19:44,109 --> 00:19:46,029
Java guarda internamente

451
00:19:46,029 --> 00:19:48,210
en un hash set lo que hace

452
00:19:48,210 --> 00:19:48,670
es

453
00:19:48,670 --> 00:19:51,769
asociar un código de hash

454
00:19:51,769 --> 00:19:54,130
a cada elemento, entonces ese código

455
00:19:54,130 --> 00:19:56,069
de hash hace que luego

456
00:19:56,069 --> 00:19:57,930
cuando tiene que localizarlo dentro del hash set

457
00:19:57,930 --> 00:19:59,509
lo hace muy rápido, porque tú le das un objeto

458
00:19:59,509 --> 00:20:01,930
saca el código de hash de ese objeto

459
00:20:01,930 --> 00:20:04,210
con ese código de hash se va a su tabla hash

460
00:20:04,210 --> 00:20:05,950
y dice, ah este código de hash es este

461
00:20:05,950 --> 00:20:07,490
está aquí colocado

462
00:20:07,490 --> 00:20:10,069
entonces es bastante rápido localizar

463
00:20:10,069 --> 00:20:12,170
los elementos en un hash set porque a cada objeto

464
00:20:12,170 --> 00:20:13,289
tiene un código de hash

465
00:20:13,289 --> 00:20:15,730
te llega un objeto para localizarle

466
00:20:15,730 --> 00:20:16,789
haces el hash, es este

467
00:20:16,789 --> 00:20:19,529
pero eso implicaba que cada

468
00:20:19,529 --> 00:20:21,970
que la clase esta de aquí

469
00:20:21,970 --> 00:20:23,650
tiene que tener una función

470
00:20:23,650 --> 00:20:25,670
para generar ese código, una función

471
00:20:25,670 --> 00:20:28,069
esa función era la implementación

472
00:20:28,069 --> 00:20:30,630
esta, vale

473
00:20:30,630 --> 00:20:33,230
string ya la tiene, string ya tiene

474
00:20:33,230 --> 00:20:35,150
su propia implementación de hashCode

475
00:20:35,150 --> 00:20:36,569
no tenemos que hacerla nosotros

476
00:20:36,569 --> 00:20:38,970
luego puedo usar

477
00:20:38,970 --> 00:20:41,009
un hashMap que implica

478
00:20:41,009 --> 00:20:43,029
a su vez que las claves van en un hashSet

479
00:20:43,029 --> 00:20:44,490
sin preocuparme de nada más

480
00:20:44,490 --> 00:20:47,589
porque string ya tiene una función de hash

481
00:20:47,589 --> 00:20:49,869
para generar esos códigos de hash

482
00:20:49,869 --> 00:20:51,970
que le van a permitir internamente a java

483
00:20:51,970 --> 00:20:53,950
trabajar rápidamente con el conjunto

484
00:20:53,950 --> 00:20:55,529
que repito

485
00:20:55,529 --> 00:20:56,990
efectos de programar nosotros

486
00:20:56,990 --> 00:20:58,589
es que eso no es transparente

487
00:20:58,589 --> 00:21:00,250
ni vemos como genera los hash

488
00:21:00,250 --> 00:21:01,390
como los usa para localizar

489
00:21:01,390 --> 00:21:03,450
nosotros metemos en la colección

490
00:21:03,450 --> 00:21:05,049
eliminamos y ya está

491
00:21:05,049 --> 00:21:06,650
pero

492
00:21:06,650 --> 00:21:09,029
si que tenemos que saber

493
00:21:09,029 --> 00:21:10,509
que si una clave

494
00:21:10,509 --> 00:21:12,890
es de una clase concreta

495
00:21:12,890 --> 00:21:15,150
esa clase tiene que tener una implementación

496
00:21:15,150 --> 00:21:17,069
de hashcode lo más

497
00:21:17,069 --> 00:21:17,950
eficiente posible

498
00:21:17,950 --> 00:21:20,369
string ya la tiene

499
00:21:20,369 --> 00:21:22,930
¿vale? pero si yo pusiera como clave

500
00:21:22,930 --> 00:21:24,569
una clase mía

501
00:21:24,569 --> 00:21:26,789
cualquiera, una clase que yo

502
00:21:26,789 --> 00:21:27,970
me he inventado clave

503
00:21:27,970 --> 00:21:31,470
pues tengo que hacer una implementación

504
00:21:31,470 --> 00:21:32,809
de hashcode

505
00:21:32,809 --> 00:21:34,089
ahí

506
00:21:34,089 --> 00:21:35,690
la tengo que hacer

507
00:21:35,690 --> 00:21:38,509
que la hicimos el año pasado

508
00:21:38,509 --> 00:21:40,710
pues la que te generaba el eclipse es suficiente

509
00:21:40,710 --> 00:21:42,650
porque tampoco teníamos conocimientos

510
00:21:42,650 --> 00:21:44,690
como para generar una óptima en función de

511
00:21:44,690 --> 00:21:46,750
la estadística de mis datos, lo ideal

512
00:21:46,750 --> 00:21:48,869
es que en función de la estadística

513
00:21:48,869 --> 00:21:49,950
del uso de mis datos

514
00:21:49,950 --> 00:21:52,529
yo generara una óptima, pero bueno

515
00:21:52,529 --> 00:21:54,029
eso ya es pasarse

516
00:21:54,029 --> 00:21:56,509
nadie hace eso, ¿vale?

517
00:21:56,529 --> 00:21:58,710
con la implementación de Haskell de estándar

518
00:21:58,710 --> 00:22:00,710
que te ofrece Eclipse ya es un compromiso

519
00:22:00,710 --> 00:22:01,809
más o menos

520
00:22:01,809 --> 00:22:04,109
porque si no implementamos esto

521
00:22:04,109 --> 00:22:08,190
¿qué versión de Haskell usa?

522
00:22:08,990 --> 00:22:10,390
la de Object, porque ya sabéis

523
00:22:10,390 --> 00:22:12,470
que todas las clases eran de Object, todas

524
00:22:12,470 --> 00:22:14,710
entonces si yo no sobrescribo

525
00:22:14,710 --> 00:22:16,910
hashCode va a utilizar la implementación

526
00:22:16,910 --> 00:22:19,269
de object y la implementación

527
00:22:19,269 --> 00:22:19,890
de object

528
00:22:19,890 --> 00:22:23,049
convierte el set en una lista

529
00:22:23,049 --> 00:22:24,990
normal y corriente porque todos los elementos

530
00:22:24,990 --> 00:22:27,170
devuelven el mismo hashCode, todos, con lo cual

531
00:22:27,170 --> 00:22:28,809
¿de qué me serviría?

532
00:22:29,309 --> 00:22:31,190
usar un hashSet si no sobrescribo

533
00:22:31,190 --> 00:22:33,130
la implementación de object

534
00:22:33,130 --> 00:22:35,069
de hashCode es que no

535
00:22:35,069 --> 00:22:37,150
hace un código de hash distinto para cada elemento

536
00:22:37,150 --> 00:22:39,069
con lo cual es como si estuvieran todos en una lista

537
00:22:39,069 --> 00:22:41,069
bueno, todo esto es más o menos

538
00:22:41,069 --> 00:22:43,089
del año pasado, lo repaso un poco por encima

539
00:22:43,089 --> 00:22:44,470
pero lo que importa ahora

540
00:22:44,470 --> 00:22:47,009
es que a la hora

541
00:22:47,009 --> 00:22:49,309
de usarlo, la clase

542
00:22:49,309 --> 00:22:51,029
que pongamos aquí, si es

543
00:22:51,029 --> 00:22:53,029
que es un HashMap, tiene que tener

544
00:22:53,029 --> 00:22:55,009
una implementación de hash, este

545
00:22:55,009 --> 00:22:57,009
bien la tiene, porque ya está hecha

546
00:22:57,009 --> 00:22:58,670
esa clase y la tiene, ¿vale?

547
00:23:00,029 --> 00:23:00,509
Bueno

548
00:23:00,509 --> 00:23:03,009
y si poníamos el trimap

549
00:23:03,009 --> 00:23:07,279
esto se guardaba en un

550
00:23:07,279 --> 00:23:10,670
triset, eso tenía una

551
00:23:10,670 --> 00:23:12,630
implicación, en un triset

552
00:23:12,630 --> 00:23:16,750
implica que internamente lo guarda en un árbol binario

553
00:23:16,750 --> 00:23:19,910
donde es muy eficiente el árbol binario

554
00:23:19,910 --> 00:23:24,130
porque se coloca según un criterio de orden

555
00:23:24,130 --> 00:23:28,289
si es mayor hacia acá, este es mayor que este

556
00:23:28,289 --> 00:23:31,670
este es menor que este, este es menor que este

557
00:23:31,670 --> 00:23:33,750
este es mayor que este, este es menor que este

558
00:23:33,750 --> 00:23:36,029
entonces al guardar según un criterio de orden

559
00:23:36,029 --> 00:23:40,930
a la hora de localizar, localiza muy rápido

560
00:23:40,930 --> 00:23:43,210
porque se va quitando punto a la mitad de los elementos

561
00:23:43,210 --> 00:23:45,190
de golpe, se los va quitando entonces localiza

562
00:23:45,190 --> 00:23:46,950
rápido, por eso el trimap es eficiente

563
00:23:46,950 --> 00:23:49,190
¿vale? pero a la hora

564
00:23:49,190 --> 00:23:50,910
ya nosotros de escribir el código

565
00:23:50,910 --> 00:23:53,049
¿qué implicación

566
00:23:53,049 --> 00:23:55,410
tenía si yo aquí

567
00:23:55,410 --> 00:23:57,390
decido un trimap

568
00:23:57,390 --> 00:23:59,269
en vez de un

569
00:23:59,269 --> 00:24:01,230
hasmap, decido un trimap

570
00:24:01,230 --> 00:24:03,349
ahora ya a la hora de escribir código

571
00:24:03,349 --> 00:24:05,430
¿qué implicación tenía? ¿alguien la recuerda?

572
00:24:05,869 --> 00:24:06,710
seguro que sí

573
00:24:06,710 --> 00:24:11,240
claro

574
00:24:11,240 --> 00:24:12,299
que esta clase

575
00:24:12,299 --> 00:24:14,680
tenía que tener un criterio de orden.

576
00:24:15,500 --> 00:24:16,880
¿Y cómo hacemos que una clase

577
00:24:16,880 --> 00:24:18,140
tenga un criterio de orden?

578
00:24:19,160 --> 00:24:20,279
Implementando comparable

579
00:24:20,279 --> 00:24:23,299
e implementar comparable

580
00:24:23,299 --> 00:24:25,539
implica implementar el método compare-tú.

581
00:24:25,880 --> 00:24:27,019
Entonces le damos un criterio de orden.

582
00:24:28,099 --> 00:24:29,000
Que no podemos...

583
00:24:29,000 --> 00:24:30,279
String ya implementa comparable,

584
00:24:30,420 --> 00:24:32,140
con lo cual podríamos usar 3Maps sin problema.

585
00:24:32,720 --> 00:24:34,500
Que tenemos aquí una clase

586
00:24:34,500 --> 00:24:37,319
que no implementa comparable,

587
00:24:37,640 --> 00:24:39,119
pero no la hemos hecho nosotros.

588
00:24:39,839 --> 00:24:41,339
Ni tenemos acceso a ella

589
00:24:41,339 --> 00:24:43,700
y no podemos tocarla, con lo cual

590
00:24:43,700 --> 00:24:45,519
yo no puedo de repente coger su código

591
00:24:45,519 --> 00:24:47,460
fuente y decir, voy a añadirle que

592
00:24:47,460 --> 00:24:49,460
implemente comparable y por el método que me dé la gana

593
00:24:49,460 --> 00:24:50,980
no puedo, esa clase no la he hecho yo

594
00:24:50,980 --> 00:24:53,019
como ocurre la mayoría de las veces y no puedo

595
00:24:53,019 --> 00:24:55,700
eso implica que es imposible

596
00:24:55,700 --> 00:24:56,799
usar un trimap

597
00:24:56,799 --> 00:25:03,700
vale, pero bueno

598
00:25:03,700 --> 00:25:05,660
implica que entonces aquí tienes que hacer una instancia

599
00:25:05,660 --> 00:25:07,380
de la heredada, vale

600
00:25:07,380 --> 00:25:09,960
sí, pero cambias el modelo de datos

601
00:25:09,960 --> 00:25:11,900
un poquito, pero bueno, sería una solución

602
00:25:11,900 --> 00:25:13,400
pero cambiándolo, hay una más fácil

603
00:25:13,400 --> 00:25:14,720
que es

604
00:25:14,720 --> 00:25:18,079
pasas aquí en el constructor

605
00:25:18,079 --> 00:25:21,859
un objeto comparator

606
00:25:21,859 --> 00:25:23,819
¿os acordáis?

607
00:25:24,500 --> 00:25:27,019
entonces el comparator es un objeto

608
00:25:27,019 --> 00:25:29,859
que es un criterio de orden concreto

609
00:25:29,859 --> 00:25:31,839
para el uso del map

610
00:25:31,839 --> 00:25:33,859
no es que ese criterio de orden

611
00:25:33,859 --> 00:25:35,900
simplemente para siempre en esta clase

612
00:25:35,900 --> 00:25:38,859
no, solamente el map lo va a usar

613
00:25:38,859 --> 00:25:40,519
él solamente, su trimap

614
00:25:40,519 --> 00:25:43,539
lo va a usar cuando necesite meter las cosas

615
00:25:43,539 --> 00:25:45,819
Va a usar ese criterio de orden que yo ponga aquí

616
00:25:45,819 --> 00:25:47,640
Y esta clase se queda inalterada

617
00:25:47,640 --> 00:25:48,859
Ni comparable ni nada

618
00:25:48,859 --> 00:25:50,539
¿Vale?

619
00:25:51,220 --> 00:25:52,339
Bueno, pues aquí

620
00:25:52,339 --> 00:25:54,460
No nos complicamos la vida

621
00:25:54,460 --> 00:25:56,799
En realidad es que da igual cual pusiéramos

622
00:25:56,799 --> 00:25:58,759
Como string, implementa comparable

623
00:25:58,759 --> 00:26:00,700
Implementa hashcode

624
00:26:00,700 --> 00:26:02,539
Es que da igual el que eligiera

625
00:26:02,539 --> 00:26:04,740
Pero

626
00:26:04,740 --> 00:26:07,579
Si hay una diferencia

627
00:26:07,579 --> 00:26:09,119
Con esto ya paramos un segundito

628
00:26:09,119 --> 00:26:11,539
De implementar hashback a implementar

629
00:26:11,539 --> 00:26:13,660
trimap, hay una diferencia

630
00:26:13,660 --> 00:26:15,519
visible que yo podría observar luego

631
00:26:15,519 --> 00:26:17,480
trabajando. ¿La recordáis?

632
00:26:17,960 --> 00:26:21,880
Que cuando yo itere,

633
00:26:22,480 --> 00:26:23,759
que puede ser que yo tenga que

634
00:26:23,759 --> 00:26:25,819
iterar para ver todos los alumnos,

635
00:26:25,980 --> 00:26:27,779
para ver todo. Pues cuando

636
00:26:27,779 --> 00:26:30,099
yo itere, cuando itero en un triset,

637
00:26:31,720 --> 00:26:33,759
la iteración se va a hacer

638
00:26:33,759 --> 00:26:34,759
en el orden

639
00:26:34,759 --> 00:26:36,980
del criterio de orden.

640
00:26:37,559 --> 00:26:39,539
Entonces, la iteración me va a sacar

641
00:26:39,539 --> 00:26:41,339
los elementos siempre ordenaditos.

642
00:26:41,799 --> 00:26:43,500
La iteración en un haset

643
00:26:43,500 --> 00:26:46,380
no me lo saca siguiendo ningún criterio

644
00:26:46,380 --> 00:26:47,720
de orden que yo haya definido

645
00:26:47,720 --> 00:26:50,000
entonces, si mi aplicación

646
00:26:50,000 --> 00:26:52,299
va a hacer iteraciones para mostrar listados

647
00:26:52,299 --> 00:26:54,599
y lo que sea, pues estás cómoda

648
00:26:54,599 --> 00:26:56,440
porque esa iteración

649
00:26:56,440 --> 00:26:58,180
ya me va a dar los elementos ordenados

650
00:26:58,180 --> 00:27:00,259
aquí quiero yo ordenar

651
00:27:00,259 --> 00:27:02,240
los alumnos por NIF, si yo tuviera una

652
00:27:02,240 --> 00:27:03,960
funcionalidad que fuera

653
00:27:03,960 --> 00:27:06,119
dame la lista de alumnos ordenados

654
00:27:06,119 --> 00:27:08,079
por NIF, pues hombre

655
00:27:08,079 --> 00:27:09,880
ahí podría tener sentido elegir un trimap

656
00:27:09,880 --> 00:27:11,940
porque cuando itere por el map van a salir

657
00:27:11,940 --> 00:27:13,680
todos ordenados por la CLAR

658
00:27:13,680 --> 00:27:15,980
que es el... si me da igual

659
00:27:15,980 --> 00:27:17,960
pues entonces un HashMap

660
00:27:17,960 --> 00:27:19,359
que siempre es más

661
00:27:19,359 --> 00:27:22,099
más comodillo y esas cosas

662
00:27:22,099 --> 00:27:23,839
vale, vamos a parar

663
00:27:23,839 --> 00:27:24,680
un segundinito