1
00:00:00,050 --> 00:00:07,809
vale, vamos a

2
00:00:07,809 --> 00:00:09,410
ejecutar este

3
00:00:09,410 --> 00:00:11,550
main de aquí, que lo único que hace es

4
00:00:11,550 --> 00:00:13,509
inserta dos alumnos en nuestra

5
00:00:13,509 --> 00:00:15,810
lista de alumnos y luego como la aplicación

6
00:00:15,810 --> 00:00:17,410
ya se va, pues los deja

7
00:00:17,410 --> 00:00:19,109
guardados para la próxima vez

8
00:00:19,109 --> 00:00:21,350
pues nada, vamos a ejecutar

9
00:00:21,350 --> 00:00:25,859
esto y no

10
00:00:25,859 --> 00:00:26,980
no ha pasado

11
00:00:26,980 --> 00:00:29,920
pues nada, cuando nos salen cosas

12
00:00:29,920 --> 00:00:31,780
rojas, fundamental es

13
00:00:31,780 --> 00:00:36,000
ver qué tipo de excepción nos da, qué información nos da

14
00:00:36,000 --> 00:00:38,859
y en qué momento ha ocurrido

15
00:00:38,859 --> 00:00:45,740
sí, pero si no se la doy es que es la ruta por defecto, que es la raíz

16
00:00:45,740 --> 00:00:48,060
del proyecto, ¿vale? o sea yo

17
00:00:48,060 --> 00:00:52,979
tengo dos opciones, dar la ruta absoluta partiendo desde mi unidad de disco

18
00:00:52,979 --> 00:01:01,479
en un archivo serializado

19
00:01:01,479 --> 00:01:05,340
de objetos, no hay tipo, claro, entonces yo tengo la opción

20
00:01:05,340 --> 00:01:07,200
de darle una ruta absoluta

21
00:01:07,200 --> 00:01:09,299
y se identifica que es absoluta

22
00:01:09,299 --> 00:01:11,379
porque partes directamente

23
00:01:11,379 --> 00:01:12,579
de una unidad de disco

24
00:01:12,579 --> 00:01:15,099
o si fuera en linux

25
00:01:15,099 --> 00:01:17,379
porque partes directamente de la barra

26
00:01:18,140 --> 00:01:21,459
o puedes no darle una ruta absoluta

27
00:01:21,459 --> 00:01:23,700
como esta en la que no partes de una unidad de disco

28
00:01:23,700 --> 00:01:25,260
si no partes de una unidad de disco

29
00:01:25,260 --> 00:01:27,340
entonces él concatena esto

30
00:01:27,340 --> 00:01:29,340
a la ruta por defecto

31
00:01:29,340 --> 00:01:30,459
que es la raíz del proyecto

32
00:01:30,459 --> 00:01:33,299
entonces como yo no le estoy dando una ruta absoluta

33
00:01:33,299 --> 00:01:35,379
porque no tengo una unidad de disco de partida

34
00:01:35,379 --> 00:01:38,159
él concatena eso a la raíz del proyecto

35
00:01:38,159 --> 00:01:40,799
con lo cual alumnos me lo va a poner en la raíz

36
00:01:40,799 --> 00:01:44,079
que yo le pongo esto

37
00:01:44,079 --> 00:01:49,700
pues me pondría dentro de alumnos

38
00:01:49,700 --> 00:01:51,439
perdón, en la raíz del proyecto

39
00:01:51,439 --> 00:01:54,219
buscaría la subcarpeta SRC

40
00:01:54,219 --> 00:01:57,219
y en esa subcarpeta de la raíz del proyecto

41
00:01:57,219 --> 00:01:58,359
en este fichero

42
00:01:58,359 --> 00:02:01,819
es decir, lo que yo le ponga aquí

43
00:02:01,819 --> 00:02:04,099
lo concatena con

44
00:02:04,099 --> 00:02:06,140
la carpeta raíz del proyecto

45
00:02:06,140 --> 00:02:08,259
a menos que yo le esté dando una unidad de disco

46
00:02:08,259 --> 00:02:09,800
entonces ya es absoluta y desde el disco

47
00:02:09,800 --> 00:02:12,419
¿vale? en este caso

48
00:02:12,419 --> 00:02:16,060
perdón

49
00:02:16,060 --> 00:02:22,639
a ver

50
00:02:22,639 --> 00:02:24,300
con la unidad de disco

51
00:02:24,300 --> 00:02:26,219
más todas las carpetas que van

52
00:02:26,219 --> 00:02:27,879
no, con la unidad de disco no, o sea no

53
00:02:27,879 --> 00:02:29,500
porque no es esto

54
00:02:29,500 --> 00:02:32,780
no concatena con eso, concatena con eso

55
00:02:32,780 --> 00:02:34,639
más users alumno de eso

56
00:02:34,639 --> 00:02:36,460
bla bla bla hasta que llegue a mi proyecto

57
00:02:36,460 --> 00:02:38,419
cada ordenador la que tenga, da igual

58
00:02:38,419 --> 00:02:40,639
el que tenga, por eso es relativa

59
00:02:40,639 --> 00:02:41,960
porque este mismo

60
00:02:41,960 --> 00:02:43,759
este mismo

61
00:02:43,759 --> 00:02:46,259
proyecto en vuestro ordenador

62
00:02:46,259 --> 00:02:48,620
funciona, pero la ruta que va adelante

63
00:02:48,620 --> 00:02:50,620
no tiene nada que ver la mía con la tuya

64
00:02:50,620 --> 00:02:52,719
y sigue funcionando, sin embargo

65
00:02:52,719 --> 00:02:54,219
si yo pongo una ruta absoluta

66
00:02:54,219 --> 00:02:59,169
y yo digo, no, no te la voy a dar así

67
00:02:59,169 --> 00:03:01,129
te la voy a dar, espera, vamos a

68
00:03:01,129 --> 00:03:02,610
poner aquí, vámonos a

69
00:03:02,610 --> 00:03:04,629
mi proyecto que es este

70
00:03:04,629 --> 00:03:10,919
ejemplo, alumnos

71
00:03:10,919 --> 00:03:12,099
Me voy a poner aquí

72
00:03:12,099 --> 00:03:16,810
Control-C

73
00:03:16,810 --> 00:03:17,469
Vale

74
00:03:17,469 --> 00:03:23,159
Yo tengo

75
00:03:23,159 --> 00:03:24,879
Dos maneras de hacer lo mismo

76
00:03:24,879 --> 00:03:26,039
En este caso

77
00:03:26,039 --> 00:03:27,860
Uy, espérate

78
00:03:27,860 --> 00:03:32,009
Control-C

79
00:03:32,009 --> 00:03:36,270
Ya, pero es que hay veces que

80
00:03:36,270 --> 00:03:37,629
A lo mejor hay gente que no lo tiene claro

81
00:03:37,629 --> 00:03:39,090
Y es que esto hay veces que

