1
00:00:02,220 --> 00:00:07,580
su capa más básica para acceder a ficheros

2
00:00:07,580 --> 00:00:10,140
su capa más básica trabaja en dos modos

3
00:00:10,140 --> 00:00:15,080
el modo carácter que es asumiendo que el fichero lo que tiene es texto

4
00:00:15,080 --> 00:00:17,179
es decir, que esos bits que tiene

5
00:00:17,179 --> 00:00:22,199
si los agrupamos de 8 en 8 tiene una correspondencia en la tabla ASCII

6
00:00:22,199 --> 00:00:23,239
que representa un carácter

7
00:00:23,239 --> 00:00:25,980
o el modo byte

8
00:00:25,980 --> 00:00:27,960
o el modo byte

9
00:00:27,960 --> 00:00:35,039
entonces en el modo byte

10
00:00:35,039 --> 00:00:36,539
no hacemos ninguna

11
00:00:36,539 --> 00:00:39,100
suposición sobre el contenido del archivo

12
00:00:39,100 --> 00:00:40,859
asumimos que un archivo

13
00:00:40,859 --> 00:00:43,039
es una lista de ceros y unos

14
00:00:43,039 --> 00:00:44,780
y lo que codifique

15
00:00:44,780 --> 00:00:47,179
pues vete a saber, dependerá de la aplicación

16
00:00:47,179 --> 00:00:49,060
que lo haya generado, si lo ha generado el Word

17
00:00:49,060 --> 00:00:51,359
pues codificará

18
00:00:51,359 --> 00:00:53,399
la codificación

19
00:00:53,399 --> 00:00:54,920
interna del Word, sea la que sea

20
00:00:54,920 --> 00:00:57,179
si lo ha generado el Excel, pues la codificación interna

21
00:00:57,179 --> 00:00:59,140
del Excel, un fichero al fin y al cabo

22
00:00:59,140 --> 00:01:00,659
es eso, es una sucesión de bits

23
00:01:00,659 --> 00:01:03,100
uno tras otro, entonces en algunos

24
00:01:03,100 --> 00:01:03,659
casos

25
00:01:03,659 --> 00:01:07,260
esos bits si los agrupamos de 8 en 8

26
00:01:07,260 --> 00:01:09,099
hacemos la correspondencia con

27
00:01:09,099 --> 00:01:10,900
la tabla ASTI, vemos

28
00:01:10,900 --> 00:01:12,359
un texto con sentido

29
00:01:12,359 --> 00:01:15,000
y eso es un fichero de texto

30
00:01:15,000 --> 00:01:17,019
pero en muchísimos otros casos

31
00:01:17,019 --> 00:01:18,760
esa ristra de bits

32
00:01:18,760 --> 00:01:21,159
no se corresponde con caracteres

33
00:01:21,159 --> 00:01:23,200
de la tabla ASTI, sino se corresponde

34
00:01:23,200 --> 00:01:25,060
con lo que

35
00:01:25,060 --> 00:01:26,920
la aplicación haya generado para

36
00:01:26,920 --> 00:01:28,319
guardar su propia información

37
00:01:28,319 --> 00:01:30,299
y toda esa rista de bits

38
00:01:30,299 --> 00:01:32,140
para que sea interpretable

39
00:01:32,140 --> 00:01:34,799
es esa misma aplicación

40
00:01:34,799 --> 00:01:36,500
Word, Excel, la que sea esa misma

41
00:01:36,500 --> 00:01:38,579
la que lo tiene que abrir, porque si no

42
00:01:38,579 --> 00:01:40,400
es imposible entender de ahí nada

43
00:01:40,400 --> 00:01:42,040
entonces

44
00:01:42,040 --> 00:01:44,299
Java ofrece unas clases

45
00:01:44,299 --> 00:01:46,760
para, asumiendo que los bits

46
00:01:46,760 --> 00:01:48,519
vienen de donde vengan, simplemente

47
00:01:48,519 --> 00:01:50,640
dedicarse a moverlos

48
00:01:50,640 --> 00:01:52,340
moverlos a

49
00:01:52,340 --> 00:01:54,519
memoria principal o volverlos a llevar

50
00:01:54,519 --> 00:01:56,159
al fichero, pero no valen para nada más

51
00:01:56,159 --> 00:01:58,500
porque no puede extraer ninguna información sobre esos bits

52
00:01:58,500 --> 00:02:00,620
no puede extraer ninguna, no valen para nada más

53
00:02:00,620 --> 00:02:03,540
entonces las voy a mencionar solo para que las conozcamos

54
00:02:03,540 --> 00:02:06,280
porque son las básicas sobre las que se monta todo

55
00:02:06,280 --> 00:02:09,060
y esas clases básicas sirven simplemente

56
00:02:09,060 --> 00:02:12,360
para mover bits de 8 en 8

57
00:02:12,360 --> 00:02:15,120
de nuestro fichero a variables de Java

58
00:02:15,120 --> 00:02:18,280
y para volverlas a llevar de variables de Java aquí

59
00:02:18,280 --> 00:02:20,180
y solamente valen para eso

60
00:02:20,180 --> 00:02:23,780
luego ya esos bits que están ahí movidos ya en variables de Java

61
00:02:23,780 --> 00:02:26,000
si esa aplicación Java

62
00:02:26,000 --> 00:02:28,280
tiene información sobre lo que le significan

63
00:02:28,280 --> 00:02:30,080
son de Word, son de no sé qué

64
00:02:30,080 --> 00:02:31,819
puede plantearse hacer cosas con ellos

65
00:02:31,819 --> 00:02:33,939
si tiene esa información añadida sobre lo que significan

66
00:02:33,939 --> 00:02:36,460
pero si no, son 8 bits que no significan

67
00:02:36,460 --> 00:02:37,900
nada para ella

68
00:02:37,900 --> 00:02:40,219
para la aplicación Java, no significan

69
00:02:40,219 --> 00:02:42,379
porque tienen una codificación que depende

70
00:02:42,379 --> 00:02:43,159
de la aplicación

71
00:02:43,159 --> 00:02:45,819
¿vale? entonces

72
00:02:45,819 --> 00:02:48,120
repito, voy a mencionarlas porque son

73
00:02:48,120 --> 00:02:50,240
las básicas o las que se montan todas las

74
00:02:50,240 --> 00:02:51,879
demás, pero

75
00:02:51,879 --> 00:02:53,680
su uso es simplemente ese

76
00:02:53,680 --> 00:02:55,759
coger de un fichero, que son

77
00:02:55,759 --> 00:02:58,240
un montón de bits, mover los bytes

78
00:02:58,240 --> 00:02:59,979
de uno en uno a la aplicación

79
00:02:59,979 --> 00:03:01,560
a variable y ya está

80
00:03:01,560 --> 00:03:03,960
bueno, pues esas clases, las que trabajan

81
00:03:03,960 --> 00:03:05,840
en modo byte

82
00:03:05,840 --> 00:03:07,039
serían estas

83
00:03:07,039 --> 00:03:10,020
file input

84
00:03:10,020 --> 00:03:18,300
stream, para leer

85
00:03:18,300 --> 00:03:20,300
es decir, cuando digo leer

86
00:03:20,300 --> 00:03:21,879
digo mover del fichero

87
00:03:21,879 --> 00:03:23,060
a variables de java

88
00:03:23,060 --> 00:03:26,360
y file output stream para escribir

89
00:03:26,360 --> 00:03:37,520
vale, pues entonces repito

90
00:03:37,520 --> 00:03:39,539
vamos a ver un ejemplo mínimo de cómo

91
00:03:39,539 --> 00:03:41,500
funcionan, pero entendiendo que

92
00:03:41,500 --> 00:03:42,199
su uso

93
00:03:42,199 --> 00:03:45,500
es muy muy muy limitado, porque lo único que hacen

94
00:03:45,500 --> 00:03:47,560
es mover, entonces a lo mejor ¿para qué nos pueden servir?

95
00:03:48,199 --> 00:03:49,479
pues nos pueden servir para copiar

96
00:03:49,479 --> 00:03:51,479
un fichero en otro, por ejemplo, para eso sí

97
00:03:51,479 --> 00:03:53,639
porque cuando yo quiero copiar un fichero en otro

98
00:03:53,639 --> 00:03:55,259
desde una aplicación Java

99
00:03:55,259 --> 00:03:57,460
lo que contiene

100
00:03:57,460 --> 00:03:59,780
la información, lo que significa, el significado

101
00:03:59,780 --> 00:04:01,620
me da igual, lo único que quiero

102
00:04:01,620 --> 00:04:02,719
es llevar estos bits aquí

103
00:04:02,719 --> 00:04:05,620
lo único que quiero es eso, el significado me da igual

104
00:04:05,620 --> 00:04:07,580
pues si el significado me da igual

105
00:04:07,580 --> 00:04:09,199
con estas clases tengo suficiente

106
00:04:09,199 --> 00:04:10,699
porque lo que haré será

107
00:04:10,699 --> 00:04:13,259
llevar a la aplicación java

108
00:04:13,259 --> 00:04:14,840
y luego de la aplicación java llevar al otro

109
00:04:14,840 --> 00:04:16,720
¿vale? entonces

110
00:04:16,720 --> 00:04:18,699
en aplicaciones java

111
00:04:18,699 --> 00:04:21,720
que necesiten trasladar esos bits

112
00:04:21,720 --> 00:04:23,319
o hacer cosas con esos bits

113
00:04:23,319 --> 00:04:25,600
pero sin importarles

114
00:04:25,600 --> 00:04:27,740
en absoluto lo que representan

115
00:04:27,740 --> 00:04:29,620
pues estas clases pueden ser suficientes

116
00:04:29,620 --> 00:04:31,420
¿vale? vamos a hacer ese ejemplo

117
00:04:31,420 --> 00:04:33,560
sin más, un ejemplito de una aplicación

118
00:04:33,560 --> 00:04:35,540
java para copiar un fichero

119
00:04:35,540 --> 00:04:37,660
en otro, por ejemplo, con otro

120
00:04:37,660 --> 00:04:38,920
nombre y ya está

121
00:04:38,920 --> 00:04:41,720
y luego ya pasamos a clases

122
00:04:41,720 --> 00:04:43,480
que ya están montadas sobre

123
00:04:43,480 --> 00:04:45,540
estas que hacen cosas un poquito más

124
00:04:45,540 --> 00:04:47,600
sofisticadas, ¿vale? pero están

125
00:04:47,600 --> 00:04:49,100
montadas sobre estas que son la base

126
00:04:49,100 --> 00:04:51,120
las de mover bits de un lado a otro

127
00:04:51,120 --> 00:04:53,620
venga, pues vamos a

128
00:04:53,620 --> 00:04:55,480
hacernos aquí en el proyecto

129
00:04:55,480 --> 00:04:56,579
ejemplo que estábamos