82
00:03:39,090 --> 00:03:50,229
Ejemplo

83
00:03:50,229 --> 00:03:51,189
Alumnos

84
00:03:51,189 --> 00:03:52,669
Alumnos

85
00:03:52,669 --> 00:04:03,280
Es que muchas veces esto es lo que hace

86
00:04:03,280 --> 00:04:04,280
de una aplicación este bien hecha.

87
00:04:04,699 --> 00:04:07,419
Vale. Entonces, lo de arriba

88
00:04:07,419 --> 00:04:08,740
y lo de abajo es lo mismo.

89
00:04:09,379 --> 00:04:10,719
Me da igual esta sentencia que esta.

90
00:04:11,139 --> 00:04:13,039
Me da igual. Estoy haciendo lo mismo.

91
00:04:13,400 --> 00:04:15,020
Esta ruta y esta ruta son

92
00:04:15,020 --> 00:04:16,980
idénticas. Son la misma.

93
00:04:17,620 --> 00:04:18,240
Está claro, ¿no?

94
00:04:19,139 --> 00:04:19,959
Son la misma.

95
00:04:20,959 --> 00:04:23,120
¿Cuál es la diferencia? Que ahora este proyecto

96
00:04:23,120 --> 00:04:24,079
se va a vuestro ordenador.

97
00:04:25,920 --> 00:04:27,019
Con esta opción

98
00:04:27,019 --> 00:04:29,480
va a seguir funcionando sin ningún problema

99
00:04:29,480 --> 00:04:30,980
y con la de abajo no

100
00:04:30,980 --> 00:04:33,300
porque puede que vosotros

101
00:04:33,300 --> 00:04:35,120
la ruta hasta la raíz de vuestro proyecto

102
00:04:35,120 --> 00:04:36,439
no sea esa, sea otra

103
00:04:36,439 --> 00:04:39,819
pero sin embargo, si yo se la paso así como relativa

104
00:04:39,819 --> 00:04:41,379
él va a coger la que

105
00:04:41,379 --> 00:04:42,879
en vuestro ordenador

106
00:04:42,879 --> 00:04:44,699
lleve a la raíz del proyecto

107
00:04:44,699 --> 00:04:47,439
en mi ordenador a la raíz del proyecto

108
00:04:47,439 --> 00:04:49,540
lleva esta, pero si yo se la casco

109
00:04:49,540 --> 00:04:51,420
aquí, va a llevar esa

110
00:04:51,420 --> 00:04:53,560
a misa, en este ordenador, en el vuestro, en cualquiera

111
00:04:53,560 --> 00:04:55,459
si yo se la casco de esta

112
00:04:55,459 --> 00:04:57,560
manera, va a ser capaz de coger

113
00:04:57,560 --> 00:04:58,860
la local de cada equipo

114
00:04:58,860 --> 00:05:01,259
por eso esta es relativa y esta es absoluta

115
00:05:01,259 --> 00:05:03,060
porque esta cambia dependiendo del equipo

116
00:05:03,060 --> 00:05:04,379
del que se ejecute, esta cambia

117
00:05:04,379 --> 00:05:06,860
esta no cambia, esta me da igual

118
00:05:06,860 --> 00:05:08,980
donde la ejecute, esa va a tomar esa

119
00:05:08,980 --> 00:05:11,100
con lo cual en el mío no fallará, en el vuestro fallará

120
00:05:11,100 --> 00:05:12,660
por eso siempre

121
00:05:12,660 --> 00:05:13,779
hay que

122
00:05:13,779 --> 00:05:16,759
trabajar con rutas absolutas porque si no

123
00:05:16,759 --> 00:05:18,720
en el ordenador solo tienes la garantía

124
00:05:18,720 --> 00:05:20,779
perdón, la aplicación solo tienes la garantía de que te funcione

125
00:05:20,779 --> 00:05:22,860
en local, en el tuyo

126
00:05:22,860 --> 00:05:24,759
si yo lo despliego en el Dell no me va a funcionar

127
00:05:25,560 --> 00:05:26,660
pero esta versión

128
00:05:26,660 --> 00:05:28,100
sí, ¿vale? entonces

129
00:05:28,100 --> 00:05:30,720
esta y esta en mi ordenador

130
00:05:30,720 --> 00:05:32,579
hacen lo mismo, pero en el vuestro

131
00:05:32,579 --> 00:05:34,600
no, en el vuestro esta funciona y esta

132
00:05:34,600 --> 00:05:38,660
no, vale, pues entonces

133
00:05:38,660 --> 00:05:46,459
bueno, pues

134
00:05:46,459 --> 00:05:48,079
entonces estábamos con que me ha dado un error

135
00:05:48,079 --> 00:05:49,800
que tenemos que ver, que error es

136
00:05:49,800 --> 00:05:50,740
que me dice

137
00:05:50,740 --> 00:05:53,399
pues me dice

138
00:05:53,399 --> 00:05:55,800
oye, alumno

139
00:05:55,800 --> 00:05:57,279
no es serializable

140
00:05:57,279 --> 00:06:00,319
vale, claro, efectivamente

141
00:06:00,319 --> 00:06:02,079
porque hay que darle

142
00:06:02,079 --> 00:06:04,040
ah, este es un error, silencio

143
00:06:04,040 --> 00:06:05,579
que se olvida mucho

144
00:06:05,579 --> 00:06:08,100
pues conviene que identifiquéis esta excepción

145
00:06:08,100 --> 00:06:10,199
porque es un error que se olvida mucho

146
00:06:10,199 --> 00:06:11,199
entonces identificarla

147
00:06:11,199 --> 00:06:12,439
¿qué significa esto?

148
00:06:12,519 --> 00:06:13,660
que a la entidad alumno

149
00:06:13,660 --> 00:06:16,360
no se le ha dado el comportamiento

150
00:06:16,360 --> 00:06:17,959
de que sea serializable

151
00:06:17,959 --> 00:06:20,079
no se le ha dado ese comportamiento

152
00:06:20,079 --> 00:06:22,720
y darle un comportamiento a una entidad

153
00:06:22,720 --> 00:06:23,779
¿cómo se consigue?

154
00:06:24,459 --> 00:06:26,759
haciendo la que implemente una interfaz

155
00:06:26,759 --> 00:06:27,560
¿verdad?

156
00:06:27,680 --> 00:06:28,680
para eso son las interfaces

157
00:06:28,680 --> 00:06:30,420
las interfaces fijan

158
00:06:30,420 --> 00:06:32,160
un patrón de comportamiento

159
00:06:32,160 --> 00:06:33,839
a través de sus métodos

160
00:06:33,839 --> 00:06:35,560
patatín, patatín, patatán

161
00:06:35,560 --> 00:06:37,480
el que implementa esa interfaz

162
00:06:37,480 --> 00:06:38,959
automáticamente

163
00:06:38,959 --> 00:06:41,839
adquiere esos métodos