130
00:04:56,579 --> 00:04:58,540
otro paquete

131
00:04:58,540 --> 00:05:02,000
que lo vamos a llamar

132
00:05:02,000 --> 00:05:03,660
modo byte

133
00:05:03,660 --> 00:05:04,759
para que

134
00:05:04,759 --> 00:05:10,459
sepamos que ahí está el ejemplito

135
00:05:10,459 --> 00:05:11,839
para hacer esta aplicación Java

136
00:05:11,839 --> 00:05:13,439
que usa estas clases que hemos dicho

137
00:05:13,439 --> 00:05:14,560
para copiar un fichero en otro

138
00:05:14,560 --> 00:05:16,319
pues venga

139
00:05:16,319 --> 00:05:19,519
nos hacemos una clase cualquiera

140
00:05:19,519 --> 00:05:20,720
que va a tener ya el main

141
00:05:20,720 --> 00:05:26,870
copiar ficheros

142
00:05:26,870 --> 00:05:27,750
vale

143
00:05:27,750 --> 00:05:34,259
venga pues en esta clase vamos a hacer un método

144
00:05:34,259 --> 00:05:36,259
que va a servir

145
00:05:36,259 --> 00:05:40,189
para

146
00:05:40,189 --> 00:05:42,769
he dado un nombre de fichero

147
00:05:42,769 --> 00:05:44,689
origen y un nombre de fichero destino

148
00:05:44,689 --> 00:05:47,689
copiar el fichero origen en el fichero destino

149
00:05:47,689 --> 00:05:49,970
como si hiciéramos un move del sistema operativo

150
00:05:49,970 --> 00:05:52,610
desde la línea de comandos

151
00:05:52,610 --> 00:05:54,949
pues venga

152
00:05:54,949 --> 00:06:01,860
vale, pues este método vamos a hacer

153
00:06:01,860 --> 00:06:02,899
le vamos a pasar los nombres

154
00:06:02,899 --> 00:06:05,220
directamente es como si simularamos el

155
00:06:05,220 --> 00:06:06,660
el copy

156
00:06:06,660 --> 00:06:09,199
del move o como lo queréis llamar

157
00:06:09,199 --> 00:06:10,399
del sistema operativo

158
00:06:10,399 --> 00:06:11,879
que recibe le ponemos dos nombres

159
00:06:11,879 --> 00:06:13,100
le ponemos ahí dos cadenas

160
00:06:13,100 --> 00:06:15,139
pues entonces

161
00:06:15,139 --> 00:06:19,360
vale

162
00:06:19,360 --> 00:06:23,240
Fichero origen

163
00:06:23,240 --> 00:06:26,709
Y el otro

164
00:06:26,709 --> 00:06:32,339
Fichero destino

165
00:06:32,339 --> 00:06:35,430
Ala

166
00:06:35,430 --> 00:06:37,730
Bueno, pues entonces

167
00:06:37,730 --> 00:06:39,889
Aquí uno ve este método y dice

168
00:06:39,889 --> 00:06:41,009
¿Qué tengo que hacer con esto?

169
00:06:41,709 --> 00:06:42,889
Este fichero tiene unos bits

170
00:06:42,889 --> 00:06:44,769
Y este tiene otros

171
00:06:44,769 --> 00:06:47,610
El objetivo es que estos bits se muevan aquí

172
00:06:47,610 --> 00:06:50,569
¿Tengo que interpretar algo sobre su contenido?

173
00:06:51,189 --> 00:06:52,209
No tengo que interpretar nada

174
00:06:52,209 --> 00:06:53,930
Solo tengo que moverlos de un sitio a otro

175
00:06:53,930 --> 00:06:55,470
No tengo que interpretar nada

176
00:06:55,470 --> 00:06:57,610
pues entonces estas clases

177
00:06:57,610 --> 00:06:59,769
input, file, input, string, file, output

178
00:06:59,769 --> 00:07:01,529
nos valen, porque estas clases valen

179
00:07:01,529 --> 00:07:03,389
para mover, nada más

180
00:07:03,389 --> 00:07:05,069
para trasladar, pues estas me valen

181
00:07:05,069 --> 00:07:07,170
que son las más básicas, las más sencillas

182
00:07:07,170 --> 00:07:09,089
las que menos carga computacional tienen

183
00:07:09,089 --> 00:07:11,209
vale, pues entonces

184
00:07:11,209 --> 00:07:12,610
una aplicación java

185
00:07:12,610 --> 00:07:15,389
para acceder a ficheros

186
00:07:15,389 --> 00:07:17,449
ya sabemos que puede hacer

187
00:07:17,449 --> 00:07:19,709
dos cosas, o leer

188
00:07:19,709 --> 00:07:20,750
y leer es

189
00:07:20,750 --> 00:07:23,790
coger del fichero y llevarlo a variables internas

190
00:07:23,790 --> 00:07:25,189
para con esa

191
00:07:25,189 --> 00:07:27,050
una vez que ya están variables internas

192
00:07:27,050 --> 00:07:27,949
hacer con eso lo que sea

193
00:07:27,949 --> 00:07:31,990
o escribir que es lo que tienen variables internas

194
00:07:31,990 --> 00:07:32,990
llevarlo a un fichero

195
00:07:32,990 --> 00:07:35,550
esas son las dos cosas

196
00:07:35,550 --> 00:07:36,970
que se pueden hacer con ficheros

197
00:07:36,970 --> 00:07:38,089
desde una aplicación Java

198
00:07:38,089 --> 00:07:40,250
coger su información

199
00:07:40,250 --> 00:07:43,110
y traerla a variables

200
00:07:43,110 --> 00:07:44,209
de la aplicación

201
00:07:44,209 --> 00:07:47,529
o contenido que está en variables

202
00:07:47,529 --> 00:07:48,889
moverlo a ficheros

203
00:07:48,889 --> 00:07:50,329
esas son las dos cosas que se puede hacer

204
00:07:50,329 --> 00:07:52,889
y luego ya con esa información

205
00:07:52,889 --> 00:07:54,850
que está en variables uno ya procesa

206
00:07:54,850 --> 00:07:56,569
hace todo lo que necesite hacer

207
00:07:56,569 --> 00:07:58,750
porque

208
00:07:58,750 --> 00:08:00,730
de nuevo repito, una aplicación Java

209
00:08:00,730 --> 00:08:02,389
cuando opera con datos

210
00:08:02,389 --> 00:08:04,250
esos datos tienen que estar en variables

211
00:08:04,250 --> 00:08:06,490
ahí sí que no hay tutía, tienen que estar en variables

212
00:08:06,490 --> 00:08:08,269
me da igual qué tipo de variables

213
00:08:08,269 --> 00:08:10,610
primitivas, colecciones, objetos, pero una aplicación

214
00:08:10,610 --> 00:08:12,589
Java solo puede trabajar con los datos

215
00:08:12,589 --> 00:08:13,910
que están en sus variables

216
00:08:13,910 --> 00:08:16,470
¿de dónde han llegado

217
00:08:16,470 --> 00:08:18,529
esos datos? ¿que me los han metido en la

218
00:08:18,529 --> 00:08:20,310
consola? ¿que los he leído de un fichero?

219
00:08:20,589 --> 00:08:22,250
bueno, pues ya veremos, depende

220
00:08:22,250 --> 00:08:24,509
pero una aplicación solo puede operar

221
00:08:24,509 --> 00:08:25,829
con lo que tienen sus variables

222
00:08:25,829 --> 00:08:28,970
y como cuando la aplicación termina

223
00:08:28,970 --> 00:08:30,410
lo que está en las variables

224
00:08:30,410 --> 00:08:32,570
se borra porque las variables

225
00:08:32,570 --> 00:08:34,450
desaparecen, pues por eso

226
00:08:34,450 --> 00:08:36,370
uno se tiene que preocupar si quiere

227
00:08:36,370 --> 00:08:38,289
que esa información se conserve de llevarla

228
00:08:38,289 --> 00:08:40,470
a un fichero antes de que la aplicación

229
00:08:40,470 --> 00:08:41,450
termine o lo que sea

230
00:08:41,450 --> 00:08:44,490
bueno, pues entonces aquí nuestra operación

231
00:08:44,490 --> 00:08:46,509
es estos bits que están en este fichero

232
00:08:46,509 --> 00:08:47,889
tienen que ir a estos bits que están en este

233
00:08:47,889 --> 00:08:50,509
como lo único que puede hacer Java es

234
00:08:50,509 --> 00:08:52,149
llevar de

235
00:08:52,149 --> 00:08:54,490
fichero a variable

236
00:08:54,490 --> 00:08:56,750
o de variables a fichero, pues tendremos que hacer

237
00:08:56,750 --> 00:08:59,029
esos dos pasos, primero llevamos

238
00:08:59,029 --> 00:09:01,090
de este fichero a variables

239
00:09:01,090 --> 00:09:02,809
y luego llevamos de variables

240
00:09:02,809 --> 00:09:04,690
a este fichero, esos dos pasos hay que hacerlos

241
00:09:04,690 --> 00:09:07,009
porque no se puede llevar de un fichero

242
00:09:07,009 --> 00:09:08,809
a otro directamente, siempre hay que pasar

243
00:09:08,809 --> 00:09:10,330
por RAM, vale

244
00:09:10,330 --> 00:09:12,629
el disco duro no se puede

245
00:09:12,629 --> 00:09:14,730
comunicar entre sí directamente, de un sector

246
00:09:14,730 --> 00:09:16,870
a otro, es imposible, siempre tiene que viajar

247
00:09:16,870 --> 00:09:19,070
a la memoria RAM y salir otra vez

248
00:09:19,070 --> 00:09:21,070
vale, pues aquí

249
00:09:21,070 --> 00:09:23,070
igual, yo tengo dos ficheros

250
00:09:23,070 --> 00:09:26,990
uno tiene que viajar a las variables de mi aplicación

251
00:09:26,990 --> 00:09:30,990
a la RAM y de ahí irse a el otro fichero

252
00:09:30,990 --> 00:09:33,889
vale, pues entonces vamos a hacer primero la operación de lectura

253
00:09:33,889 --> 00:09:38,470
la de lectura es, voy a leer de uno y luego voy a escribir en otro

254
00:09:38,470 --> 00:09:42,289
bueno, pues leer bytes de un fichero, el file input string

255
00:09:42,289 --> 00:09:50,840
pues nada, lo instanciamos aquí, y como se instancia

256
00:09:50,840 --> 00:09:53,360
este objeto file input string, pues como el file reader

257
00:09:53,360 --> 00:09:55,460
le damos

258
00:09:55,460 --> 00:09:58,179
o bien el nombre

259
00:09:58,179 --> 00:09:59,480
del fichero directamente

260
00:09:59,480 --> 00:10:01,480
o el objeto file asociado

261
00:10:01,480 --> 00:10:03,779
el constructor me permite las dos variantes