164
00:06:41,839 --> 00:06:43,660
y por tanto puede comportarse ya

165
00:06:43,660 --> 00:06:45,680
de esa manera, los puede sobrescribir

166
00:06:45,680 --> 00:06:47,199
o no, eso ya es otra cosa

167
00:06:47,199 --> 00:06:49,699
bueno, pues entonces, nuestro error

168
00:06:49,699 --> 00:06:51,720
aquí es que

169
00:06:51,720 --> 00:06:53,560
alumno

170
00:06:54,160 --> 00:06:54,839
¿vale?

171
00:06:57,209 --> 00:06:58,949
no implementaba serializable

172
00:06:58,949 --> 00:07:00,949
pues no pasa nada

173
00:07:00,949 --> 00:07:02,990
vamos a hacerle que implemente

174
00:07:02,990 --> 00:07:05,129
la interfaz serializable

175
00:07:07,129 --> 00:07:10,970
lo importáis del paquete correspondiente

176
00:07:10,970 --> 00:07:11,730
que es java.io

177
00:07:11,730 --> 00:07:12,870
y ya está

178
00:07:12,870 --> 00:07:15,490
y ahora ya esta clase ha adquirido

179
00:07:15,490 --> 00:07:17,529
el comportamiento que le da esta interfaz

180
00:07:17,529 --> 00:07:19,750
esta interfaz tiene métodos dentro

181
00:07:19,750 --> 00:07:21,269
con códigos por defecto

182
00:07:21,269 --> 00:07:22,589
con codificación por defecto

183
00:07:22,589 --> 00:07:23,490
ya la ha adquirido

184
00:07:23,490 --> 00:07:26,490
entonces si queremos serializar

185
00:07:26,490 --> 00:07:28,350
objetos de una clase

186
00:07:28,350 --> 00:07:30,750
esa clase tiene que implementar

187
00:07:30,750 --> 00:07:32,009
la interfaz serializable

188
00:07:32,009 --> 00:07:35,129
vale, y no solo esa clase

189
00:07:35,129 --> 00:07:36,610
porque

190
00:07:36,610 --> 00:07:38,949
si esta clase tiene dentro

191
00:07:38,949 --> 00:07:41,050
propiedades de otras clases

192
00:07:41,050 --> 00:07:42,910
como esas propiedades

193
00:07:42,910 --> 00:07:44,509
también se van a tener que visualizar por dentro

194
00:07:44,509 --> 00:07:46,569
esas clases también lo tendrán que ser

195
00:07:46,569 --> 00:07:47,930
pero en este caso

196
00:07:47,930 --> 00:07:51,009
solo tengo string y string

197
00:07:51,009 --> 00:07:52,550
y string

198
00:07:52,550 --> 00:07:54,910
es que ya lo son, si yo me meto en la

199
00:07:54,910 --> 00:07:57,050
declaración de string, ya lo es

200
00:07:57,050 --> 00:07:58,470
ya lo tiene ya puesta

201
00:07:58,470 --> 00:08:00,250
¿vale?

202
00:08:01,029 --> 00:08:03,310
pero si yo aquí en alumno

203
00:08:03,310 --> 00:08:05,310
pues resulta que utilizo una clase

204
00:08:05,310 --> 00:08:06,269
matrícula

205
00:08:06,269 --> 00:08:09,250
en lugar de string

206
00:08:09,250 --> 00:08:10,730
porque tengo una clase matrícula

207
00:08:10,730 --> 00:08:12,509
con las propiedades de la matrícula

208
00:08:12,509 --> 00:08:14,689
pues entonces esta clase matrícula

209
00:08:14,689 --> 00:08:16,810
también tendría que implementar serializable

210
00:08:16,810 --> 00:08:19,410
porque dentro de alumno hay matrículas

211
00:08:19,410 --> 00:08:20,769
y se tiene que serializar todo

212
00:08:20,769 --> 00:08:23,290
el alumno con todos los objetos que hay dentro

213
00:08:23,290 --> 00:08:25,389
pero en este caso

214
00:08:25,389 --> 00:08:27,370
callaos

215
00:08:27,370 --> 00:08:29,470
pero en este caso

216
00:08:29,470 --> 00:08:30,350
string ya lo es

217
00:08:30,350 --> 00:08:32,590
y no tengo otro tipo de dato que no sea

218
00:08:32,590 --> 00:08:33,590
o primitivo

219
00:08:33,590 --> 00:08:36,330
que el primitivo es que se lleva tal cual

220
00:08:36,330 --> 00:08:37,690
no hay que serializar, se lleva tal cual

221
00:08:37,690 --> 00:08:39,549
no tengo otro tipo de dato que no sea primitivo

222
00:08:39,549 --> 00:08:42,230
o serializable de por sí

223
00:08:42,230 --> 00:08:43,029
como string

224
00:08:43,029 --> 00:08:46,389
bueno pues con estos en principio ya hemos dado

225
00:08:46,389 --> 00:08:47,990
todo el comportamiento que hace falta

226
00:08:47,990 --> 00:08:50,570
si lo volvemos a ejecutar

227
00:08:50,570 --> 00:08:54,269
ahora ya error no ha dado

228
00:08:54,269 --> 00:08:58,269
y vamos a ver si ha aparecido el fichero

229
00:08:58,269 --> 00:09:02,220
vale, ha aparecido aquí un fichero

230
00:09:02,220 --> 00:09:02,779
de alumnos

231
00:09:02,779 --> 00:09:06,179
obviamente si abrimos este archivo

232
00:09:06,179 --> 00:09:08,799
no entendemos absolutamente nada

233
00:09:08,799 --> 00:09:10,299
porque ¿qué hacemos al abrirlo?

234
00:09:11,019 --> 00:09:11,919
estamos haciendo

235
00:09:11,919 --> 00:09:15,019
que un editor de texto lo interprete

236
00:09:15,019 --> 00:09:16,480
¿y el editor de texto qué hace?

237
00:09:16,600 --> 00:09:18,980
pues el editor de texto va cogiendo bits de 8 en 8

238
00:09:18,980 --> 00:09:20,480
va a la tabla ASCII

239
00:09:20,480 --> 00:09:22,240
lo convierte al carácter y te lo planta

240
00:09:22,240 --> 00:09:23,360
eso es lo que hace el editor de texto

241
00:09:23,360 --> 00:09:25,820
le hemos dado un fichero con un montón de bits

242
00:09:25,820 --> 00:09:27,960
dice vale, muy bien, yo soy un editor de texto

243
00:09:27,960 --> 00:09:29,039
lo único que yo sé hacer es

244
00:09:29,039 --> 00:09:32,340
te cojo los 8 primeros, tabla ASCII, carácter que toca

245
00:09:32,340 --> 00:09:33,980
te lo planto, te cojo los 8 siguientes

246
00:09:33,980 --> 00:09:35,220
tabla ASCII, carácter que toca

247
00:09:35,220 --> 00:09:37,440
ese fichero no codificaba

248
00:09:37,440 --> 00:09:39,120
ASCII, con lo cual

249
00:09:39,120 --> 00:09:40,840
nos ha sacado cosas

250
00:09:40,840 --> 00:09:43,500
¿vale? algunos caracteres

251
00:09:43,500 --> 00:09:45,700
tienen sentido porque en la serialización

252
00:09:45,700 --> 00:09:47,120
algunas cosas van como char

253
00:09:47,120 --> 00:09:49,879
pero muchas otras no, todos los cuadraditos

254
00:09:49,879 --> 00:09:51,240
se corresponden

255
00:09:51,240 --> 00:09:53,299
a bytes que en la tabla

256
00:09:53,299 --> 00:09:55,679
ASCII no tienen correspondencia, no la tienen, no existen

257
00:09:55,679 --> 00:09:57,340
por eso el leidor

258
00:09:57,340 --> 00:09:58,500
texto pone cuadraditos

259
00:09:58,500 --> 00:10:01,200
luego, este fichero

260
00:10:01,200 --> 00:10:03,200
obviamente no vale para abrirlo con

261
00:10:03,200 --> 00:10:05,259
ninguna aplicación, este fichero está

262
00:10:05,259 --> 00:10:07,200
ahí simplemente para que cuando

263
00:10:07,200 --> 00:10:08,820
mi aplicación Java arranque

264
00:10:08,820 --> 00:10:11,159
otra vez lo deserialice con la clase

265
00:10:11,159 --> 00:10:13,519
correspondiente, con la complementaria

266
00:10:13,519 --> 00:10:15,019
a object output string que es

267
00:10:15,019 --> 00:10:17,259
object input string, es para lo único

268
00:10:17,259 --> 00:10:19,139
que vale este fichero, para ahora

269
00:10:19,139 --> 00:10:21,059
que otra aplicación con object

270
00:10:21,059 --> 00:10:23,159
input string haga la operación inversa

271
00:10:23,159 --> 00:10:25,000
pero no se puede abrir con ningún

272
00:10:25,000 --> 00:10:25,259
otro

273
00:10:25,259 --> 00:10:30,779
aplicación, bueno pues entonces

274
00:10:30,779 --> 00:10:33,840
aquí ahora ya podríamos

275
00:10:33,840 --> 00:10:36,360
en mi clase esta de aquí, operaciones

276
00:10:36,360 --> 00:10:38,159
pues podríamos

277
00:10:38,159 --> 00:10:39,500
hacer un método

278
00:10:39,500 --> 00:10:41,740
para que recuperara

279
00:10:41,740 --> 00:10:44,159
objetos del archivo y los guardara

280
00:10:44,159 --> 00:10:44,399
aquí

281
00:10:44,399 --> 00:10:48,179
y yo ese método le llamo cuando arranca la aplicación

282
00:10:48,179 --> 00:10:50,419
por ejemplo, y así cuando la aplicación

283
00:10:50,419 --> 00:10:52,399
arranca, este list

284
00:10:52,399 --> 00:10:54,059
ya se llena con los objetos

285
00:10:54,059 --> 00:10:55,360
que haya en ese archivo

286
00:10:55,360 --> 00:10:57,379
si es que los hay

287
00:10:57,379 --> 00:11:00,279
pues venga, vamos a hacer

288
00:11:00,279 --> 00:11:01,019
ese método

289
00:11:01,019 --> 00:11:03,379
que sería

290
00:11:03,379 --> 00:11:05,000
en lugar del método guardar datos

291
00:11:05,000 --> 00:11:06,360
pues recuperar datos

292
00:11:06,360 --> 00:11:18,070
y le podemos pasar pues el nombre

293
00:11:18,070 --> 00:11:19,429
del fichero donde

294
00:11:19,429 --> 00:11:21,289
suponemos

295
00:11:21,289 --> 00:11:23,350
que están los alumnos

296
00:11:23,350 --> 00:11:29,820
vale, pues aquí hombre, esto para que fuera más general

297
00:11:29,820 --> 00:11:31,620
podríamos primero mirar a ver

298
00:11:31,620 --> 00:11:32,679
si el archivo existe o no

299
00:11:32,679 --> 00:11:35,379
porque si el archivo no existe

300
00:11:35,379 --> 00:11:37,919
pues entonces no hay alumnos que recuperar

301
00:11:37,919 --> 00:11:39,639
el método ya termina, la lista se habrá

302
00:11:39,639 --> 00:11:41,279
que se quedará vacía como estaba

303
00:11:41,279 --> 00:11:42,340
y ya está

304
00:11:42,340 --> 00:11:44,820
entonces podemos hacerlo primero esto

305
00:11:44,820 --> 00:11:46,340
instanciar un objeto file

306
00:11:46,340 --> 00:11:47,980
asociado

307
00:11:47,980 --> 00:11:51,440
a este nombre

308
00:11:51,440 --> 00:11:58,700
non-fichero

309
00:11:58,700 --> 00:12:10,570
y ahora ya podemos hacer

310
00:12:10,570 --> 00:12:13,129
si resulta que el fichero f no existe

311
00:12:13,129 --> 00:12:14,590
pues no hay nada que hacer

312
00:12:14,590 --> 00:12:16,830
return, no hay nada que recuperar

313
00:12:16,830 --> 00:12:18,710
que se quede la lista como estaba, que era vacía

314
00:12:18,710 --> 00:12:19,490
sin alumnos

315
00:12:19,490 --> 00:12:22,570
esto en función

316
00:12:22,570 --> 00:12:27,779
si es una interfaz gráfica o no lo es

317
00:12:27,779 --> 00:12:29,960
pues se podría avisar, no hay alumnos previos

318
00:12:29,960 --> 00:12:31,500
lo que sea, ya está

319
00:12:31,500 --> 00:12:32,559
si el fichero no existe, return

320
00:12:32,559 --> 00:12:35,700
y ahora ya el fichero existe, pues ahora ya

321
00:12:35,700 --> 00:12:38,039
podemos abrirlo para deserializar

322
00:12:38,039 --> 00:12:40,000
y la clase para deserializar es esta

323
00:12:40,000 --> 00:12:42,759
object

324
00:12:42,759 --> 00:12:45,299
input stream

325
00:12:45,299 --> 00:12:48,559
ya vamos a referencia

326
00:12:48,559 --> 00:12:49,460
como nos dé la gana

327
00:12:49,460 --> 00:12:52,240
y lo mismo que la output

328
00:12:52,240 --> 00:12:59,019
object

329
00:12:59,019 --> 00:13:00,360
input stream está montada

330
00:13:00,360 --> 00:13:02,980
sobre un file input stream

331
00:13:02,980 --> 00:13:05,179
porque object input string

332
00:13:05,179 --> 00:13:06,899
lo que tiene que hacer es