262
00:10:03,779 --> 00:10:04,820
igual que file reader

263
00:10:04,820 --> 00:10:06,940
como tenemos el nombre

264
00:10:06,940 --> 00:10:08,399
vamos a usar el constructor

265
00:10:08,399 --> 00:10:10,720
que recibe el nombre

266
00:10:10,720 --> 00:10:13,379
el string con la cadena de texto que es el nombre

267
00:10:13,379 --> 00:10:19,049
vale, pues ya tenemos un

268
00:10:19,049 --> 00:10:21,190
flujo conectado a un fichero

269
00:10:21,190 --> 00:10:23,309
con este nombre, hay preparado

270
00:10:23,309 --> 00:10:24,809
para hacer operaciones de lectura

271
00:10:24,809 --> 00:10:27,509
es decir, para hacer operaciones

272
00:10:27,509 --> 00:10:29,370
de coger del fichero y llevar

273
00:10:29,370 --> 00:10:31,250
a la memoria RAM

274
00:10:31,250 --> 00:10:31,789
a variables

275
00:10:31,789 --> 00:10:35,190
esto habrá que importarlo, claro, del paquete

276
00:10:35,190 --> 00:10:35,809
java.io

277
00:10:35,809 --> 00:10:39,289
y de nuevo, esta operación

278
00:10:39,289 --> 00:10:40,929
puede lanzar una excepción

279
00:10:40,929 --> 00:10:42,350
file not found exception

280
00:10:42,350 --> 00:10:45,289
y te dice, tienes que capturarla

281
00:10:45,289 --> 00:10:47,450
o avisar, para quien use este método

282
00:10:47,450 --> 00:10:49,090
pues por no complicar el código

283
00:10:49,090 --> 00:10:50,990
la propagamos

284
00:10:50,990 --> 00:10:53,049
throws, ala, ya está

285
00:10:53,049 --> 00:10:54,629
y ahora toca leer

286
00:10:54,629 --> 00:10:57,470
bueno, pues esto es el mismo bucle de lectura

287
00:10:57,470 --> 00:10:59,450
el mismo que con el FileReader

288
00:10:59,450 --> 00:11:03,590
cada lectura, este tiene un método read

289
00:11:03,590 --> 00:11:05,509
igual que tenía el FileReader

290
00:11:05,509 --> 00:11:07,309
este método

291
00:11:07,309 --> 00:11:09,029
este método que te hace, te lee un byte

292
00:11:09,029 --> 00:11:11,610
silencio

293
00:11:11,610 --> 00:11:13,490
con leerte un byte

294
00:11:13,490 --> 00:11:15,590
me refiero, coge un byte del fichero

295
00:11:15,590 --> 00:11:17,070
y te lo lleva

296
00:11:17,070 --> 00:11:18,250
a una variable

297
00:11:18,250 --> 00:11:20,210
del programa

298
00:11:20,210 --> 00:11:23,450
¿a qué tipo de variable? a una variable de tipo byte

299
00:11:23,450 --> 00:11:25,470
podría ser porque cabe

300
00:11:25,470 --> 00:11:27,250
en una variable de tipo byte, pero no

301
00:11:27,250 --> 00:11:29,409
te lo lleva a una variable

302
00:11:29,409 --> 00:11:30,169
de tipo int

303
00:11:30,169 --> 00:11:32,149
ahí te lo lleva

304
00:11:32,149 --> 00:11:35,350
entonces, esto que hemos hecho aquí

305
00:11:35,350 --> 00:11:37,590
bueno, aparte de que puede hacer una excepción

306
00:11:37,590 --> 00:11:39,210
y o exception que vamos a propagar

307
00:11:39,210 --> 00:11:42,750
esta sentencia de aquí

308
00:11:42,750 --> 00:11:45,210
te lee un único byte

309
00:11:45,210 --> 00:11:47,330
del fichero, lo coloca

310
00:11:47,330 --> 00:11:49,070
en el byte menos

311
00:11:49,070 --> 00:11:50,789
significativo de la variable n

312
00:11:50,789 --> 00:11:52,649
que ya sabéis que tiene 4

313
00:11:52,649 --> 00:11:55,049
en el byte menos significativo

314
00:11:55,049 --> 00:11:56,590
lo coloca, el resto lo deja a ceros

315
00:11:56,590 --> 00:11:59,009
y el posicionador interno

316
00:11:59,009 --> 00:12:00,809
del fichero lo avanza para que

317
00:12:00,809 --> 00:12:02,870
en la siguiente lectura, en el siguiente read

318
00:12:02,870 --> 00:12:04,929
leamos el siguiente, exactamente igual que con

319
00:12:04,929 --> 00:12:07,149
el file reader

320
00:12:07,149 --> 00:12:07,850
en realidad

321
00:12:07,850 --> 00:12:10,529
la única diferencia es que con el file reader

322
00:12:10,529 --> 00:12:12,129
si luego hacíamos el casting a char

323
00:12:12,129 --> 00:12:14,909
pues nos daba un carácter, aquí no

324
00:12:14,909 --> 00:12:17,269
nos da nada, porque lo mueve tal cual

325
00:12:17,269 --> 00:12:18,370
es que no hace ninguna

326
00:12:18,370 --> 00:12:21,450
los bits tal cual son, nos lleva a n

327
00:12:21,450 --> 00:12:24,169
Vale, pues entonces

328
00:12:24,169 --> 00:12:27,350
¿Y qué queremos hacer con cada uno de ellos?

329
00:12:27,590 --> 00:12:28,509
Llevarlos al otro

330
00:12:28,509 --> 00:12:32,490
Mismo bucle de lectura que en el file reader

331
00:12:32,490 --> 00:12:35,269
Tendremos que hacer tantos read de estos

332
00:12:35,269 --> 00:12:37,990
Tantos read como bytes haya

333
00:12:37,990 --> 00:12:39,909
Esto habrá que meterlo en un while, ¿verdad?

334
00:12:41,129 --> 00:12:43,929
Entonces el bucle de lectura se queda igual que el file reader

335
00:12:43,929 --> 00:12:46,250
Mientras

336
00:12:46,250 --> 00:12:49,110
Yo aquí declararía mi variable n

337
00:12:49,110 --> 00:13:14,450
Y mientras n, siendo n el resultado de hacer una lectura, sea diferente de menos 1, porque tenemos la misma forma de avisar que con el file reader.

338
00:13:16,649 --> 00:13:24,330
La sentencia esta read, coge un byte y lo lleva a n, a la parte menos significativa, el resto lo pone todo a ceros.

339
00:13:24,330 --> 00:13:27,389
vale, que ocurre

340
00:13:27,389 --> 00:13:29,529
si este react intenta leer

341
00:13:29,529 --> 00:13:31,090
la marca fin de archivo

342
00:13:31,090 --> 00:13:32,990
porque ya acabamos, intenta leer la marca

343
00:13:32,990 --> 00:13:34,129
fin de archivo

344
00:13:34,129 --> 00:13:36,330
en este numerito n

345
00:13:36,330 --> 00:13:38,929
lo que coloca es el número entero

346
00:13:38,929 --> 00:13:41,230
menos uno, entonces como el número entero

347
00:13:41,230 --> 00:13:42,909
es menos uno, es negativo

348
00:13:42,909 --> 00:13:44,710
y por tanto su bit de signo es uno

349
00:13:44,710 --> 00:13:47,289
luego no, es la forma

350
00:13:47,289 --> 00:13:49,049
de ver que ese no es un byte

351
00:13:49,049 --> 00:13:50,990
del fichero, porque si fuera un byte del fichero

352
00:13:50,990 --> 00:13:53,110
este numerito n tendría todos ceros aquí

353
00:13:53,110 --> 00:13:55,730
con lo cual es imposible que sea menos uno

354
00:13:55,730 --> 00:13:57,590
porque su bit de signo es cero, es positivo

355
00:13:57,590 --> 00:13:59,830
entonces si esto hubiera

356
00:13:59,830 --> 00:14:01,850
hecho una lectura

357
00:14:01,850 --> 00:14:03,190
válida, una lectura válida

358
00:14:03,190 --> 00:14:05,370
jamás podría ser menos uno

359
00:14:05,370 --> 00:14:07,809
jamás podría ser menos uno, podría ser lo que fuera

360
00:14:07,809 --> 00:14:09,750
pero no menos uno porque el bit de signo sería

361
00:14:09,750 --> 00:14:11,610
cero, luego sería un positivo

362
00:14:11,610 --> 00:14:14,149
si me devuelve menos uno

363
00:14:14,149 --> 00:14:16,029
es porque lo que ha leído

364
00:14:16,029 --> 00:14:17,970
es la marca fin de archivo, entonces lo ha colocado

365
00:14:17,970 --> 00:14:18,590
todo a unos

366
00:14:18,590 --> 00:14:21,769
y entonces es mi manera de ver

367
00:14:21,769 --> 00:14:22,950
que, ah, vale, vale

368
00:14:22,950 --> 00:14:25,450
no has conseguido mover un byte

369
00:14:25,450 --> 00:14:27,789
no lo has conseguido, pues si hubieras conseguido

370
00:14:27,789 --> 00:14:29,809
n tendría un número positivo

371
00:14:29,809 --> 00:14:31,169
el que fuera, pero positivo

372
00:14:31,169 --> 00:14:33,669
no lo has conseguido, me estás avisando

373
00:14:33,669 --> 00:14:35,370
poniendo menos uno en ese n

374
00:14:35,370 --> 00:14:37,710
pues ya está, esta es la misma

375
00:14:37,710 --> 00:14:39,590
condición de fin de archivo en el file real

376
00:14:39,590 --> 00:14:41,870
pues mientras n, siendo n

377
00:14:41,870 --> 00:14:43,809
el intento de leer

378
00:14:43,809 --> 00:14:45,929
el byte, no me haya

379
00:14:45,929 --> 00:14:47,509
devuelto este resultado

380
00:14:47,509 --> 00:14:49,450
mientras no me lo haya devuelto, yo ya con n

381
00:14:49,450 --> 00:14:51,710
hago ahí lo que quiera, n es un byte

382
00:14:51,710 --> 00:14:53,830
que tiene bits, que a saberlo decodifica eso

383
00:14:53,830 --> 00:14:55,389
ni idea, un char no

384
00:14:55,389 --> 00:14:57,230
no tiene por qué, ni idea

385
00:14:57,230 --> 00:14:59,990
vale, en este ejemplo en concreto, ¿qué queremos hacer

386
00:14:59,990 --> 00:15:01,990
con sn? queremos mandarlo al otro

387
00:15:01,990 --> 00:15:03,690
archivo, y así, leemos byte

388
00:15:03,690 --> 00:15:06,049
escribimos, leemos byte, escribimos, leemos byte

389
00:15:06,049 --> 00:15:07,990
escribimos, el otro archivo está

390
00:15:07,990 --> 00:15:09,909
sin abrir, pues vamos a

391
00:15:09,909 --> 00:15:11,929
abrirlo, este, como este caso es

392
00:15:11,929 --> 00:15:12,649
para escribir

393
00:15:12,649 --> 00:15:15,549
pues vamos a

394
00:15:15,549 --> 00:15:17,769
abrirlo con file output

395
00:15:17,769 --> 00:15:20,149
stream

396
00:15:20,149 --> 00:15:22,370
que es para escribir bytes

397
00:15:22,370 --> 00:15:30,149
de nuevo el constructor

398
00:15:30,149 --> 00:15:32,210
o bien se le pasa

399
00:15:32,210 --> 00:15:34,269
la cadena de texto que tiene el nombre

400
00:15:34,269 --> 00:15:36,190
o el objeto file asociado

401
00:15:36,190 --> 00:15:38,190
da igual, admite ambas opciones

402
00:15:38,190 --> 00:15:39,990
como tenemos la cadena de texto

403
00:15:39,990 --> 00:15:41,769
en lugar de hacer new file esa cadena

404
00:15:41,769 --> 00:15:44,090
pues le pasamos el nombrecito

405
00:15:44,090 --> 00:15:47,720
y ya está, fichero

406
00:15:47,720 --> 00:15:49,519
destino

407
00:15:49,519 --> 00:15:55,740
y este admite un segundo

408
00:15:55,740 --> 00:15:57,679
parámetro que tiene la misma

409
00:15:57,679 --> 00:15:59,139
utilidad que en el file writer

410
00:15:59,139 --> 00:16:01,720
que es, cuando yo abro este fichero

411
00:16:01,720 --> 00:16:03,700
puede ocurrir dos cosas

412
00:16:03,700 --> 00:16:05,559
que este ya exista

413
00:16:05,559 --> 00:16:07,360
de antes o que no exista

414
00:16:07,360 --> 00:16:09,299
si no existe de antes

415
00:16:09,299 --> 00:16:10,700
se crea nuevo y limpio

416
00:16:10,700 --> 00:16:13,419
pero y si existe de antes

417
00:16:13,419 --> 00:16:15,600
¿qué hace? pues si existe de antes

418
00:16:15,600 --> 00:16:17,620
lo abro para escribir pero tengo dos opciones

419
00:16:17,620 --> 00:16:20,000
me posiciono al final para añadir

420
00:16:20,000 --> 00:16:22,000
o me posiciono al principio

421
00:16:22,000 --> 00:16:23,080
y todo lo que hay después

422
00:16:23,080 --> 00:16:24,179
lo tiro a la basura

423
00:16:24,179 --> 00:16:27,299
¿cuál de las dos opciones escoge?

424
00:16:27,299 --> 00:16:29,440
depende de si yo aquí pongo true o false

425
00:16:29,440 --> 00:16:31,360
si pongo true

426
00:16:31,360 --> 00:16:33,019
se posiciona al final

427
00:16:33,019 --> 00:16:35,360
para añadir a continuación

428
00:16:35,360 --> 00:16:37,299
de lo que ya hubiera, exactamente igual que

429
00:16:37,299 --> 00:16:39,179
en el file writer, igual, si pongo

430
00:16:39,179 --> 00:16:41,480
false, no añade, se posiciona

431
00:16:41,480 --> 00:16:42,899
al principio, elimina lo demás

432
00:16:42,899 --> 00:16:44,700
si no ponemos nada

433
00:16:44,700 --> 00:16:46,919
la opción por defecto es como haber puesto false

434
00:16:46,919 --> 00:16:48,600
todo esto es igual que el file writer

435
00:16:48,600 --> 00:16:51,200
en nuestro caso, vamos a copiar

436
00:16:51,200 --> 00:16:52,200
este en este otro

437
00:16:52,200 --> 00:16:55,200
si el fichero existe, pues lo vamos a sobrescribir

438
00:16:55,200 --> 00:16:59,539
podríamos, si queremos hacer

439
00:16:59,539 --> 00:17:01,620
este método más bonito, por ejemplo

440
00:17:01,620 --> 00:17:03,679
podríamos hacer aquí, vamos a ver si existe

441
00:17:03,679 --> 00:17:05,700
y si existe avisamos

442
00:17:05,700 --> 00:17:06,859
desea sobre escribir

443
00:17:06,859 --> 00:17:09,500
¿cómo podríamos ver si este archivo existe?

444
00:17:10,240 --> 00:17:11,619
pues para esto tenemos la clase file

445
00:17:11,619 --> 00:17:13,519
que me permite obtener información sobre el archivo

446
00:17:13,519 --> 00:17:15,400
si existe, si es de lectura, escritura

447
00:17:15,400 --> 00:17:17,900
pues podríamos instanciar un objeto

448
00:17:17,900 --> 00:17:19,279
file asociado

449
00:17:19,279 --> 00:17:22,099
a ese archivo

450
00:17:22,099 --> 00:17:26,839
a este

451
00:17:26,839 --> 00:17:29,200
fichero destino

452
00:17:29,200 --> 00:17:33,809
y ahora podríamos hacer

453
00:17:33,809 --> 00:17:37,190
Si el fichero existe, le preguntamos

454
00:17:37,190 --> 00:17:38,630
¿Desea sobrescribir sí o no?

455
00:17:38,869 --> 00:17:41,289
Y si te dice que no desea sobrescribir, retún

456
00:17:41,289 --> 00:17:42,329
Ya está, que no haga nada

457
00:17:42,329 --> 00:17:44,309
Podemos hacer eso, ¿no?

458
00:17:45,430 --> 00:17:49,670
Si f.existe

459
00:17:49,670 --> 00:17:52,390
Si el fichero existe, este fichero

460
00:17:52,390 --> 00:17:55,190
Pues le podríamos preguntar ahora ya sí

461
00:17:55,190 --> 00:18:05,609
El fichero existe

462
00:18:05,609 --> 00:18:11,289
¿Desea sobrescribir?

463
00:18:15,009 --> 00:18:16,049
leemos

464
00:18:16,049 --> 00:18:18,329
su respuesta

465
00:18:18,329 --> 00:18:19,029
si no

466
00:18:19,029 --> 00:18:28,279
para lo cual pues hay que leer del teclado

467
00:18:28,279 --> 00:18:30,160
con escáner o con lo que

468
00:18:30,160 --> 00:18:31,519
os dé la gana

469
00:18:31,519 --> 00:18:42,039
aquí ya la tengo ahí

470
00:18:42,039 --> 00:18:42,299
vale

471
00:18:42,299 --> 00:18:44,680
yo leo con

472
00:18:44,680 --> 00:18:46,779
esta clase

473
00:18:46,779 --> 00:18:52,630
y yo haría ya directamente

474
00:18:52,630 --> 00:18:54,730
si teclado.leercadena

475
00:18:54,730 --> 00:18:57,490
es

476
00:18:57,490 --> 00:19:00,930
igual a no, no desea sobrescribir

477
00:19:00,930 --> 00:19:03,789
es igual

478
00:19:03,789 --> 00:19:04,970
a n

479
00:19:04,970 --> 00:19:12,069
pues entonces, como me ha dicho

480
00:19:12,069 --> 00:19:14,049
que no, ya no tengo más que

481
00:19:14,049 --> 00:19:15,390
hacer el método que termine

482
00:19:15,390 --> 00:19:17,150
por ejemplo, pues que termine

483
00:19:17,150 --> 00:19:20,289
entonces aquí ya le puedo poner directamente

484
00:19:20,289 --> 00:19:21,670
eh

485
00:19:21,670 --> 00:19:23,349
return

486
00:19:23,349 --> 00:19:25,670
y listo, vale

487
00:19:25,670 --> 00:19:27,569
entonces si el fichero existe

488
00:19:27,569 --> 00:19:29,930
me avisa y me dice

489
00:19:29,930 --> 00:19:31,450
¿quiere sobreescribir? le digo que no

490
00:19:31,450 --> 00:19:32,710
vale, pues termina

491
00:19:32,710 --> 00:19:34,470
¿que no le he dicho que no?

492
00:19:35,309 --> 00:19:38,329
No entraría aquí, el método sigue y ahora ya hace todo esto.

493
00:19:38,549 --> 00:19:45,309
De hecho, esto lo voy a poner para que lo haga aquí solo si lo necesita.

494
00:19:49,890 --> 00:19:50,769
Bueno, pues nada.

495
00:19:52,069 --> 00:19:56,930
Hemos dicho que o bien no existe, con lo cual no ha entrado en este if,

496
00:19:57,089 --> 00:19:59,890
o bien no existe, o bien existía, pero ha dicho que sobrescribe.

497
00:20:00,690 --> 00:20:04,950
En cualquiera de esas dos cosas, si no existe o si existiendo quiere sobrescribir,

498
00:20:04,950 --> 00:20:06,789
en cualquiera de ellas hemos llegado a este punto.

499
00:20:07,069 --> 00:20:39,720
hemos llegado a ese punto, vale, pues abrimos esto para leer, que es lo que estábamos, abrimos esto para escribir, vale, no le ponemos que añada, porque nos ha dicho que sobrescribe, pues así se queda, importamos de aquí, y nos dice la excepción, espérate, algo, he escrito algo mal, porque, ah, no, no, vale, vale, y ahora ya,

500
00:20:39,720 --> 00:20:41,980
voy leyendo del primero

501
00:20:41,980 --> 00:20:43,640
con cada byte leído, ¿qué quiero hacer?

502
00:20:43,700 --> 00:20:45,420
llevarlo al otro, y se acabó

503
00:20:45,420 --> 00:20:46,440
y para eso tendré

504
00:20:46,440 --> 00:20:49,740
un método GRUITE al que le paso

505
00:20:49,740 --> 00:20:51,000
ese byte

506
00:20:51,000 --> 00:20:52,380
y ya está

507
00:20:52,380 --> 00:20:55,259
¿y el GRUITE qué hace?

508
00:20:55,539 --> 00:20:57,799
el GRUITE coge el byte

509
00:20:57,799 --> 00:20:59,779
menos significativo de este

510
00:20:59,779 --> 00:21:01,339
el menos significativo

511
00:21:01,339 --> 00:21:02,900
porque en ese es en el que está la información

512
00:21:02,900 --> 00:21:04,819
el resto están solo

513
00:21:04,819 --> 00:21:07,799
para habilitar esa posibilidad de poner el menos uno

514
00:21:07,799 --> 00:21:08,980
solo están para eso

515
00:21:08,980 --> 00:21:10,099
pero no tienen información

516
00:21:10,099 --> 00:21:13,220
la única información está en el byte

517
00:21:13,220 --> 00:21:14,599
menos significativo de n

518
00:21:14,599 --> 00:21:18,779
vale, pues este lo que hace es eso

519
00:21:18,779 --> 00:21:20,920
coge el byte