333
00:13:06,899 --> 00:13:09,279
hay de verdad

334
00:13:09,279 --> 00:13:11,220
hay tres bares enfrente

335
00:13:11,220 --> 00:13:12,820
o cuatro, no sé cuántos hay

336
00:13:12,820 --> 00:13:15,559
pues largaos a esos bares

337
00:13:15,559 --> 00:13:17,100
que ahí no van a

338
00:13:17,100 --> 00:13:18,720
no vais a salir el coñazo, bueno, a ver

339
00:13:18,720 --> 00:13:21,240
seguramente también, pero que os aguante

340
00:13:21,240 --> 00:13:22,399
otro, yo no voy a aguantar

341
00:13:22,399 --> 00:13:26,679
entonces esta clase

342
00:13:26,679 --> 00:13:29,080
lo primero que hará será mover los bits

343
00:13:29,080 --> 00:13:31,000
y para mover los bits file input string

344
00:13:31,000 --> 00:13:31,519
no hay otra

345
00:13:31,519 --> 00:13:34,100
y luego ya con esos bits

346
00:13:34,100 --> 00:13:36,179
ahí ya tendrá sus métodos

347
00:13:36,179 --> 00:13:37,919
para deserializarlos, hacer lo que tienen

348
00:13:37,919 --> 00:13:40,320
llevarlos a las propiedades del objeto, hacer todo lo que haga falta

349
00:13:40,320 --> 00:13:42,080
pero hay que

350
00:13:42,080 --> 00:13:44,440
darle el FileInputString sobre el que está montado

351
00:13:44,440 --> 00:13:48,340
pues el FileInputString

352
00:13:48,340 --> 00:13:50,480
sobre el que está montado, pues es un FileInputString

353
00:13:50,480 --> 00:13:52,200
asociado al non-fichero ese

354
00:13:52,200 --> 00:13:56,980
que me han dado, o a F

355
00:13:56,980 --> 00:13:57,559
me da igual

356
00:13:57,559 --> 00:13:59,799
el costo es el mismo

357
00:13:59,799 --> 00:14:02,799
venga, pues nada, tendremos

358
00:14:02,799 --> 00:14:04,399
que importar esto

359
00:14:04,399 --> 00:14:08,100
y esto

360
00:14:08,100 --> 00:14:11,559
y propagar la excepción correspondiente.

361
00:14:15,110 --> 00:14:15,309
¡Hala!

362
00:14:15,730 --> 00:14:18,129
Y ahora, leer es más complicado

363
00:14:18,129 --> 00:14:19,590
que escribir, porque escribir es

364
00:14:19,590 --> 00:14:21,529
escribo y ahí lo mando. Y ya está.

365
00:14:22,090 --> 00:14:24,070
¿La siguiente escritura que haga? Pues se hará justo

366
00:14:24,070 --> 00:14:25,889
debajo. Pero leer,

367
00:14:26,190 --> 00:14:27,889
como no tenemos la información de lo que hay,

368
00:14:28,690 --> 00:14:29,610
tenemos que hacer un bucle,

369
00:14:29,750 --> 00:14:31,769
un bucle que vaya leyendo hasta llegar al final.

370
00:14:32,230 --> 00:14:33,549
No sabemos cuántas lecturas hay que hacer.

371
00:14:33,669 --> 00:14:35,049
5, 20, ni idea.

372
00:14:35,049 --> 00:14:37,350
depende de lo que hay en el archivo

373
00:14:37,350 --> 00:14:40,029
alguna vez

374
00:14:40,029 --> 00:14:42,070
podemos llamar a recuperar datos y a lo mejor hay 30

375
00:14:42,070 --> 00:14:43,750
pues tendremos que darle 30 veces

376
00:14:43,750 --> 00:14:46,230
sin embargo puede ser

377
00:14:46,230 --> 00:14:47,950
que la siguiente vez que lleguemos a recuperar archivo

378
00:14:47,950 --> 00:14:49,909
haya solo 20, pues entonces habrá que hacer 20 veces

379
00:14:49,909 --> 00:14:50,649
entonces será un bucle

380
00:14:50,649 --> 00:14:53,549
que está leyendo mientras

381
00:14:53,549 --> 00:14:55,129
no hayamos llegado al final

382
00:14:55,129 --> 00:14:57,850
y cada lectura es un objeto

383
00:14:57,850 --> 00:14:59,009
cada lectura es un objeto

384
00:14:59,009 --> 00:15:01,629
¿vale? bueno pues aquí

385
00:15:01,629 --> 00:15:03,889
el bucle de fin de archivo no es tan sencillo

386
00:15:03,889 --> 00:15:05,710
como el otro ejemplo que hemos visto

387
00:15:05,710 --> 00:15:07,129
porque leía solamente un int

388
00:15:07,129 --> 00:15:09,870
entonces marcar el fin de archivo era tan sencillo

389
00:15:09,870 --> 00:15:11,870
como decir si ese int es menos uno, llega al final

390
00:15:11,870 --> 00:15:14,110
y si es cualquier otra cosa

391
00:15:14,110 --> 00:15:15,769
no he llegado al final

392
00:15:15,769 --> 00:15:17,830
cojo el menos significativo y listo

393
00:15:17,830 --> 00:15:20,149
aquí la forma más general de plantearlo

394
00:15:20,149 --> 00:15:20,549
es

395
00:15:20,549 --> 00:15:24,129
el acordarse, el identificar

396
00:15:24,129 --> 00:15:25,190
que hay una excepción

397
00:15:25,190 --> 00:15:27,669
que recoge

398
00:15:27,669 --> 00:15:29,090
el hecho de que cuando uno está

399
00:15:29,090 --> 00:15:31,909
leyendo un archivo, llegue al final

400
00:15:31,909 --> 00:15:32,990
esa

401
00:15:32,990 --> 00:15:34,669
excepción

402
00:15:34,669 --> 00:15:36,789
se llama así

403
00:15:36,789 --> 00:15:41,320
no sé si tiene dos Fs o no, vamos a buscarla

404
00:15:41,320 --> 00:15:42,799
aquí, ya que estamos

405
00:15:42,799 --> 00:15:47,460
tan...

406
00:15:47,460 --> 00:15:49,080
es una excepción que ya está hecha

407
00:15:49,080 --> 00:15:51,820
y está incorporada en la librería

408
00:15:51,820 --> 00:15:52,820
de la máquina virtual

409
00:15:52,820 --> 00:15:55,759
está en java.io, que java.io

410
00:15:55,759 --> 00:15:56,960
está aquí

411
00:15:56,960 --> 00:15:59,600
pues en este paquete

412
00:15:59,600 --> 00:16:02,399
hay una excepción

413
00:16:02,399 --> 00:16:03,340
que se llama

414
00:16:03,340 --> 00:16:05,960
EOF exception, el file me lo he sacado de la manga

415
00:16:05,960 --> 00:16:07,820
EOF exception