520
00:21:20,920 --> 00:21:22,519
menos significativo de n

521
00:21:22,519 --> 00:21:24,279
que es donde se guardó lo que leyó

522
00:21:24,279 --> 00:21:24,980
y va al otro

523
00:21:24,980 --> 00:21:28,240
y se acabó, cuando este bucle ha terminado

524
00:21:28,240 --> 00:21:30,180
pues ya podemos cerrar los dos

525
00:21:30,180 --> 00:21:32,519
y listo

526
00:21:37,680 --> 00:21:38,759
bueno, pues con este

527
00:21:38,759 --> 00:21:40,359
ejemplito sencillo en el cual

528
00:21:40,359 --> 00:21:42,740
lo único que necesitamos es coger los bytes

529
00:21:42,740 --> 00:21:45,940
Llevarlos a sitios, pero lo que codifiquen nos da igual

530
00:21:45,940 --> 00:21:49,240
Pues con estas dos clases que son de muy bajo nivel

531
00:21:49,240 --> 00:21:51,799
Y por tanto muy eficientes computacionalmente

532
00:21:51,799 --> 00:21:52,380
Pues nos vale

533
00:21:52,380 --> 00:21:59,539
Si vamos a probarlo ahora

534
00:21:59,539 --> 00:22:02,599
Desde aquí

535
00:22:02,599 --> 00:22:06,930
Fichero origen

536
00:22:06,930 --> 00:22:14,769
Y aquí

537
00:22:14,769 --> 00:22:20,200
Fichero origen

538
00:22:20,200 --> 00:22:22,200
Le voy a pedir el destino

539
00:22:22,200 --> 00:22:23,440
Luego llamo al método

540
00:22:23,440 --> 00:22:30,700
Fichero destino

541
00:22:30,700 --> 00:22:33,220
Y ahora voy a llamar al método

542
00:22:33,220 --> 00:22:34,559
Copiar fichero

543
00:22:34,559 --> 00:22:39,480
Este que le he dicho

544
00:22:39,480 --> 00:22:40,519
Copialo aquí

545
00:22:40,519 --> 00:22:44,869
Y vamos a ver si funciona y lo copia

546
00:22:44,869 --> 00:22:46,690
Como lanza excepción, pues me dice

547
00:22:46,690 --> 00:22:48,289
Si tienes que hacer algo, pues throws

548
00:22:48,289 --> 00:22:49,529
El throws se va aquí al main

549
00:22:49,529 --> 00:22:51,670
Y ya está

550
00:22:51,670 --> 00:22:55,269
Vale, entonces estoy en este fichero

551
00:22:55,269 --> 00:22:57,269
Uy, en este proyecto

552
00:22:57,269 --> 00:22:58,349
Vamos a probar

553
00:22:58,349 --> 00:23:02,140
Este de aquí, destino

554
00:23:02,140 --> 00:23:04,460
Vamos a copiarlo en destino2

555
00:23:04,460 --> 00:23:10,099
Pues venga, ejecutamos esto

556
00:23:10,099 --> 00:23:15,319
Fichero origen, este

557
00:23:15,319 --> 00:23:18,740
Copialo en destino 2

558
00:23:18,740 --> 00:23:22,180
No dice nada, suponemos que lo habrá copiado

559
00:23:22,180 --> 00:23:25,630
Vamos a actualizar

560
00:23:25,630 --> 00:23:29,490
Refresh ahí

561
00:23:29,490 --> 00:23:34,269
Y destino 2 está aquí, que efectivamente tiene la misma información

562
00:23:34,269 --> 00:23:37,710
Si dijéramos que copie destino en intercala

563
00:23:37,710 --> 00:23:40,150
Que ya existe, es cuando me dirá lo de

564
00:23:40,150 --> 00:23:42,029
¿Quieres sobreescribir patatín patatán?

565
00:23:42,029 --> 00:23:44,269
vamos a probarlo

566
00:23:44,269 --> 00:23:47,450
queremos copiar destino en

567
00:23:47,450 --> 00:23:49,230
le voy a volver a decir destino2

568
00:23:49,230 --> 00:23:49,890
que ya existe

569
00:23:49,890 --> 00:23:54,019
¿desea sobreescribirlo? pues si le digo que no

570
00:23:54,019 --> 00:23:56,680
pues ya está, ha terminado y no lo ha sobreescrito

571
00:23:56,680 --> 00:23:58,720
y si le digo que sí, pues lo habría sobreescrito

572
00:23:58,720 --> 00:24:00,220
aunque en este caso tendrían lo mismo ya

573
00:24:00,220 --> 00:24:04,470
pero bueno, pues nada

574
00:24:04,470 --> 00:24:05,710
queda ahí ese ejemplo

575
00:24:05,710 --> 00:24:08,869
para ilustrar estas dos clases

576
00:24:08,869 --> 00:24:10,990
que son las más básicas

577
00:24:10,990 --> 00:24:12,609
de ese paquete

578
00:24:12,609 --> 00:24:13,970
que mueven bytes

579
00:24:13,970 --> 00:24:16,170
con este read que hemos visto y con el write

580
00:24:16,170 --> 00:24:18,430
luego tiene nombre más métodos para hacer más cosillas

581
00:24:18,430 --> 00:24:19,230
y eso, pero bueno

582
00:24:19,230 --> 00:24:26,450
bueno, pues entonces

583
00:24:26,450 --> 00:24:28,609
quedémonos por ahora con estas cinco clases

584
00:24:28,609 --> 00:24:30,250
la clase file

585
00:24:30,250 --> 00:24:32,690
reader, writer, input string, output string

586
00:24:32,690 --> 00:24:34,569
con los ejemplos de uso que hemos visto

587
00:24:34,569 --> 00:24:36,690
para que sirven, como las podemos

588
00:24:36,690 --> 00:24:38,490
usar para algunas cosas básicas

589
00:24:38,490 --> 00:24:40,849
y ahora ya vamos a saltar

590
00:24:40,849 --> 00:24:43,069
a otras clases que nos pueden ser más útiles

591
00:24:43,069 --> 00:24:47,799
bueno, pues estas otras

592
00:24:47,799 --> 00:24:49,779
clases que vamos a ver tienen que ver con

593
00:24:49,779 --> 00:24:52,000
esto de aquí, serialización

594
00:24:52,000 --> 00:24:54,180
de objetos

595
00:24:54,180 --> 00:24:56,200
tiene que ver

596
00:24:56,200 --> 00:25:01,529
con este concepto

597
00:25:01,529 --> 00:25:03,890
vale, pues nosotros en nuestra aplicación

598
00:25:03,890 --> 00:25:05,549
en nuestras aplicaciones normalmente

599
00:25:05,549 --> 00:25:07,210
las variables pueden estar

600
00:25:07,210 --> 00:25:10,029
en variables primitivas, en numeritos enteros

601
00:25:10,029 --> 00:25:11,269
en char, en string

602
00:25:11,269 --> 00:25:13,430
pero muchísimas veces están

603
00:25:13,430 --> 00:25:14,750
la mayoría de veces están en objetos

604
00:25:14,750 --> 00:25:17,569
objeto alumno, objeto cliente

605
00:25:17,569 --> 00:25:18,930
en nuestras aplicaciones

606
00:25:18,930 --> 00:25:21,829
tienen de repente un montón de objetos alumno

607
00:25:21,829 --> 00:25:24,569
y la aplicación se cierra

608
00:25:24,569 --> 00:25:25,789
o se tiene que reiniciar

609
00:25:25,789 --> 00:25:27,630
y todos los alumnos que se han dado de alta

610
00:25:27,630 --> 00:25:30,670
se van a perder para que luego cuando la aplicación termine

611
00:25:30,670 --> 00:25:31,849
tenga yo que meterlas de nuevo

612
00:25:31,849 --> 00:25:34,549
hombre pues no, lo ideal es que todo eso

613
00:25:34,549 --> 00:25:36,049
que tenemos en nuestras colecciones

614
00:25:36,049 --> 00:25:37,769
en nuestros maps, en todo eso

615
00:25:37,769 --> 00:25:40,490
pueda ir fácilmente a algún sitio

616
00:25:40,490 --> 00:25:42,390
para que cuando la aplicación

617
00:25:42,390 --> 00:25:44,650
se arranca o se reinicia pues automáticamente

618
00:25:44,650 --> 00:25:45,470
vuelva otra vez

619
00:25:45,470 --> 00:25:48,509
es el funcionamiento ideal, que no tengamos

620
00:25:48,509 --> 00:25:50,269
que cada vez que arranca una aplicación meterle

621
00:25:50,269 --> 00:25:52,269
todos los datos. Si los datos

622
00:25:52,269 --> 00:25:54,289
son 30.000 usuarios, ¿los tenemos que meter

623
00:25:54,289 --> 00:25:55,029
cada vez? Pues no.

624
00:25:56,589 --> 00:25:58,069
Entonces, todo ese conjunto

625
00:25:58,069 --> 00:26:00,130
de datos que está en colecciones

626
00:26:00,130 --> 00:26:02,089
de objetos enormes, todo ese conjunto

627
00:26:02,089 --> 00:26:04,089
de datos, su sitio

628
00:26:04,089 --> 00:26:05,990
natural de alojarse, obviamente

629
00:26:05,990 --> 00:26:07,230
es una base de datos.

630
00:26:08,349 --> 00:26:09,950
Porque en una base de datos, además,

631
00:26:10,250 --> 00:26:12,109
podemos guardar algo tan importante

632
00:26:12,109 --> 00:26:14,309
como la estructura. Es decir,

633
00:26:14,410 --> 00:26:15,509
no solo el contenido,

634
00:26:16,329 --> 00:26:18,029
sino también una información

635
00:26:18,029 --> 00:26:20,029
sobre el contenido, la estructura. Es decir,

636
00:26:20,029 --> 00:26:22,029
tablas, yo tengo un alumno

637
00:26:22,029 --> 00:26:23,730
el alumno tiene NIF, nombre y nota

638
00:26:23,730 --> 00:26:26,450
pues hombre, ¿dónde va a estar

639
00:26:26,450 --> 00:26:28,089
mejor guardado que en una tabla

640
00:26:28,089 --> 00:26:29,869
que tiene también tres campos?

641
00:26:30,069 --> 00:26:31,769
NIF, nombre y nota, estupendo

642
00:26:31,769 --> 00:26:34,210
la misma estructura que tengo en la clase

643
00:26:34,210 --> 00:26:35,609
la misma la tengo en una tabla

644
00:26:35,609 --> 00:26:37,869
lo que está en las tres propiedades

645
00:26:37,869 --> 00:26:39,849
está en tres campos, o sea, el sitio natural

646
00:26:39,849 --> 00:26:42,049
para guardar objetos son las tablas

647
00:26:42,049 --> 00:26:42,910
de las bases de datos

648
00:26:42,910 --> 00:26:46,109
porque la estructura de propiedades es la estructura

649
00:26:46,109 --> 00:26:47,089
de campos, es lo mismo

650
00:26:47,089 --> 00:26:50,009
pero ahora aquí nos vamos a ver

651
00:26:50,009 --> 00:26:53,730
como guardar los objetos

652
00:26:53,730 --> 00:26:56,170
en bases de datos

653
00:26:56,170 --> 00:26:59,470
eso se englobaría todo bajo un único nombre

654
00:26:59,470 --> 00:27:01,430
que es el nombre de persistencia

655
00:27:01,430 --> 00:27:03,930
persistencia en el contexto nuestro de desarrollo

656
00:27:03,930 --> 00:27:06,230
tiene un único significado

657
00:27:06,230 --> 00:27:08,990
que es que los datos de mi aplicación

658
00:27:08,990 --> 00:27:12,289
estén permanentemente conectados a un soporte permanente

659
00:27:12,289 --> 00:27:14,450
de forma transparente para mí

660
00:27:14,450 --> 00:27:17,109
yo trabajo con los objetos

661
00:27:17,109 --> 00:27:19,650
y eso está ahí permanentemente conectado a una base de datos

662
00:27:19,650 --> 00:27:22,450
y así me tengo que despreocupar, desalvar, recuperar, etc

663
00:27:22,450 --> 00:27:24,789
eso es lo que se llama persistencia

664
00:27:24,789 --> 00:27:28,670
y todo eso exige unos frengos, unas clases

665
00:27:28,670 --> 00:27:30,750
que se encarguen de hacer todo eso

666
00:27:30,750 --> 00:27:32,970
todo eso es un módulo del año que viene

667
00:27:32,970 --> 00:27:35,869
nosotros ahora lo que vamos a hacer es

668
00:27:35,869 --> 00:27:39,710
hombre, para mí es algo, no quiero nada tan sofisticado

669
00:27:39,710 --> 00:27:41,569
yo tengo una aplicación con 30 alumnos

670
00:27:41,569 --> 00:27:45,490
cuando me acuesto por la noche yo quiero dejar el ordenador apagado

671
00:27:45,490 --> 00:27:48,950
y cuando lo arranco por la mañana quiero que mis 30 alumnos

672
00:27:48,950 --> 00:27:51,450
o mis 30 clientes sigan ahí en la aplicación

673
00:27:51,450 --> 00:27:53,210
para seguir operando con ellos, quiero eso

674
00:27:53,210 --> 00:27:55,230
simplemente, bueno pues

675
00:27:55,230 --> 00:27:57,329
en situaciones así, ni siquiera tenemos

676
00:27:57,329 --> 00:27:59,150
por qué habilitar un sistema gestor de base

677
00:27:59,150 --> 00:28:01,230
de datos y poner ahí la base de datos, tampoco

678
00:28:01,230 --> 00:28:03,250
hace falta, yo en

679
00:28:03,250 --> 00:28:05,230
un fichero, me llevo mis

680
00:28:05,230 --> 00:28:07,589
objetos y luego ahí los recupero

681
00:28:07,589 --> 00:28:09,130
pero como me los llevo, no son

682
00:28:09,130 --> 00:28:11,230
texto, son propiedades de un

683
00:28:11,230 --> 00:28:13,210
objeto, es algo más raro, no me los puedo llevar con

684
00:28:13,210 --> 00:28:15,509
un file writer, un file writer solo admite caracteres

685
00:28:15,509 --> 00:28:17,190
un objeto no es eso, no es una sucesión

686
00:28:17,190 --> 00:28:18,930
de caracteres, ¿cómo me los llevo?

687
00:28:19,450 --> 00:28:21,430
Bueno, pues para eso se habilitan

688
00:28:21,430 --> 00:28:23,329
unas clases muy sencillas de usar

689
00:28:23,329 --> 00:28:25,369
que hacen esto

690
00:28:25,369 --> 00:28:27,630
que decimos de llevar todo ese mogollón

691
00:28:27,630 --> 00:28:29,549
que hay dentro de un objeto, que hay de todo

692
00:28:29,549 --> 00:28:31,329
un nombre, un nif, todo ese mogollón

693
00:28:31,329 --> 00:28:32,750
llevarlo a un archivo

694
00:28:32,750 --> 00:28:34,990
y se le llama serializar

695
00:28:34,990 --> 00:28:37,349
porque todo ese mogollón de propiedades

696
00:28:37,349 --> 00:28:39,509
nif, nombre, nota, patatín

697
00:28:39,509 --> 00:28:41,490
como que se las pone en filitas

698
00:28:41,490 --> 00:28:43,609
se hace ahí una filita de bits

699
00:28:43,609 --> 00:28:45,730
y eso se le llama serializar

700
00:28:45,730 --> 00:28:47,490
lo convierto yo en una filita de bits

701
00:28:47,490 --> 00:28:48,990
y esa filita de bits va al fichero

702
00:28:48,990 --> 00:28:51,789
ese fichero cuando se abra

703
00:28:51,789 --> 00:28:54,109
no es que no se pueda abrir, ahí no se entiende nada

704
00:28:54,109 --> 00:28:55,630
porque esos son unos bits

705
00:28:55,630 --> 00:28:57,670
que serializan de una manera interna

706
00:28:57,670 --> 00:28:59,910
todo eso que está ahí, es que ahí es imposible abrirlo

707
00:28:59,910 --> 00:29:01,829
pero claro, para eso están

708
00:29:01,829 --> 00:29:03,730
las clases que deserializan

709
00:29:04,470 --> 00:29:05,950
yo ahora cojo ese fichero

710
00:29:05,950 --> 00:29:08,069
y cojo esa filita de bits

711
00:29:08,069 --> 00:29:09,470
y me la llevo a la aplicación Java

712
00:29:09,470 --> 00:29:11,289
la aplicación Java ya sí que lo puede entender

713
00:29:11,289 --> 00:29:13,750
¿vale? entonces la serialización

714
00:29:13,750 --> 00:29:15,970
lleva un fichero, ese fichero ya no se entiende ni papa

715
00:29:15,970 --> 00:29:17,890
y nadie lo podrá abrir, pero luego si

716
00:29:17,890 --> 00:29:20,009
desde otra aplicación hago la deserialización

717
00:29:20,009 --> 00:29:21,289
vuelve otra vez

718
00:29:21,289 --> 00:29:23,890
al objeto, y ese objeto

719
00:29:23,890 --> 00:29:24,910
yo puedo trabajar con él

720
00:29:24,910 --> 00:29:28,170
bueno, pues esas clases

721
00:29:28,170 --> 00:29:29,690
de serialización de objetos serían

722
00:29:29,690 --> 00:29:32,170
para serializar

723
00:29:32,170 --> 00:29:33,789
hacia el fichero, es decir

724
00:29:33,789 --> 00:29:35,069
llevar de objetos a fichero

725
00:29:35,069 --> 00:29:37,670
serían object

726
00:29:37,670 --> 00:29:40,029
output stream

727
00:29:40,029 --> 00:29:45,019
esto es lo que sería

728
00:29:45,019 --> 00:29:46,619
para escribir, ¿verdad?

729
00:29:47,039 --> 00:30:09,309
para escribir al archivo y para leer sería esta vale esto sería para serializar y esto para

730
00:30:10,569 --> 00:30:24,660
de serializar si es que ese verbo existiera que no existe bueno pues vamos a ver cómo

731
00:30:24,660 --> 00:30:34,799
podemos usarlas en una aplicación por ahí vale pues venga vamos a hacernos una aplicación

732
00:30:34,799 --> 00:30:42,599
vale, vamos a ver

733
00:30:42,599 --> 00:30:44,099
si pudiéramos coger aquí

734
00:30:44,099 --> 00:30:48,289
una que tuviera entidades

735
00:30:48,289 --> 00:30:50,369
main model, tiene alumno

736
00:30:50,369 --> 00:30:52,750
y luego tiene aquí unas operaciones

737
00:30:52,750 --> 00:30:53,549
que son

738
00:30:53,549 --> 00:30:56,369
insertar, mostrar datos

739
00:30:56,369 --> 00:30:57,210
de un alumno

740
00:30:57,210 --> 00:30:59,269
alumno tiene

741
00:30:59,269 --> 00:31:04,380
matrícula, lista de asignaturas

742
00:31:04,380 --> 00:31:06,099
vale

743
00:31:06,099 --> 00:31:07,859
pues vamos a echarle un vistazo a esta aplicación

744
00:31:07,859 --> 00:31:09,960
de ejemplo alumnos que tenemos aquí

745
00:31:09,960 --> 00:31:11,279
que es una con las que

746
00:31:11,279 --> 00:31:14,200
hemos trabajado en su momento para ver colecciones

747
00:31:14,200 --> 00:31:16,039
vale, esta aplicación

748
00:31:16,039 --> 00:31:17,319
que tenía, tiene

749
00:31:17,319 --> 00:31:19,640
la única entidad con la que trabajaba

750
00:31:19,640 --> 00:31:21,019
el alumno

751
00:31:21,019 --> 00:31:25,690
vale, pues el alumno

752
00:31:25,690 --> 00:31:27,630
se caracterizaba por su número de matrícula

753
00:31:27,630 --> 00:31:28,789
su nombre, su edad

754
00:31:28,789 --> 00:31:31,970
y un conjunto, una lista de asignaturas

755
00:31:31,970 --> 00:31:33,829
de las que está matriculado, se supone

756
00:31:33,829 --> 00:31:35,509
solamente el nombre en string

757
00:31:35,509 --> 00:31:36,329
solamente el nombre

758
00:31:36,329 --> 00:31:39,710
por eso se caracteriza el alumno

759
00:31:39,710 --> 00:31:41,589
vale, aquí tenía sus guides, sus sets, etc

760
00:31:41,589 --> 00:32:00,470
Y luego esta aplicación tiene unas funcionalidades, unas cosas que se puede hacer con esos alumnos que teníamos recogidas en esta clase de operaciones. Teníamos recogidas unas funcionalidades. Este proyecto está en la aula virtual, imagino.

761
00:32:00,470 --> 00:32:02,029
vale

762
00:32:02,029 --> 00:32:04,890
teníamos recogidas unas funcionalidades que eran

763
00:32:04,890 --> 00:32:06,809
los datos

764
00:32:06,809 --> 00:32:08,690
estaban en una lista de alumnos

765
00:32:08,690 --> 00:32:09,690
aquí estaban los datos

766
00:32:09,690 --> 00:32:11,329
ahí están los datos

767
00:32:11,329 --> 00:32:15,190
y ahora, ¿qué podíamos hacer con esos datos?

768
00:32:15,430 --> 00:32:16,470
que estaban en esa lista

769
00:32:16,470 --> 00:32:18,470
luego cuando la aplicación arranca

770
00:32:18,470 --> 00:32:20,609
eso está limpio