416
00:16:07,820 --> 00:16:10,320
vale, pues

417
00:16:10,320 --> 00:16:18,480
en off file exception

418
00:16:18,480 --> 00:16:20,820
vale, pues esta excepción es una excepción

419
00:16:20,820 --> 00:16:22,399
que lanza la máquina

420
00:16:22,399 --> 00:16:23,919
la máquina virtual no la lanza

421
00:16:23,919 --> 00:16:26,899
la lanzará cualquiera de las clases

422
00:16:26,899 --> 00:16:28,860
que hacen lectura, input, file, input

423
00:16:28,860 --> 00:16:30,500
string, cualquiera de las que hacen lectura

424
00:16:30,500 --> 00:16:32,539
si fuéramos a mirar en su código

425
00:16:32,539 --> 00:16:34,679
como lo hacen, veríamos que hace un

426
00:16:34,679 --> 00:16:36,320
throw en off file exception cuando

427
00:16:36,320 --> 00:16:38,340
se detecta una situación de

428
00:16:38,340 --> 00:16:40,200
incapacidad del hardware

429
00:16:40,200 --> 00:16:41,460
de seguir leyendo

430
00:16:41,460 --> 00:16:44,279
vale, pues entonces podemos utilizar

431
00:16:44,279 --> 00:16:45,679
esta excepción

432
00:16:45,679 --> 00:16:46,960
para hacer un bucle

433
00:16:46,960 --> 00:16:48,600
con el try-catch

434
00:16:48,600 --> 00:16:51,600
y decir, mientras yo no entre en el catch

435
00:16:51,600 --> 00:16:53,799
es porque tengo algo más que leer

436
00:16:53,799 --> 00:16:55,700
vale, entonces podríamos

437
00:16:55,700 --> 00:16:57,879
hacerlo de esta manera, y tendríamos el bucle de lectura

438
00:16:57,879 --> 00:16:58,919
más genérico que hay

439
00:16:58,919 --> 00:17:01,600
que es el siguiente, esto lo dejamos aquí

440
00:17:01,600 --> 00:17:02,799
aparcadito, que es

441
00:17:02,799 --> 00:17:05,960
vamos a hacer un bucle, vamos a hacer primero un boolean

442
00:17:05,960 --> 00:17:07,859
para indicar yo si he llegado

443
00:17:07,859 --> 00:17:08,700
al final o no

444
00:17:08,700 --> 00:17:10,359
fin archivo

445
00:17:10,359 --> 00:17:13,559
entonces inicialmente no he llegado al final

446
00:17:13,559 --> 00:17:15,359
falso, y ahora me hago

447
00:17:15,359 --> 00:17:15,859
mi bucle

448
00:17:15,859 --> 00:17:19,519
mientras no haya llegado a fin archivo

449
00:17:19,519 --> 00:17:28,069
vale, pues entonces yo tengo

450
00:17:28,069 --> 00:17:28,490
aquí

451
00:17:28,490 --> 00:17:32,210
este boolean que quiero construir

452
00:17:32,210 --> 00:17:34,089
de tal manera que inicialmente es

453
00:17:34,089 --> 00:17:35,210
falso porque no he llegado al final

454
00:17:35,210 --> 00:17:36,890
pero que aquí dentro

455
00:17:36,890 --> 00:17:39,650
se ponga true cuando he llegado al final

456
00:17:39,650 --> 00:17:41,150
eso es lo que yo quiero

457
00:17:41,150 --> 00:17:43,549
que aquí dentro en algún momento se ponga true

458
00:17:43,549 --> 00:17:45,490
vale, ¿qué voy a querer hacer yo aquí dentro?

459
00:17:45,609 --> 00:17:46,789
leer un objeto alumno

460
00:17:46,789 --> 00:17:49,509
¿Vale? Porque los tengo que ir leyendo uno por uno

461
00:17:49,509 --> 00:17:51,710
Igual que los caracteres, los leía de uno en uno

462
00:17:51,710 --> 00:17:52,630
Los bai de uno en uno

463
00:17:52,630 --> 00:17:54,490
Pues vamos a leer un objeto alumno

464
00:17:54,490 --> 00:17:56,809
Alumno a, ¿y cómo lo leemos?

465
00:17:56,930 --> 00:17:59,009
Pues con el object input string que hemos hecho aquí

466
00:17:59,009 --> 00:18:01,690
Con su método

467
00:18:01,690 --> 00:18:02,890
React object

468
00:18:02,890 --> 00:18:08,490
Ala, con este leemos un alumno

469
00:18:08,490 --> 00:18:10,190
Pero este método

470
00:18:10,190 --> 00:18:11,809
Está programado

471
00:18:11,809 --> 00:18:12,950
Está declarado

472
00:18:12,950 --> 00:18:16,509
De tal manera que te lo devuelve como un object

473
00:18:16,509 --> 00:18:17,970
Porque claro, es un método

474
00:18:17,970 --> 00:18:19,910
que te puede leer cualquier tipo de objeto

475
00:18:19,910 --> 00:18:22,230
está programado para que te lo vuelva como un object

476
00:18:22,230 --> 00:18:24,309
aunque él internamente te hace un instance of

477
00:18:24,309 --> 00:18:25,809
para que el casting funcione, etc.

478
00:18:27,049 --> 00:18:28,890
pero entonces para que el compilador

479
00:18:28,890 --> 00:18:29,809
se quede callado

480
00:18:29,809 --> 00:18:31,769
hay que hacer un casting

481
00:18:31,769 --> 00:18:33,210
para que se quede callado

482
00:18:33,210 --> 00:18:35,849
y oye, esto que estás leyendo

483
00:18:35,849 --> 00:18:38,150
hazme casting alumno

484
00:18:38,150 --> 00:18:40,529
y este casting va a funcionar sin problema

485
00:18:40,529 --> 00:18:42,009
en este caso, pero vamos

486
00:18:42,009 --> 00:18:44,369
va a funcionar sin problema en este caso porque nosotros

487
00:18:44,369 --> 00:18:46,329
somos los que hemos generado

488
00:18:46,329 --> 00:18:48,509
este archivo y sabemos que hay objetos

489
00:18:48,509 --> 00:18:50,730
alumno, si nos pudisiéramos

490
00:18:50,730 --> 00:18:52,690
hacer read object de otro objeto

491
00:18:52,690 --> 00:18:54,430
que no tiene alumno, si hiciéramos el casting

492
00:18:54,430 --> 00:18:56,190
alumno, pues petaría

493
00:18:56,190 --> 00:18:58,250
claro, pero nuestra

494
00:18:58,250 --> 00:18:59,490
aplicación está coordinada

495
00:18:59,490 --> 00:19:02,170
el método de guardar está coordinado

496
00:19:02,170 --> 00:19:03,910
con el de recuperar, es una aplicación

497
00:19:03,910 --> 00:19:05,630
obviamente que está coordinada para que funcione