771
00:32:20,609 --> 00:32:23,150
cuando la aplicación arranca ahí no hay ningún alumno

772
00:32:23,150 --> 00:32:24,150
eso está limpio

773
00:32:24,150 --> 00:32:27,069
vale, pues ¿qué hacíamos aquí con esta

774
00:32:27,069 --> 00:32:29,029
con estos alumnos?

775
00:32:29,029 --> 00:32:51,230
Podíamos insertar un alumno. Vale, pues insertamos el alumno y ya está. Mostrar datos de un alumno dado su número de matrícula. Pues mostrábamos los datos, patatín. ¿Qué más cosas hacíamos? Matricular a un alumno de una asignatura. Pues esto hacíamos.

776
00:32:51,230 --> 00:32:54,309
¿qué más hacíamos? desmatricular a un alumno

777
00:32:54,309 --> 00:32:55,329
de una asignatura

778
00:32:55,329 --> 00:32:58,250
le quitábamos el string

779
00:32:58,250 --> 00:33:00,150
¿vale?

780
00:33:00,210 --> 00:33:01,470
eliminar a un alumno

781
00:33:01,470 --> 00:33:04,349
pues lo eliminábamos con el remove

782
00:33:04,349 --> 00:33:06,390
¿vale? alumno que tenía

783
00:33:06,390 --> 00:33:07,549
más asignaturas

784
00:33:07,549 --> 00:33:10,769
pues nada, aquí hacíamos el máximo

785
00:33:10,769 --> 00:33:12,049
para ver que alumno tenía más asignaturas

786
00:33:12,049 --> 00:33:14,230
al alumno mayor, pues lo mismo

787
00:33:14,230 --> 00:33:16,690
el número de alumnos

788
00:33:16,690 --> 00:33:17,750
matriculados

789
00:33:17,750 --> 00:33:19,450
pues

790
00:33:19,450 --> 00:33:22,529
matriculados en una asignatura

791
00:33:22,529 --> 00:33:24,210
en una, en esta

792
00:33:24,210 --> 00:33:26,369
y luego a ver

793
00:33:26,369 --> 00:33:28,549
si existe matrícula

794
00:33:28,549 --> 00:33:28,910
este

795
00:33:28,910 --> 00:33:32,089
si esta matrícula estaba

796
00:33:32,089 --> 00:33:32,650
en el

797
00:33:32,650 --> 00:33:34,750
en la lista

798
00:33:34,750 --> 00:33:38,289
¿vale? por eso hacíamos

799
00:33:38,289 --> 00:33:39,569
retune contains, bueno

800
00:33:39,569 --> 00:33:41,890
pues este era un proyecto que usamos

801
00:33:41,890 --> 00:33:43,869
en su momento para

802
00:33:43,869 --> 00:33:46,130
practicar con listas y ya está

803
00:33:46,130 --> 00:33:48,089
hacer remove, contains y poco más

804
00:33:48,089 --> 00:33:50,609
pero claro, en este momento dijimos

805
00:33:50,609 --> 00:33:52,470
a ver, los datos

806
00:33:52,470 --> 00:33:53,450
de la aplicación

807
00:33:53,450 --> 00:33:56,490
tienen que estar en memoria principal

808
00:33:56,490 --> 00:33:58,210
porque no los podemos tener en ningún soporte

809
00:33:58,210 --> 00:33:59,369
permanente porque no sabemos

810
00:33:59,369 --> 00:34:02,390
cuando la aplicación arrancaba, esta lista

811
00:34:02,390 --> 00:34:04,250
estaba vacía, y luego ya según

812
00:34:04,250 --> 00:34:06,549
la aplicación iba llamando a insertar alumno

813
00:34:06,549 --> 00:34:08,590
pues ya estaban apareciendo alumnos

814
00:34:08,590 --> 00:34:10,590
y luego ya podíamos eliminarlos

815
00:34:10,590 --> 00:34:12,570
de todo, cuando la aplicación

816
00:34:12,570 --> 00:34:14,369
se cierra, pues no hay

817
00:34:14,369 --> 00:34:16,150
ningún alumno, o sea, los alumnos

818
00:34:16,150 --> 00:34:17,570
desaparecen y se acabó

819
00:34:17,570 --> 00:34:39,690
Bueno, pues podríamos completar esta aplicación de tal manera que cuando la aplicación arranca, recoja los alumnos de un fichero de texto, si es que los hay, para partir ya con ellos y cuando la aplicación termine, que todos esos alumnos vayan a un fichero, por ejemplo.

820
00:34:39,690 --> 00:34:50,210
Y así, si nosotros apagamos la aplicación, apagamos el ordenador, no pasa nada cuando la aplicación arranque de nuevas, pues los alumnos seguirán estando exactamente los mismos.

821
00:34:52,829 --> 00:35:00,489
Entonces, como lo que tenemos que guardar son objetos, aquí no podemos hacer ni FileWriter ni nada, esto es un lío.

822
00:35:01,590 --> 00:35:04,369
Entonces tenemos que usar estas clases de serialización.

823
00:35:04,369 --> 00:35:06,429
Vale, pues por ejemplo

824
00:35:06,429 --> 00:35:07,610
Vamos a hacernos un método

825
00:35:07,610 --> 00:35:13,159
Se puede copiar un proyecto entero

826
00:35:13,159 --> 00:35:15,639
Si, si haces copy paste

827
00:35:15,639 --> 00:35:18,400
Copy luego paste

828
00:35:18,400 --> 00:35:19,500
Te lo copia con

829
00:35:19,500 --> 00:35:20,980
Pero si yo lo

830
00:35:20,980 --> 00:35:23,440
Hice el otro día, si, a ver

831
00:35:23,440 --> 00:35:26,420
Copias

832
00:35:26,420 --> 00:35:28,239
Y ahora yo pongo aquí paste

833
00:35:28,239 --> 00:35:29,820
Y me aparece aquí

834
00:35:29,820 --> 00:35:32,199
Otro con, me pone el 2 pero lo puedes cambiar de nombre

835
00:35:32,199 --> 00:35:35,530
Vale, pues venga

836
00:35:35,530 --> 00:35:40,389
vale, pues vamos a añadir un método

837
00:35:40,389 --> 00:35:42,489
que de nuevo

838
00:35:42,489 --> 00:35:44,130
puede ser interesante en este proyecto

839
00:35:44,130 --> 00:35:46,369
que es guardar datos en fichero

840
00:35:46,369 --> 00:35:47,610
guardar datos y ya está

841
00:35:47,610 --> 00:35:57,820
guardar datos

842
00:35:57,820 --> 00:36:00,739
y lo que le vamos a pasar es el nombre

843
00:36:00,739 --> 00:36:02,760
del fichero en el que

844
00:36:02,760 --> 00:36:03,659
queremos que se guarde

845
00:36:03,659 --> 00:36:15,369
bueno, pues cuando llamemos a este método

846
00:36:15,369 --> 00:36:17,449
toda esa lista

847
00:36:17,449 --> 00:36:18,210
va a ese fichero

848
00:36:18,210 --> 00:36:20,630
y ahí se queda preparada por si alguien quiere

849
00:36:20,630 --> 00:36:22,829
recuperarla en algún momento, toda esa lista

850
00:36:22,829 --> 00:36:23,690
de objetos alumna

851
00:36:23,690 --> 00:36:25,949
vale, pues entonces

852
00:36:25,949 --> 00:36:28,530
ahora lo que queremos es

853
00:36:28,530 --> 00:36:30,190
escribir

854
00:36:30,190 --> 00:36:32,949
escribir, recordad que tenéis que asociarlo a

855
00:36:32,949 --> 00:36:35,230
muevo de variables

856
00:36:35,230 --> 00:36:36,510
a fichero

857
00:36:36,510 --> 00:36:38,909
eso es escribir, operación de escritura

858
00:36:38,909 --> 00:36:40,190
operación de salida

859
00:36:40,190 --> 00:36:43,070
las clases que tengan output

860
00:36:43,070 --> 00:36:45,190
en su nombre, object, output string

861
00:36:45,190 --> 00:36:46,750
file output string

862
00:36:46,750 --> 00:36:47,769
o las que tengan writer

863
00:36:47,769 --> 00:36:50,789
las que tengan

864
00:36:50,789 --> 00:36:52,869
writer o output son las que hacen

865
00:36:52,869 --> 00:36:54,769
escritura, que es llevar

866
00:36:54,769 --> 00:36:56,269
de variables a fichero

867
00:36:56,269 --> 00:36:58,989
y las clases que tienen en su nombre

868
00:36:58,989 --> 00:37:00,849
input o reader son las que

869
00:37:00,849 --> 00:37:03,010
hacen lectura, que es de fichero

870
00:37:03,010 --> 00:37:04,989
a variables, en este caso

871
00:37:04,989 --> 00:37:06,050
queremos escritura

872
00:37:06,050 --> 00:37:08,889
de variables, de la lista en este caso

873
00:37:08,889 --> 00:37:10,829
al fichero, escritura

874
00:37:10,829 --> 00:37:12,710
pues entonces es object output string

875
00:37:12,710 --> 00:37:14,849
esta es la que nos

876
00:37:14,849 --> 00:37:17,170
interesa, hemos identificado

877
00:37:17,170 --> 00:37:18,869
que queremos serializar objetos

878
00:37:18,869 --> 00:37:20,429
llevarlos al fichero

879
00:37:20,429 --> 00:37:22,449
pues esta es la que nos interesa

880
00:37:22,449 --> 00:37:24,570
porque esta es la que nos vale para guardar objetos

881
00:37:24,570 --> 00:37:27,389
pues venga, la podemos instanciar

882
00:37:27,389 --> 00:37:29,349
y ahora

883
00:37:29,349 --> 00:37:30,989
la paso aquí debajo

884
00:37:30,989 --> 00:37:32,030
para que se vea bien

885
00:37:32,030 --> 00:37:34,710
pues nada, se instancia aquí con el

886
00:37:34,710 --> 00:37:40,239
constructor que sabemos que metemos

887
00:37:40,239 --> 00:37:40,679
dentro

888
00:37:40,679 --> 00:37:43,380
pero claro, el constructor

889
00:37:43,380 --> 00:37:44,800
¿qué necesita?

890
00:37:45,320 --> 00:37:47,239
pues el objeto de amputación es una clase

891
00:37:47,239 --> 00:37:48,980
más compleja, obviamente

892
00:37:48,980 --> 00:37:51,579
porque lo que tiene que hacer es meterse en el objeto

893
00:37:51,579 --> 00:37:53,179
empezar a romper las propiedades

894
00:37:53,179 --> 00:37:54,019
patatín patatán

895
00:37:54,019 --> 00:37:57,300
y en última instancia esta clase a quien acabará llamando

896
00:37:57,300 --> 00:37:59,579
a quien acabará llamando por debajo

897
00:37:59,579 --> 00:38:01,179
es a la file output string