498
00:19:05,630 --> 00:19:07,670
y sabemos que este

499
00:19:07,670 --> 00:19:10,490
flujo está conectado

500
00:19:10,490 --> 00:19:11,869
a un archivo que tiene objetos

501
00:19:11,869 --> 00:19:14,190
alumno, entonces podemos hacer

502
00:19:14,190 --> 00:19:15,309
el casting sin problema

503
00:19:15,309 --> 00:19:17,769
bueno, pues vamos leyendo de uno en uno

504
00:19:17,769 --> 00:19:20,089
y esto

505
00:19:20,089 --> 00:19:21,890
puede lanzar una excepción

506
00:19:21,890 --> 00:19:24,250
que ponemos en el throw para no molestar

507
00:19:24,250 --> 00:19:25,829
y ahora

508
00:19:25,829 --> 00:19:29,650
el fin archivo este

509
00:19:29,650 --> 00:19:30,329
¿cómo cambiará?

510
00:19:31,009 --> 00:19:32,970
en algún momento tendrá que cambiar y ponerse a true

511
00:19:32,970 --> 00:19:34,130
porque hemos llegado al final

512
00:19:34,130 --> 00:19:37,990
claro, pues nosotros queremos ponerlo a true

513
00:19:37,990 --> 00:19:39,849
cuando este read object

514
00:19:39,849 --> 00:19:41,569
saque una excepción de este tipo

515
00:19:41,569 --> 00:19:43,829
cuando este read object

516
00:19:43,829 --> 00:19:45,250
saque una excepción de este tipo

517
00:19:45,250 --> 00:19:47,809
es porque hemos llegado a fin de archivo

518
00:19:47,809 --> 00:19:50,150
pues entonces vamos a capturar

519
00:19:50,150 --> 00:19:51,309
esta sentencia

520
00:19:51,309 --> 00:19:53,769
vamos a capturarla y vamos a decir

521
00:19:53,769 --> 00:19:55,029
oye, tú intenta hacerla

522
00:19:55,029 --> 00:19:58,309
y si resulta que como consecuencia de hacerla

523
00:19:58,309 --> 00:20:01,410
te encuentras esto

524
00:20:01,410 --> 00:20:03,930
que sale una excepción

525
00:20:03,930 --> 00:20:06,150
en off-file exception

526
00:20:06,150 --> 00:20:07,769
pues la capturas

527
00:20:07,769 --> 00:20:10,109
que no es obligatorio capturarla

528
00:20:10,109 --> 00:20:12,190
por eso yo cuando tenía esto sin el try-catch

529
00:20:12,190 --> 00:20:13,630
ahí el compilador estaba tan tranquilo

530
00:20:13,630 --> 00:20:14,490
no es obligatorio

531
00:20:14,490 --> 00:20:17,569
porque esta es run time exception

532
00:20:17,569 --> 00:20:18,569
esta no es exception

533
00:20:18,569 --> 00:20:21,829
pero a mi me interesa capturarla para detectar

534
00:20:21,829 --> 00:20:22,509
cuando ha salido

535
00:20:22,509 --> 00:20:26,109
porque cuando haya salido entonces lo que yo quiero es

536
00:20:26,109 --> 00:20:27,990
fin archivo

537
00:20:27,990 --> 00:20:28,750
igual a true

538
00:20:28,750 --> 00:20:31,509
y la importo

539
00:20:31,509 --> 00:20:33,130
en not file exception dejaba ahí

540
00:20:33,130 --> 00:20:36,640
vale pues ahora ya

541
00:20:36,640 --> 00:20:38,940
capturando esta excepción

542
00:20:38,940 --> 00:20:41,259
que puedo no capturarla

543
00:20:41,259 --> 00:20:42,779
y si no la capturo cuando salga

544
00:20:42,779 --> 00:20:44,319
pues la vas a ir en rojo ahí

545
00:20:44,319 --> 00:20:46,259
capturando esta excepción

546
00:20:46,259 --> 00:20:48,339
cuando el readObject

547
00:20:48,339 --> 00:20:49,859
no haya podido leer

548
00:20:49,859 --> 00:20:51,539
no haya podido porque está al final

549
00:20:51,539 --> 00:20:53,460
entonces saltará esto

550
00:20:53,460 --> 00:20:55,099
y esto se pondrá true

551
00:20:55,099 --> 00:20:57,559
y ahora el while cuando vuelva arriba dirá

552
00:20:57,559 --> 00:20:59,420
uy, condición false

553
00:20:59,420 --> 00:21:01,299
y ya está, y se acabará

554
00:21:01,299 --> 00:21:04,380
entonces este bucle de lectura

555
00:21:04,380 --> 00:21:06,440
es muy genérico, nos permite usar

556
00:21:06,440 --> 00:21:08,279
con el tryCast de excepción

557
00:21:08,279 --> 00:21:10,259
nos permite hacer lecturas

558
00:21:10,259 --> 00:21:12,140
con cualquier método de lectura

559
00:21:12,140 --> 00:21:14,039
de cualquier clase que haga lecturas

560
00:21:14,039 --> 00:21:19,200
y que me devuelvo un en of file

561
00:21:19,200 --> 00:21:20,200
po venga

562
00:21:20,200 --> 00:21:25,029
y ahora ya está

563
00:21:25,029 --> 00:21:26,369
entonces ahora este objeto

564
00:21:26,369 --> 00:21:27,829
este método está leyendo

565
00:21:27,829 --> 00:21:30,230
y ahora que haré yo aquí con cada objeto alumno

566
00:21:30,230 --> 00:21:31,470
meterlo en la lista

567
00:21:31,470 --> 00:21:32,390
eso es lo que yo querré

568
00:21:32,390 --> 00:21:35,029
en mi lista de alumnos

569
00:21:35,029 --> 00:21:36,029
quiero meter ese alumno

570
00:21:36,029 --> 00:21:42,950
vale pues ya tengo mi método

571
00:21:42,950 --> 00:21:45,329
a falta de cerrar

572
00:21:45,329 --> 00:21:48,009
el flujo que acabo de abrir

573
00:21:48,009 --> 00:21:52,380
ya tengo mi método

574
00:21:52,380 --> 00:21:54,980
que está todo el rato

575
00:21:54,980 --> 00:21:58,140
si el archivo no existe, no hace nada

576
00:21:58,140 --> 00:22:00,779
y si existe, se pone

577
00:22:00,779 --> 00:22:03,720
lee un alumno de él, lo manda a la lista

578
00:22:03,720 --> 00:22:06,740
lee otro alumno, lo manda a la lista, así hasta que no haya más alumnos

579
00:22:06,740 --> 00:22:13,849
bueno, pues entonces ahora ya, mi aplicación arranca

580
00:22:13,849 --> 00:22:17,230
lo primero que yo tendría que hacer