898
00:38:01,179 --> 00:38:02,159
que hemos mencionado antes

899
00:38:02,159 --> 00:38:03,619
porque esa es la básica

900
00:38:03,619 --> 00:38:06,820
file output string es la que te lleva bits

901
00:38:06,820 --> 00:38:08,599
de variable a fichero

902
00:38:08,599 --> 00:38:11,539
pues el object output string está montada

903
00:38:11,539 --> 00:38:12,940
sobre la file output string

904
00:38:12,940 --> 00:38:15,420
cogiendo las variables, desmenuzándolas

905
00:38:15,420 --> 00:38:17,780
poniéndolas en fila, haciendo todo el desmadre que haga falta

906
00:38:17,780 --> 00:38:20,800
y en última instancia ya llamara a FileOutputStream

907
00:38:20,800 --> 00:38:22,340
para que FileOutputStream las lleve.

908
00:38:23,320 --> 00:38:25,699
Bueno, pues entonces el constructor necesita

909
00:38:25,699 --> 00:38:28,179
que le pasemos como parámetro

910
00:38:28,179 --> 00:38:31,380
el nombre del FileOutputStream,

911
00:38:31,920 --> 00:38:34,380
el objeto, perdón, el objeto FileOutputStream

912
00:38:34,380 --> 00:38:35,840
sobre el que queremos montarlo.

913
00:38:36,659 --> 00:38:39,059
¿Y sobre qué FileOutputStream queremos montarlo?

914
00:38:39,159 --> 00:38:40,940
Pues sobre uno que esté asociado a este, obviamente.

915
00:38:42,239 --> 00:38:44,199
Entonces aquí para ahorrarnos referencias,

916
00:38:44,340 --> 00:38:46,079
pues directamente le podemos pasar esto.

917
00:38:46,079 --> 00:38:51,010
file output stream y

918
00:38:51,010 --> 00:38:53,389
num fichero

919
00:38:53,389 --> 00:38:56,849
entonces le estamos diciendo

920
00:38:56,849 --> 00:38:58,610
al object output stream que todo

921
00:38:58,610 --> 00:39:00,530
eso que él va a desmenuzar ahí

922
00:39:00,530 --> 00:39:02,210
luego lo mande

923
00:39:02,210 --> 00:39:04,550
a través de este file output stream

924
00:39:04,550 --> 00:39:06,550
que este ya es el que manda los bits

925
00:39:06,550 --> 00:39:08,690
directamente, que lo mande

926
00:39:08,690 --> 00:39:10,630
a través de este que a su vez está asociado

927
00:39:10,630 --> 00:39:14,809
a este fichero, pues nada

928
00:39:14,809 --> 00:39:16,469
tendremos que importar las clases

929
00:39:16,469 --> 00:39:22,500
y propagar la excepción

930
00:39:22,500 --> 00:39:32,869
correspondiente, bueno

931
00:39:32,869 --> 00:39:33,670
pues el uso

932
00:39:33,670 --> 00:39:36,650
de esto en realidad es inmediato

933
00:39:36,650 --> 00:39:38,170
porque object.outputString

934
00:39:38,170 --> 00:39:39,530
lo único que te hace es

935
00:39:39,530 --> 00:39:41,530
le pasas un objeto y te lo manda

936
00:39:41,530 --> 00:39:42,610
y ya está

937
00:39:42,610 --> 00:39:44,750
tiene un método

938
00:39:44,750 --> 00:39:51,469
se puede usar para más cosas

939
00:39:51,469 --> 00:39:54,789
tú le pasas aquí un objeto

940
00:39:54,789 --> 00:39:55,630
una referencia

941
00:39:55,630 --> 00:39:58,389
y te lo serializa y te lo manda

942
00:39:58,389 --> 00:39:59,349
¿que quieres mandar muchos?

943
00:39:59,510 --> 00:40:01,630
pues tendrás que hacer un bucle para que te los mande todos

944
00:40:01,630 --> 00:40:04,449
aquí queremos mandar todos los que están en la lista

945
00:40:04,449 --> 00:40:06,489
pues entonces tendremos que

946
00:40:06,489 --> 00:40:08,010
meter aquí un for

947
00:40:08,010 --> 00:40:10,510
¿vale? para recorrer esta lista

948
00:40:10,510 --> 00:40:14,369
que se llama

949
00:40:14,369 --> 00:40:16,130
alumnos

950
00:40:16,130 --> 00:40:22,260
¿vale? pues

951
00:40:22,260 --> 00:40:24,159
para cada objeto

952
00:40:24,159 --> 00:40:26,139
alumno, para cada referencia

953
00:40:26,139 --> 00:40:28,760
que está en alumnos

954
00:40:28,760 --> 00:40:30,079
A es una copia

955
00:40:30,079 --> 00:40:31,820
de la referencia, pero como

956
00:40:31,820 --> 00:40:34,320
la copia de dirección de memoria va al mismo lado

957
00:40:34,320 --> 00:40:36,320
bueno, no os olvidéis de que

958
00:40:36,320 --> 00:40:36,840
el for each

959
00:40:36,840 --> 00:40:40,219
es una copia de la referencia, pero

960
00:40:40,219 --> 00:40:42,159
claro, apunta al mismo sitio

961
00:40:42,159 --> 00:40:44,800
Pues que queremos hacer con este objeto

962
00:40:44,800 --> 00:40:45,659
Ala, ya está

963
00:40:45,659 --> 00:40:48,219
Pues ya está

964
00:40:48,219 --> 00:40:50,239
Ya tenemos todos los objetos serializados

965
00:40:50,239 --> 00:40:52,780
Un chorizo ahí de bits que ni idea

966
00:40:52,780 --> 00:40:54,480
De como lo ha hecho, pero están ahí

967
00:40:54,480 --> 00:40:56,760
Entonces una vez

968
00:40:56,760 --> 00:40:58,980
Que uno ha terminado de guardarlos

969
00:40:58,980 --> 00:41:00,159
Todos, pues

970
00:41:00,159 --> 00:41:03,909
Lo cerraría ahí

971
00:41:03,909 --> 00:41:05,710
Vale

972
00:41:05,710 --> 00:41:12,380
Entonces vamos a probar desde nuestro main

973
00:41:12,380 --> 00:41:13,880
Que tendremos aquí uno de pruebas

974
00:41:13,880 --> 00:41:17,039
En el proyecto teníamos un main

975
00:41:17,039 --> 00:41:18,480
sí

976
00:41:18,480 --> 00:41:23,460
ejemplo alumnos

977
00:41:23,460 --> 00:41:25,079
que estaba

978
00:41:25,079 --> 00:41:31,139
aquí

979
00:41:31,139 --> 00:41:35,230
vale, pues en este teníamos un main

980
00:41:35,230 --> 00:41:36,809
para hacer pruebas

981
00:41:36,809 --> 00:41:39,190
teníamos un insertar alumno, vamos a

982
00:41:39,190 --> 00:41:41,230
dejarlo, va a insertar dos, este

983
00:41:41,230 --> 00:41:41,730
y este

984
00:41:41,730 --> 00:41:44,949
y luego teníamos aquí más pruebas

985
00:41:44,949 --> 00:41:47,710
para comprobar que el alumno existía

986
00:41:47,710 --> 00:41:49,409
matricular alumno

987
00:41:49,409 --> 00:41:51,429
bueno, un montón de pruebas

988
00:41:51,429 --> 00:41:53,010
de las funcionalidades que habíamos hecho

989
00:41:53,010 --> 00:41:57,000
aquí más cositas

990
00:41:57,000 --> 00:42:01,230
vale, vamos a dejar

991
00:42:01,230 --> 00:42:02,489
nuestro main ahora mismo

992
00:42:02,489 --> 00:42:06,840
con dos

993
00:42:06,840 --> 00:42:08,920
que inserte a dos, para tener dos

994
00:42:08,920 --> 00:42:10,559
y ahora

995
00:42:10,559 --> 00:42:12,760
pues vamos a guardar los datos, entonces esto

996
00:42:12,760 --> 00:42:14,599
claro, luego ya uno construye la aplicación

997
00:42:14,599 --> 00:42:16,119
para guardar el momento que quiera

998
00:42:16,119 --> 00:42:18,780
para si se ha dado la opción de salir

999
00:42:18,780 --> 00:42:19,840
opción salir, quieres

1000
00:42:19,840 --> 00:42:22,800
pues este main tendría un

1001
00:42:22,800 --> 00:42:24,659
este main podría

1002
00:42:24,659 --> 00:42:26,119
tener un menú, ¿no?

1003
00:42:26,199 --> 00:42:27,860
un menú insertar alumno, no sé qué

1004
00:42:27,860 --> 00:42:29,239
y en la opción de salir

1005
00:42:29,239 --> 00:42:31,880
en la opción de salir, cuando el usuario de salir

1006
00:42:31,880 --> 00:42:34,099
pues en ese momento se llamaría guardar datos

1007
00:42:34,099 --> 00:42:36,039
en la de salir para que se queden guardados

1008
00:42:36,039 --> 00:42:38,219
pero bueno, como no tenemos

1009
00:42:38,219 --> 00:42:40,139
aquí el menú, vamos a insertarlos y a guardarlos

1010
00:42:40,139 --> 00:42:42,159
y la aplicación terminará

1011
00:42:42,159 --> 00:42:44,400
y ya está, habrá insertado a los alumnos y los guardará

1012
00:42:44,400 --> 00:42:46,599
pues venga

1013
00:42:46,599 --> 00:42:48,360
guardamos

1014
00:42:48,360 --> 00:42:50,179
datos, ¿en qué fichero? pues vamos a

1015
00:42:50,179 --> 00:42:51,780
pasarle un fichero de nombre

1016
00:42:51,780 --> 00:42:53,780
alumnos

1017
00:42:53,780 --> 00:42:58,090
guardar datos y esto como tiene

1018
00:42:58,090 --> 00:42:59,469
una excepción, pues me lo dice

1019
00:42:59,469 --> 00:43:02,190
No me lo dice porque entonces

1020
00:43:02,190 --> 00:43:03,329
Lo he debido poner mal

1021
00:43:03,329 --> 00:43:05,889
Ah, opera, ah, claro

1022
00:43:05,889 --> 00:43:07,309
Que no estoy en el mismo sitio, claro

1023
00:43:07,309 --> 00:43:09,369
Estoy en otra clase

1024
00:43:09,369 --> 00:43:12,389
Operaciones, vale

1025
00:43:12,389 --> 00:43:14,610
Y ahora ya sí que me dirá

1026
00:43:14,610 --> 00:43:15,469
Lo de la excepción

1027
00:43:15,469 --> 00:43:19,739
Ay, throws

1028
00:43:19,739 --> 00:43:26,059
Vale, pues vamos a parar aquí

1029
00:43:26,059 --> 00:43:27,159
Vale, un momentito