581
00:22:17,230 --> 00:22:19,509
ahora cuando mi aplicación arranca en mi main

582
00:22:19,509 --> 00:22:22,390
sería, antes que nada

583
00:22:22,390 --> 00:22:24,730
voy a recuperar los que haya

584
00:22:24,730 --> 00:22:26,950
Para partir con los que dejé guardados

585
00:22:26,950 --> 00:22:27,789
De la última vez

586
00:22:27,789 --> 00:22:37,549
¿Vale? Recuperar alumnos y le doy el nombre

587
00:22:37,549 --> 00:22:38,809
De archivo con el que voy a trabajar

588
00:22:38,809 --> 00:22:39,890
Pues venga, alumnos

589
00:22:39,890 --> 00:22:42,589
En este caso, alumnos

590
00:22:42,589 --> 00:22:44,710
Y esto

591
00:22:44,710 --> 00:22:46,509
Un throws

592
00:22:46,509 --> 00:22:51,359
Vale, vamos a comprobar si funciona

593
00:22:51,359 --> 00:22:52,380
Poniéndole aquí

594
00:22:52,380 --> 00:22:55,059
Se han recuperado no sé cuántos alumnos

595
00:22:55,059 --> 00:22:56,259
Para ver si los ha recuperado

596
00:22:56,259 --> 00:22:59,579
Se han recuperado

597
00:22:59,579 --> 00:23:00,299
Del

598
00:23:00,299 --> 00:23:03,119
Fichero

599
00:23:03,119 --> 00:23:07,099
Pues cuánto se ha recuperado del fichero

600
00:23:07,099 --> 00:23:08,579
Pues se habrán recuperado

601
00:23:08,579 --> 00:23:09,680
Los que haya en

602
00:23:09,680 --> 00:23:12,160
Alumnos.size

603
00:23:12,160 --> 00:23:21,829
No se llama alumnos

604
00:23:21,829 --> 00:23:23,390
Ah, es que no está aquí, está en operaciones

605
00:23:23,390 --> 00:23:23,650
La

606
00:23:23,650 --> 00:23:26,869
Sí, está en operaciones la lista, ¿no?

607
00:23:31,900 --> 00:23:32,339
Operaciones

608
00:23:32,339 --> 00:23:34,079
Punto alumnos

609
00:23:34,079 --> 00:23:36,359
Punto size

610
00:23:36,359 --> 00:23:38,180
Estos son los que se han

611
00:23:38,180 --> 00:23:40,099
recuperado, luego él sigue insertando

612
00:23:40,099 --> 00:23:42,000
en este caso no los va a insertar

613
00:23:42,000 --> 00:23:43,859
porque como estos ya están, que los he guardado de antes

614
00:23:43,859 --> 00:23:45,539
pues no los va a insertar

615
00:23:45,539 --> 00:23:48,299
es una lista

616
00:23:48,299 --> 00:23:49,980
ah bueno, sí, porque es una lista

617
00:23:49,980 --> 00:23:51,880
no es un set, luego admite duplicados

618
00:23:51,880 --> 00:23:54,000
vale, los insertaría igual en otra posición

619
00:23:54,000 --> 00:23:55,759
vale

620
00:23:55,759 --> 00:23:57,900
y ahora operación guardar

621
00:23:57,900 --> 00:23:59,240
los volvería a guardar

622
00:23:59,240 --> 00:24:01,220
en este caso los cuatro

623
00:24:01,220 --> 00:24:03,859
vamos a ver primero, antes que nada

624
00:24:03,859 --> 00:24:06,200
si me dice cuando yo ejecute este

625
00:24:06,200 --> 00:24:08,140
que se han recuperado dos, porque antes

626
00:24:08,140 --> 00:24:10,200
hemos insertado estos dos, que yo sepa

627
00:24:10,200 --> 00:24:14,150
vamos a

628
00:24:14,150 --> 00:24:22,869
me parece ahí, que pena

629
00:24:22,869 --> 00:24:23,970
se me ha quitado de ahí

630
00:24:23,970 --> 00:24:33,220
pues efectivamente había dos

631
00:24:33,220 --> 00:24:35,259
que son los que ha recuperado

632
00:24:35,259 --> 00:24:36,420
y yo podría aquí

633
00:24:36,420 --> 00:24:39,200
y ahora

634
00:24:39,200 --> 00:24:41,180
habrá otros cuatro, porque ha insertado

635
00:24:41,180 --> 00:24:43,440
estos, como es una lista, repito, no es un set

636
00:24:43,440 --> 00:24:45,019
aunque están duplicados

637
00:24:45,019 --> 00:24:45,740
los meterá

638
00:24:45,740 --> 00:24:48,700
a menos que en insertar alumno

639
00:24:48,700 --> 00:24:51,279
ese método, mirar a ver si estaba o no, no lo sé

640
00:24:51,279 --> 00:24:53,859
y los ha vuelto a guardar, vamos a volver al main

641
00:24:53,859 --> 00:24:56,039
a ver si me dice ahora, se han recuperado 4

642
00:24:56,039 --> 00:25:01,569
efectivamente, se han recuperado 4

643
00:25:01,569 --> 00:25:03,509
y cada vez que le demos, pues

644
00:25:03,509 --> 00:25:08,029
bueno, le he dado tantas veces

645
00:25:08,029 --> 00:25:09,210
ya que ya le he matado

646
00:25:09,210 --> 00:25:11,890
vale, sí

647
00:25:11,890 --> 00:25:13,849
ya sé lo que ha pasado, esto olvidaros

648
00:25:13,849 --> 00:25:15,029
porque le he dado, vale

649
00:25:15,029 --> 00:25:19,890
bueno, pues este uso, es el uso

650
00:25:19,890 --> 00:25:21,910
más básico que hay de object input string

651
00:25:21,910 --> 00:25:23,710
o de output string, que es el más básico

652
00:25:23,710 --> 00:25:26,069
nos permite al menos

653
00:25:26,069 --> 00:25:27,750
hacer una aplicación

654
00:25:27,750 --> 00:25:30,109
en el cual mis datos estén ahí

655
00:25:30,109 --> 00:25:32,210
la aplicación arrancará

656
00:25:32,210 --> 00:25:33,829
yo decidiré en cómo lo tengo que recuperar

657
00:25:33,829 --> 00:25:35,130
cómo lo tengo que guardar, etc.

658
00:25:37,829 --> 00:25:38,089
¿Vale?

659
00:25:44,009 --> 00:25:45,309
Que no te los recupera

660
00:25:45,309 --> 00:25:46,950
pero te da excepción

661
00:25:46,950 --> 00:25:57,500
Porque el fichero tiene cosas, tiene bytes

662
00:25:57,500 --> 00:25:59,579
aunque no podamos ver

663
00:25:59,579 --> 00:26:00,099
el contenido

664
00:26:00,099 --> 00:26:00,720
tiene

665
00:26:00,720 --> 00:26:17,759
vale