1
00:00:00,110 --> 00:00:02,009
Segunda parte de ficheros

2
00:00:02,009 --> 00:00:03,470
Si habláis

3
00:00:03,470 --> 00:00:05,690
Me dais consentimiento para que se grabe

4
00:00:05,690 --> 00:00:06,750
¿Vale? Entonces

5
00:00:06,750 --> 00:00:08,750
Estamos viendo como leer

6
00:00:08,750 --> 00:00:10,789
Un archivo de texto ¿Vale?

7
00:00:10,849 --> 00:00:13,109
Entonces tengo mi file reader

8
00:00:13,109 --> 00:00:15,050
¿Vale? El hecho de que este reader por algún lado

9
00:00:15,050 --> 00:00:16,710
Quiere decir que estoy trabajando con

10
00:00:16,710 --> 00:00:19,530
Carácteres, con texto

11
00:00:19,530 --> 00:00:21,129
¿Vale? En no byte a byte

12
00:00:21,129 --> 00:00:22,510
Eh

13
00:00:22,510 --> 00:00:25,429
Puede utilizar un buffer reader

14
00:00:25,429 --> 00:00:27,149
Que obtiene dentro

15
00:00:27,149 --> 00:00:28,829
Que pilla como parámetro

16
00:00:28,829 --> 00:00:30,010
Un file reader

17
00:00:30,010 --> 00:00:32,530
Pues esto me crea un objeto

18
00:00:32,530 --> 00:00:34,450
BufferedReader

19
00:00:34,450 --> 00:00:37,030
Que puede hacer lo que se llama el ReadLine

20
00:00:37,030 --> 00:00:38,950
Y luego la idea de esta aquí

21
00:00:38,950 --> 00:00:41,689
Es que voy leyendo filas, filas, filas

22
00:00:41,689 --> 00:00:42,609
Líneas, líneas

23
00:00:42,609 --> 00:00:45,630
Cuando lea una línea que es null

24
00:00:45,630 --> 00:00:48,570
Porque ha llegado al final del fichero

25
00:00:48,570 --> 00:00:50,250
Pues entonces saldré de este while

26
00:00:50,250 --> 00:00:50,890
Y ya está

27
00:00:50,890 --> 00:00:54,789
Fijaos también que

28
00:00:54,789 --> 00:00:56,509
Si es null

29
00:00:56,509 --> 00:00:58,329
Cierro

30
00:00:58,329 --> 00:01:02,390
el canal de comunicación

31
00:01:02,390 --> 00:01:02,929
¿vale?

32
00:01:03,149 --> 00:01:05,909
la idea es que de vez en cuando

33
00:01:05,909 --> 00:01:07,689
cuando ya ha utilizado

34
00:01:07,689 --> 00:01:09,530
el acceso, el recurso

35
00:01:09,530 --> 00:01:10,629
al fichero y

36
00:01:10,629 --> 00:01:13,489
al canal de lectura

37
00:01:13,489 --> 00:01:16,349
pues al final lo vaya a cerrar

38
00:01:16,349 --> 00:01:16,890
¿vale?

39
00:01:17,269 --> 00:01:20,030
esto de aquí quiere decir que sustancialmente ahora el canal está cerrado

40
00:01:20,030 --> 00:01:21,390
no puedo volver a leer de ahí

41
00:01:21,390 --> 00:01:23,230
¿vale? es como todo

42
00:01:23,230 --> 00:01:25,709
en Java cuando utilizamos

43
00:01:25,709 --> 00:01:27,510
un recurso lo mantenemos abierto

44
00:01:27,510 --> 00:01:32,689
lo mantenemos activo hasta que lo necesitemos cuando ya no se necesita pues se hace esta

45
00:01:32,689 --> 00:01:40,269
operación de aquí para evitar que java mantenga allí en memoria algunas informaciones necesarias

46
00:01:40,269 --> 00:02:03,530
para poder leer cuando luego sé que no voy a leer nunca jamás sí y aparte de eso está en un

47
00:02:03,530 --> 00:02:12,430
final y porque tanto que explote como no explote lo cierro vale entonces cómo se escribe en un

48
00:02:12,430 --> 00:02:16,990
un fichero? Pues vamos a ver como se crea un fichero, en este caso por ejemplo utilizamos

49
00:02:16,990 --> 00:02:24,990
la clase FileWriter para poder escribir en un file y la clase PrintWriter, vale? La clase

50
00:02:24,990 --> 00:02:30,770
PrintWriter debería sonaros de algo, pero bueno, seguramente no. Entonces me creo un

51
00:02:30,770 --> 00:02:36,150
FileWriter, un PrintWriter, creo un nuevo FileWriter con la ruta del archivo que yo

52
00:02:36,150 --> 00:02:43,469
quiero vale fijaos que tengo la opción de utilizar un constructor que pilla dos

53
00:02:43,469 --> 00:02:51,030
parámetros o sea el nombre del archivo coma un booleano y este booleano me dice

54
00:02:51,030 --> 00:02:58,050
si al escribir en este fichero quiero que se añada al final del fichero lo que

55
00:02:58,050 --> 00:03:04,110
voy a escribir o se sobreescriba lo que ya está me explico si esto es true

56
00:03:04,110 --> 00:03:05,750
Cuando yo escribo

57
00:03:05,750 --> 00:03:07,229
Él lo pone en el fichero

58
00:03:07,229 --> 00:03:08,669
Y si escribo otra cosa

59
00:03:08,669 --> 00:03:10,729
Lo pone detrás de lo que ya he escrito

60
00:03:10,729 --> 00:03:12,969
Hace lo que se llama la función de append

61
00:03:12,969 --> 00:03:14,849
Lo añade al final

62
00:03:14,849 --> 00:03:16,550
Si yo en vez hago

63
00:03:16,550 --> 00:03:19,409
El archivo, false

64
00:03:19,409 --> 00:03:21,430
Quiere decir que cada vez que escribo

65
00:03:21,430 --> 00:03:23,449
Machaca lo que ya estaba en el fichero

66
00:03:23,449 --> 00:03:24,830
Y lo vuelve a escribir por encima

67
00:03:24,830 --> 00:03:27,569
¿Vale? Eso depende de lo que yo quiera hacer

68
00:03:27,569 --> 00:03:28,830
¿Si?

69
00:03:30,009 --> 00:03:31,270
Este file writer

70
00:03:31,270 --> 00:03:33,210
Se pasa como parámetro a un nuevo objeto

71
00:03:33,210 --> 00:03:34,030
Print writer

72
00:03:34,030 --> 00:03:36,069
vale, el printwriter

73
00:03:36,069 --> 00:03:38,009
lo que me permite hacer es un método

74
00:03:38,009 --> 00:03:39,509
que no habéis visto nunca que se llama

75
00:03:39,509 --> 00:03:40,430
println

76
00:03:40,430 --> 00:03:44,210
vale, pues si vosotros vais a mirar

77
00:03:44,210 --> 00:03:46,169
que es system.out

78
00:03:46,169 --> 00:03:48,469
pues veréis que system.out

79
00:03:48,469 --> 00:03:49,710
es un printwriter

80
00:03:49,710 --> 00:03:52,129
vale, solo que en vez

81
00:03:52,129 --> 00:03:53,729
de su canal estar

82
00:03:53,729 --> 00:03:55,909
pegado a un

83
00:03:55,909 --> 00:03:57,830
fichero

84
00:03:57,830 --> 00:04:00,129
lo que está pegado es a la salida

85
00:04:00,129 --> 00:04:02,009
estándar de mi proceso, o sea

86
00:04:02,009 --> 00:04:04,050
La consola, entonces lo que escribo

87
00:04:04,050 --> 00:04:05,569
Allí llega a la consola

88
00:04:05,569 --> 00:04:07,310
Del eclipse

89
00:04:07,310 --> 00:04:08,849
¿Dudas?

90
00:04:10,490 --> 00:04:12,030
Vale, entonces

91
00:04:12,030 --> 00:04:13,669
Esto

92
00:04:13,669 --> 00:04:15,569
Básicamente

93
00:04:15,569 --> 00:04:17,810
Es lo que aprendemos a hacer

94
00:04:17,810 --> 00:04:19,810
Repito que esto es con archivo de texto

95
00:04:19,810 --> 00:04:21,290
Que quizás es la parte más fácil

96
00:04:21,290 --> 00:04:24,009
Porque estoy usando letras

97
00:04:24,009 --> 00:04:25,769
Estoy usando carácter, estoy usando frases

98
00:04:25,769 --> 00:04:28,029
Y entonces es algo que entendemos

99
00:04:28,029 --> 00:04:30,069
Bastante, luego está la parte

100
00:04:30,069 --> 00:04:30,569
Más

101
00:04:30,569 --> 00:04:32,750
A bajo nivel

102
00:04:32,750 --> 00:04:35,170
Que es hacer lo mismo, pero byte a byte

103
00:04:35,170 --> 00:04:37,250
Y la parte más a alto nivel

104
00:04:37,250 --> 00:04:39,170
Que es hacer lo mismo, pero en vez de escribir

105
00:04:39,170 --> 00:04:40,990
Un texto, escribo un objeto

106
00:04:40,990 --> 00:04:45,980
Ejemplo

107
00:04:45,980 --> 00:04:47,740
De programita que copia

108
00:04:47,740 --> 00:04:49,100
Un fichero, vale

109
00:04:49,100 --> 00:04:51,100
Este programita de aquí

110
00:04:51,100 --> 00:04:53,319
Lo que hace es leer

111
00:04:53,319 --> 00:04:55,060
Desde un fichero

112
00:04:55,060 --> 00:04:57,139
Y escribir en otro fichero

113
00:04:57,139 --> 00:04:58,220
Distinto, vale

114
00:04:58,220 --> 00:05:00,779
Entonces se crea un input stream

115
00:05:00,779 --> 00:05:02,959
Sobre el fichero

116
00:05:02,959 --> 00:05:04,699
original, de donde va a leer

117
00:05:04,699 --> 00:05:06,759
y lo mete

118
00:05:06,759 --> 00:05:08,199
en un buffer de input stream

119
00:05:08,199 --> 00:05:10,600
fijaos, esto no estoy haciendo copia

120
00:05:10,600 --> 00:05:12,639
carácter a carácter, no estoy usando texto

121
00:05:12,639 --> 00:05:14,560
estoy usando binario, vale, no está

122
00:05:14,560 --> 00:05:16,680
el buffer reader o el

123
00:05:16,680 --> 00:05:18,740
file reader, estoy usando file input

124
00:05:18,740 --> 00:05:20,720
stream y buffer input stream

125
00:05:20,720 --> 00:05:22,439
entonces estos no tienen

126
00:05:22,439 --> 00:05:24,740
opción de leer una línea o escribir

127
00:05:24,740 --> 00:05:26,920
una línea, bueno, escribir no porque es todo un input

128
00:05:26,920 --> 00:05:28,480
pero, esto es

129
00:05:28,480 --> 00:05:30,819
leo, ni siquiera un carácter, leo

130
00:05:30,819 --> 00:05:32,339
byte a byte

131
00:05:32,339 --> 00:05:36,519
Y a este buffer de input stream

132
00:05:36,519 --> 00:05:38,019
Le paso el

133
00:05:38,019 --> 00:05:40,779
File input stream que he creado antes

134
00:05:40,779 --> 00:05:45,279
Por otro lado creo un file output stream

135
00:05:45,279 --> 00:05:46,720
Y este file output stream

136
00:05:46,720 --> 00:05:48,860
Tiene una ruta distinta

137
00:05:48,860 --> 00:05:50,379
Del otro, es otro fichero

138
00:05:50,379 --> 00:05:52,620
Este es el fichero origen.txt

139
00:05:52,620 --> 00:05:53,680
Este es el fichero

140
00:05:53,680 --> 00:05:55,620
Destino.txt

141
00:05:55,620 --> 00:06:00,300
¿Se crea o lo tienes que crear tú y decirte la ruta?

142
00:06:02,459 --> 00:06:03,060
Técnicamente

143
00:06:03,060 --> 00:06:04,699
Debería ser

144
00:06:04,699 --> 00:06:05,860
Para esto

145
00:06:05,860 --> 00:06:08,899
Deberías comprobarlo

146
00:06:08,899 --> 00:06:10,639
Deberías crear un objeto file

147
00:06:10,639 --> 00:06:12,319
Verificar que existe

148
00:06:12,319 --> 00:06:13,980
Si no existe, crearlo tú

149
00:06:13,980 --> 00:06:14,980
Y seguir adelante

150
00:06:14,980 --> 00:06:15,860
Aún así

151
00:06:15,860 --> 00:06:19,939
Salvo excepciones raras

152
00:06:19,939 --> 00:06:21,600
Alguna vez que explota

153
00:06:21,600 --> 00:06:23,800
Pues normalmente si no existe lo creas

154
00:06:23,800 --> 00:06:25,160
Cuando vas a escribir

155
00:06:25,160 --> 00:06:35,459
vale, pero hay métodos que a lo mejor no lo hacen, entonces depende, depende también de qué clase usas,

156
00:06:35,579 --> 00:06:40,019
a lo mejor si usas directamente float autostream no te lo hace, pero si usas el buffer de autostream si,

157
00:06:40,019 --> 00:06:48,899
eso hay que leer y mirar en el API que tienes que hacer, aún así para ser buen programador pues yo me crearía un fichero,

158
00:06:48,899 --> 00:06:50,339
Comprobaría si está, si no está

159
00:06:50,339 --> 00:06:54,839
Creo un buffer

160
00:06:54,839 --> 00:06:55,959
De output stream

161
00:06:55,959 --> 00:06:57,740
Al que le paso esto aquí

162
00:06:57,740 --> 00:06:59,139
¿Por qué estos dos pasos?

163
00:06:59,199 --> 00:07:02,279
¿No se podría hacer directamente con file input stream y file output stream?

164
00:07:02,459 --> 00:07:04,139
Sí, se podría hacer

165
00:07:04,139 --> 00:07:06,420
Lo que pasa es que a lo mejor tendría

166
00:07:06,420 --> 00:07:09,019
Menos funcionalidades

167
00:07:09,019 --> 00:07:10,660
Que esto sí me ofrece

168
00:07:10,660 --> 00:07:11,560
¿Vale?

169
00:07:11,699 --> 00:07:13,220
A lo mejor estos son más suficientes

170
00:07:13,220 --> 00:07:15,720
Porque en vez de escribir directamente en disco

171
00:07:15,720 --> 00:07:17,959
Lo que hacen es escribir en una memoria temporal

172
00:07:17,959 --> 00:07:20,199
Y cuando yo le digo, venga, ahora escríbelo

173
00:07:20,199 --> 00:07:21,120
Pues escriben de golpe

174
00:07:21,120 --> 00:07:25,180
Que es más rápido que escribir carácter a carácter

175
00:07:25,180 --> 00:07:25,360
¿Sí?

176
00:07:26,279 --> 00:07:28,879
Entonces, aquí no puedo utilizar string

177
00:07:28,879 --> 00:07:29,959
No puedo utilizar carácter

178
00:07:29,959 --> 00:07:31,720
Tengo que utilizar array de bytes

179
00:07:31,720 --> 00:07:36,639
Me creo un array con 1000 bytes

180
00:07:36,639 --> 00:07:37,040
¿Vale?

181
00:07:37,139 --> 00:07:39,519
Esto quiere decir que sustancialmente lo que voy a hacer es

182
00:07:39,519 --> 00:07:41,920
Leer 1000 bytes, escribir 1000 bytes

183
00:07:41,920 --> 00:07:43,579
Leer 1000 bytes, escribir 1000 bytes

184
00:07:43,579 --> 00:07:46,199
Hasta llegar a un momento en que he leído todo

185
00:07:46,199 --> 00:07:47,120
Y acabo

186
00:07:47,120 --> 00:07:53,600
Entonces, aquí no utilizo readline como utilizaba en el otro

187
00:07:53,600 --> 00:07:55,339
Sino utilizo la función read

188
00:07:55,339 --> 00:07:59,459
Que lo que brilla es un array de bytes

189
00:07:59,459 --> 00:08:04,459
Y me lo rellena con los bytes que ha leído

190
00:08:04,459 --> 00:08:06,459
Al final de esta operación

191
00:08:06,459 --> 00:08:11,459
Me devuelve un entero que me dice cuántos bytes ha podido leer

192
00:08:11,459 --> 00:08:14,279
Si he leído 3 bytes

193
00:08:14,279 --> 00:08:17,240
Aquí tendré siempre un array de 1000 bytes

194
00:08:17,240 --> 00:08:20,019
Pero solo los primeros 3 son interesantes

195
00:08:20,019 --> 00:08:27,800
A este punto, mientras lo que he leído es mayor que 0

196
00:08:27,800 --> 00:08:29,920
O sea, si he conseguido leer algún byte

197
00:08:29,920 --> 00:08:35,519
Lo que voy a hacer es escribir con la operación write

198
00:08:35,519 --> 00:08:37,379
Que pilla 3 parámetros

199
00:08:37,379 --> 00:08:40,519
Pilla un array de bytes

200
00:08:40,519 --> 00:08:43,980
Desde donde empiezo a escribir

201
00:08:43,980 --> 00:08:46,720
Y hasta donde empieza a escribir

202
00:08:46,720 --> 00:08:47,919
Eh, hasta donde

203
00:08:47,919 --> 00:08:49,299
Acabo, escribo

204
00:08:49,299 --> 00:08:50,340
¿Si?

205
00:08:51,379 --> 00:08:53,759
Entonces, esto de aquí me está diciendo, pilla la RAID

206
00:08:53,759 --> 00:08:56,440
Empieza desde el principio, siempre desde 0

207
00:08:56,440 --> 00:08:58,360
Y si es 1000

208
00:08:58,360 --> 00:09:00,840
Porque he leído 1000, pues me escribe la RAID entera

209
00:09:00,840 --> 00:09:02,519
Si en vez

210
00:09:02,519 --> 00:09:04,200
He leído solo 4 bytes

211
00:09:04,200 --> 00:09:06,720
Porque al final he leído los últimos 4 bytes

212
00:09:06,720 --> 00:09:08,320
Y no me reían al 1000, pues me escribirá

213
00:09:08,320 --> 00:09:09,360
Solo del 0 al 4

214
00:09:09,360 --> 00:09:11,820
Fijaos que

215
00:09:11,820 --> 00:09:13,340
Esto es excluido

216
00:09:13,340 --> 00:09:16,360
Esta posición de aquí es como la primera

217
00:09:16,360 --> 00:09:17,179
Que no se pone

218
00:09:17,179 --> 00:09:19,980
Si yo leo 1000, aquí va 1000

219
00:09:19,980 --> 00:09:22,779
Y la posición 1000 no está en este array

220
00:09:22,779 --> 00:09:24,860
La última posición es la 999

221
00:09:24,860 --> 00:09:26,799
Pero 1000 es excluido

222
00:09:26,799 --> 00:09:28,179
¿Sí?

223
00:09:29,220 --> 00:09:29,740
¿Dudas?

224
00:09:31,440 --> 00:09:32,340
Y ya está

225
00:09:32,340 --> 00:09:34,139
Cuando he acabado esta cosa de aquí

226
00:09:34,139 --> 00:09:36,820
Cierro el canal de entrada

227
00:09:36,820 --> 00:09:38,220
Cierro el canal de salida

228
00:09:38,220 --> 00:09:39,620
He acabado mi copia

229
00:09:39,620 --> 00:09:42,139
Antes tenía un fichero, ahora tengo dos

230
00:09:42,139 --> 00:09:43,580
Si todo esto funciona

231
00:09:43,580 --> 00:09:45,940
¿Dudas?

232
00:09:46,480 --> 00:09:48,480
Y tened en cuenta que este programita

233
00:09:48,480 --> 00:09:50,019
Funciona con cualquier tipo de fichero

234
00:09:50,019 --> 00:09:51,200
Me da igual que sea de texto

235
00:09:51,200 --> 00:09:54,039
De un fichero de

236
00:09:54,039 --> 00:09:56,240
Ejecutable

237
00:09:56,240 --> 00:09:58,279
Un fichero de cualquier cosa

238
00:09:58,279 --> 00:10:00,059
Pues este de aquí copia

239
00:10:00,059 --> 00:10:01,639
Byte por byte

240
00:10:01,639 --> 00:10:04,360
Entonces me da igual, copia los ceros y los unos

241
00:10:04,360 --> 00:10:06,480
¿Dudas?

242
00:10:09,620 --> 00:10:10,179
Vale

243
00:10:10,179 --> 00:10:12,960
Entonces vamos ahora

244
00:10:12,960 --> 00:10:16,679
a empezar a hablar de otro tema

245
00:10:16,679 --> 00:10:20,620
que es, vale, muy bien, he visto como se trabaja

246
00:10:20,620 --> 00:10:24,700
con los textos y he hecho un ejemplito de como se

247
00:10:24,700 --> 00:10:28,659
trabaja con los bytes, vale, fenomenal, más o menos

248
00:10:28,659 --> 00:10:32,820
eso es fácil de entender, vamos a ver la parte un poquito más compleja y por otro

249
00:10:32,820 --> 00:10:36,539
lado más útil, vale, que son los objetos, nosotros todo esto lo estamos

250
00:10:36,539 --> 00:10:40,620
enfocando a la persistencia de objetos, yo quiero que me echo mi escuela y cuando

251
00:10:40,620 --> 00:10:42,840
apago, pues mi escuela se queda allí

252
00:10:42,840 --> 00:10:44,399
lista para que mañana

253
00:10:44,399 --> 00:10:46,379
la encienda otra vez, pues tengo todos mis alumnos

254
00:10:46,379 --> 00:10:48,100
que he tardado una tarde

255
00:10:48,100 --> 00:10:49,759
en meterlos en el sistema

256
00:10:49,759 --> 00:10:51,480
entonces

257
00:10:51,480 --> 00:10:54,580
el punto es

258
00:10:54,580 --> 00:10:56,879
si yo tengo un objeto, lo importante

259
00:10:56,879 --> 00:10:57,659
del objeto

260
00:10:57,659 --> 00:11:00,620
son los atributos

261
00:11:00,620 --> 00:11:02,919
lo que define el estado

262
00:11:02,919 --> 00:11:04,919
de un objeto son los valores

263
00:11:04,919 --> 00:11:05,840
del atributo

264
00:11:05,840 --> 00:11:08,720
¿tenéis dudas?

265
00:11:08,720 --> 00:11:16,960
Vale, entonces

266
00:11:16,960 --> 00:11:18,580
Mi idea es

267
00:11:18,580 --> 00:11:21,879
La parte de, o sea, la clase está definida

268
00:11:21,879 --> 00:11:23,559
El comportamiento del objeto

269
00:11:23,559 --> 00:11:24,820
Ya está definido en su clase

270
00:11:24,820 --> 00:11:26,639
Entonces los métodos que puedo utilizar, etc

271
00:11:26,639 --> 00:11:29,580
Lo que tengo, lo que quiero guardar

272
00:11:29,580 --> 00:11:31,240
O sea, esa parte en un cierto sentido

273
00:11:31,240 --> 00:11:33,519
El código lo tengo ya guardado porque está en un fichero

274
00:11:33,519 --> 00:11:35,100
¿Vale? En un fichero .class

275
00:11:35,100 --> 00:11:37,379
Pues lo que necesito es

276
00:11:37,379 --> 00:11:39,440
Guardar los valores concretos

277
00:11:39,440 --> 00:11:41,299
De un objeto

278
00:11:41,299 --> 00:11:42,600
¿Vale? Entonces

279
00:11:42,600 --> 00:11:46,559
¿Cómo puedo guardar los atributos de un objeto?

280
00:11:47,039 --> 00:11:50,460
Una primera aproximación es hacer ficheros de textos

281
00:11:50,460 --> 00:11:51,059
¿Qué quiere decir?

282
00:11:51,860 --> 00:11:53,460
Tengo un archivo por clase

283
00:11:53,460 --> 00:11:58,700
Por ejemplo, alumnos.txt tendrá dentro todos los alumnos

284
00:11:58,700 --> 00:12:01,919
Materias.txt tendrá todas las materias, etc.

285
00:12:02,919 --> 00:12:05,440
Y tengo una línea por objeto

286
00:12:05,440 --> 00:12:07,240
Cada objeto tiene su línea

287
00:12:07,240 --> 00:12:11,740
Y dentro de cada línea tengo una cadena de caracteres

288
00:12:11,740 --> 00:12:13,580
Que pone cada atributo

289
00:12:13,580 --> 00:12:14,980
Los valores de los atributos

290
00:12:14,980 --> 00:12:17,500
No hay que decir nombre igual a

291
00:12:17,500 --> 00:12:18,080
Pago

292
00:12:18,080 --> 00:12:20,679
Aquí lo que pone es simplemente pago

293
00:12:20,679 --> 00:12:22,799
Yo sé que el primero es el nombre

294
00:12:22,799 --> 00:12:24,679
El segundo es el número

295
00:12:24,679 --> 00:12:26,139
El tercero es, no lo sé

296
00:12:26,139 --> 00:12:28,659
Y

297
00:12:28,659 --> 00:12:30,500
Estos valores

298
00:12:30,500 --> 00:12:33,039
Estarán separados

299
00:12:33,039 --> 00:12:34,039
Por un cierto

300
00:12:34,039 --> 00:12:36,679
Carácter

301
00:12:36,679 --> 00:12:38,679
Aquí por ejemplo uso dos puntos

302
00:12:38,679 --> 00:12:39,220
A lo mejor

303
00:12:39,220 --> 00:12:43,259
No me hace falta un separador final

304
00:12:43,259 --> 00:12:45,620
Porque hemos dicho que cada objeto está en una línea

305
00:12:45,620 --> 00:12:48,000
Entonces yo le doy a la línea y esto ya sé que es un objeto

306
00:12:48,000 --> 00:12:50,500
Si quisiera poner todo en la misma línea

307
00:12:50,500 --> 00:12:54,879
Pues debería tener un separador que separa los valores de los atributos

308
00:12:54,879 --> 00:12:57,700
Y un separador que separa un objeto de otro

309
00:12:57,700 --> 00:12:58,639
¿Vale?

310
00:12:59,059 --> 00:13:01,299
Está claro que esto puede causar problemas

311
00:13:01,299 --> 00:13:04,519
Si yo mi nombre lo pongo como

312
00:13:04,519 --> 00:13:08,539
Sara dos puntos cocodrilo

313
00:13:08,539 --> 00:13:10,759
Pues este dos puntos

314
00:13:10,759 --> 00:13:12,279
Él lo interpretará como un separador

315
00:13:12,279 --> 00:13:14,600
¿Sí?

316
00:13:15,240 --> 00:13:16,320
Y entonces, cuidado

317
00:13:16,320 --> 00:13:17,299
Pero, bueno

318
00:13:17,299 --> 00:13:19,639
Eso es otro tipo de problema

319
00:13:19,639 --> 00:13:21,820
Esta es una forma de hacerlo

320
00:13:21,820 --> 00:13:24,019
Se puede hacer con programas

321
00:13:24,019 --> 00:13:26,779
Y con objetos muy sencillos

322
00:13:26,779 --> 00:13:28,220
Esto puede ser una solución

323
00:13:28,220 --> 00:13:29,039
¿Vale?

324
00:13:29,759 --> 00:13:32,399
¿Cuáles problemas surgen

325
00:13:32,399 --> 00:13:33,620
Con este tipo de solución?

326
00:13:34,279 --> 00:13:36,019
Primero, si el dato no es un string

327
00:13:36,019 --> 00:13:37,700
Si no es un string

328
00:13:37,700 --> 00:13:40,659
Ya lo tengo que convertir

329
00:13:40,659 --> 00:13:41,259
¿Vale?

330
00:13:41,559 --> 00:13:44,259
Durante el proceso de materialización

331
00:13:44,259 --> 00:13:46,740
Y desmaterialización del objeto

332
00:13:46,740 --> 00:13:48,440
O sea, cuando lo guardo

333
00:13:48,440 --> 00:13:49,899
Y cuando lo vuelvo a crear

334
00:13:49,899 --> 00:13:51,840
Pues si no tengo

335
00:13:51,840 --> 00:13:54,679
Un string, pero tengo un entero

336
00:13:54,679 --> 00:13:56,539
Tengo un booleano, tengo otra cosa

337
00:13:56,539 --> 00:13:58,500
Pues tengo que ver como

338
00:13:58,500 --> 00:14:00,720
Transformo esto

339
00:14:00,720 --> 00:14:03,139
En el correspondiente

340
00:14:03,139 --> 00:14:06,559
Formato textual

341
00:14:06,559 --> 00:14:08,779
Hacer como un pseudo toString

342
00:14:08,779 --> 00:14:09,620
De cada uno de estos

343
00:14:09,620 --> 00:14:12,600
Y cuando lo materializo, cuando vuelvo

344
00:14:12,600 --> 00:14:14,820
A guardarlo, pues tendré que interpretar

345
00:14:14,820 --> 00:14:16,179
Que está escrito falso

346
00:14:16,179 --> 00:14:18,080
No es la string falso

347
00:14:18,080 --> 00:14:19,799
Es un booleano que vale false

348
00:14:19,799 --> 00:14:22,080
Que esto 22 no es

349
00:14:22,080 --> 00:14:24,120
El carácter 2 seguido del carácter 2

350
00:14:24,120 --> 00:14:25,960
Sino que es el número 22, es un int

351
00:14:25,960 --> 00:14:28,480
Entonces tendré que hacer todo el proceso inverso

352
00:14:28,480 --> 00:14:28,639
¿Sí?

353
00:14:29,179 --> 00:14:31,399
Y el otro problema que tenemos allí es

354
00:14:31,399 --> 00:14:34,179
¿Qué ocurre con las referencias a otro objeto?

355
00:14:34,720 --> 00:14:35,539
Aquí tengo una lista

356
00:14:35,539 --> 00:14:45,460
Vale, tengo mi alumno que tiene string, tiene nota, tiene bovedad

357
00:14:45,460 --> 00:14:48,399
Y luego tiene una red de notas

358
00:14:48,399 --> 00:14:54,320
Luego tiene, qué sé yo, un objeto dirección

359
00:14:54,320 --> 00:14:59,919
Que es otro objeto que tiene dentro calle, número y no sé qué

360
00:14:59,919 --> 00:15:04,639
Pues, ¿cómo hago esta referencia a este otro objeto?

361
00:15:05,539 --> 00:15:09,539
No es fácil, ¿vale?

362
00:15:10,519 --> 00:15:15,159
Imaginaos, dos alumnos, son hermanos, viven en la misma dirección

363
00:15:15,159 --> 00:15:20,399
En mi sistema, el primer alumno apunta a un objeto de dirección

364
00:15:20,399 --> 00:15:23,539
Y el segundo alumno apunta al mismo objeto de dirección

365
00:15:23,539 --> 00:15:26,100
Ahora lo voy a escribir de esta forma

366
00:15:26,100 --> 00:15:30,620
Vale, el primero es alumno 1, su edad

367
00:15:30,620 --> 00:15:32,220
Y la dirección, ¿cómo lo hago?

368
00:15:32,220 --> 00:15:35,879
Escribo allí la dirección entera

369
00:15:35,879 --> 00:15:37,980
Pongamos que escribo la dirección entera

370
00:15:37,980 --> 00:15:40,259
Hago como, como he hecho con alumno

371
00:15:40,259 --> 00:15:41,480
Hago lo mismo con direcciones

372
00:15:41,480 --> 00:15:43,759
Le escribo allí tres campos

373
00:15:43,759 --> 00:15:48,860
Que son la calle, el número y el código postal

374
00:15:48,860 --> 00:15:51,340
Ahora, a su hermano hago lo mismo

375
00:15:51,340 --> 00:15:53,799
Cuando los voy a recargar

376
00:15:53,799 --> 00:15:57,840
¿Cómo hago a saber que estos dos objetos

377
00:15:57,840 --> 00:16:00,460
Que vuelvo a materializar, estas dos direcciones

378
00:16:00,460 --> 00:16:01,759
En realidad son la misma?

379
00:16:02,220 --> 00:16:03,779
Se complica la cosa

380
00:16:03,779 --> 00:16:08,700
Sí, pero lo debes comprobar

381
00:16:08,700 --> 00:16:10,419
Con todo lo que existe ya

382
00:16:10,419 --> 00:16:12,059
Ver si existe ya

383
00:16:12,059 --> 00:16:14,019
No es trivial

384
00:16:14,019 --> 00:16:15,340
¿Vale?

385
00:16:15,980 --> 00:16:17,679
Además en el ejemplo que he hecho yo

386
00:16:17,679 --> 00:16:19,700
No estaría mal hecho

387
00:16:19,700 --> 00:16:23,279
Podría haber gente que vive en la misma calle

388
00:16:23,279 --> 00:16:24,039
Cosa por el estilo

389
00:16:24,039 --> 00:16:27,360
Y no sabe si son dos objetos distintos

390
00:16:27,360 --> 00:16:27,960
O un objeto solo

391
00:16:27,960 --> 00:16:29,919
Se complica, ¿vale?

392
00:16:29,919 --> 00:16:33,919
Porque cuando trabajamos con referencias es un poquito más complejo

393
00:16:33,919 --> 00:16:36,779
Entonces, ¿qué soluciones hay por aquí?

394
00:16:37,279 --> 00:16:40,500
Pues, la serialización RAW, ¿vale?

395
00:16:40,539 --> 00:16:46,059
Que es la serialización, lo que intentaremos hacer nosotros después, ¿vale?

396
00:16:47,039 --> 00:16:49,659
Hay serialización textual, ¿vale?

397
00:16:49,840 --> 00:16:54,799
O sea, que hay algunas librerías, como por ejemplo XStream

398
00:16:54,799 --> 00:16:59,620
Que lo que hace es guardarte el objeto en formato textual

399
00:16:59,620 --> 00:17:02,179
Pero usando, por ejemplo, bicheros.xml

400
00:17:02,179 --> 00:17:06,799
Entonces te crea, no una cosa sencilla

401
00:17:06,799 --> 00:17:10,480
Sino un xml donde te marcará que esta dirección

402
00:17:10,480 --> 00:17:12,680
Tiene un determinado identificador

403
00:17:12,680 --> 00:17:17,019
Que será el mismo identificador del objeto de su hermano

404
00:17:17,019 --> 00:17:22,579
Entonces allí tú puedes saber, gracias a las etiquetas xml añadidas

405
00:17:22,579 --> 00:17:24,920
Que estos son efectivamente el mismo objeto

406
00:17:24,920 --> 00:17:27,880
Y cuando lo vas a reconstruir, uno lo crearás la primera vez

407
00:17:27,880 --> 00:17:29,759
Y el segundo ya sabes que está ya creado

408
00:17:29,759 --> 00:17:31,579
Y vas a apuntar al mismo objeto

409
00:17:31,579 --> 00:17:32,480
¿Si?

410
00:17:33,000 --> 00:17:36,059
Este es un poquito más avanzado

411
00:17:36,059 --> 00:17:37,880
Y si no, usar un software

412
00:17:37,880 --> 00:17:39,779
Que tenga un ORM

413
00:17:39,779 --> 00:17:41,079
Más SGB

414
00:17:41,079 --> 00:17:42,799
O sea, una base de datos

415
00:17:42,799 --> 00:17:46,019
Una base de datos

416
00:17:46,019 --> 00:17:47,720
Junto con un

417
00:17:47,720 --> 00:17:50,000
Object Relational Mapping

418
00:17:50,000 --> 00:17:51,539
O sea, un

419
00:17:51,539 --> 00:17:53,220
Mecanismo que me diga

420
00:17:53,220 --> 00:17:54,920
Cuando tienes un objeto con esta forma

421
00:17:54,920 --> 00:17:57,480
Se relaciona a un sistema

422
00:17:57,480 --> 00:17:59,039
Relacional con esta cosa

423
00:17:59,039 --> 00:18:01,400
Se mapea a la tabla relacional

424
00:18:01,400 --> 00:18:02,279
De esta forma

425
00:18:02,279 --> 00:18:04,160
Entonces él en automático

426
00:18:04,160 --> 00:18:07,200
Me materializa y me desmaterializa

427
00:18:07,200 --> 00:18:09,480
Las cosas sin que sea yo

428
00:18:09,480 --> 00:18:10,859
El que mete las manos allí

429
00:18:10,859 --> 00:18:13,700
Y al máximo le doy algunas indicaciones

430
00:18:13,700 --> 00:18:15,539
Iniciales de cómo tiene que hacer las cosas

431
00:18:15,539 --> 00:18:17,380
Y una vez que lo sabe, pues lo hace

432
00:18:17,380 --> 00:18:18,299
¿Sí?

433
00:18:18,680 --> 00:18:21,480
Y esto es, digamos, desde más sencillo

434
00:18:22,059 --> 00:18:23,779
Hasta más complejo

435
00:18:23,779 --> 00:18:24,059
¿Sí?

436
00:18:25,119 --> 00:18:26,880
A nivel de implementación

437
00:18:26,880 --> 00:18:28,400
A nivel de gestión

438
00:18:28,400 --> 00:18:31,279
Está claro que esto, una vez implementado

439
00:18:31,279 --> 00:18:32,599
El último

440
00:18:32,599 --> 00:18:34,259
El ORM más

441
00:18:34,259 --> 00:18:36,779
Base de datos

442
00:18:36,779 --> 00:18:39,259
Una vez que está implementado toda la interfaz

443
00:18:39,259 --> 00:18:41,460
Todo el sistema

444
00:18:41,460 --> 00:18:43,240
Pues lo uso

445
00:18:43,240 --> 00:18:44,579
Más fácilmente

446
00:18:44,579 --> 00:18:46,579
Más potente que este de aquí

447
00:18:46,579 --> 00:18:49,460
Este me da más problemas a mi de programación

448
00:18:49,460 --> 00:18:51,220
Porque soy yo, al fin y al cabo

449
00:18:51,220 --> 00:18:53,380
El que tiene que hacer todo lo que después

450
00:18:53,380 --> 00:18:55,319
Haría un segundo el ORM

451
00:18:55,319 --> 00:18:56,440
¿Sí?

452
00:18:56,880 --> 00:18:59,420
Entonces, son estas cosas de segundo

453
00:18:59,420 --> 00:19:01,500
Vale, entonces

454
00:19:01,500 --> 00:19:03,940
¿Cómo hago la serialización?

455
00:19:04,900 --> 00:19:05,880
Se pueden

456
00:19:05,880 --> 00:19:08,019
Escribir en un fichero

457
00:19:08,019 --> 00:19:09,539
Solo los objetos

458
00:19:09,539 --> 00:19:11,019
Serializables

459
00:19:11,019 --> 00:19:14,220
Un objeto serializable

460
00:19:14,220 --> 00:19:15,960
Es el que implementa

461
00:19:15,960 --> 00:19:17,920
La interfaz serializable

462
00:19:17,920 --> 00:19:19,420
Que tiene

463
00:19:19,420 --> 00:19:20,279
Nada

464
00:19:20,279 --> 00:19:23,480
Tú le escribes

465
00:19:23,480 --> 00:19:26,380
Implemente serializable

466
00:19:26,380 --> 00:19:28,059
Y ya es serializable

467
00:19:28,059 --> 00:19:30,599
Listo

468
00:19:30,599 --> 00:19:31,779
¿Sí?

469
00:19:32,019 --> 00:19:33,619
Esa es la cosa buena

470
00:19:33,619 --> 00:19:37,279
Ahora, para que sea serializable

471
00:19:37,279 --> 00:19:39,140
Sus atributos

472
00:19:39,140 --> 00:19:40,079
Tienen que ser

473
00:19:40,079 --> 00:19:41,940
O tipos simples

474
00:19:41,940 --> 00:19:44,839
O otros objetos que también

475
00:19:44,839 --> 00:19:45,940
Son serializables

476
00:19:45,940 --> 00:19:49,039
Si alguno de los objetos que uso dentro

477
00:19:49,039 --> 00:19:50,599
No es serializable

478
00:19:50,599 --> 00:19:53,140
O yo se me olvida ponerle implementos serializables

479
00:19:53,140 --> 00:19:54,059
Pues me va a decir

480
00:19:54,059 --> 00:19:55,519
Esto no se puede guardar

481
00:19:55,519 --> 00:19:58,839
Porque hay una parte que no es escribible en un fichero

482
00:19:58,839 --> 00:19:59,799
¿Qué es lo que hace?

483
00:20:02,519 --> 00:20:03,039
Magia

484
00:20:03,039 --> 00:20:11,819
Serializable es, sustancialmente, en un cierto sentido, marcar que este objeto se puede escribir byte por byte

485
00:20:11,819 --> 00:20:16,099
Y, sustancialmente, lo que va a hacer es ponerte un método dentro

486
00:20:16,099 --> 00:20:22,339
Que es un método para poder irte a leer tu objeto y leerlo byte por byte

487
00:20:22,339 --> 00:20:26,160
Entonces, luego, cuando tú lo tienes que guardar, lo pillas byte por byte y lo escribes

488
00:20:26,160 --> 00:20:27,819
Y cuando tienes que sacar otra vez

489
00:20:27,819 --> 00:20:29,440
Lo lees byte por byte

490
00:20:29,440 --> 00:20:30,859
¿Vale?

491
00:20:31,779 --> 00:20:33,940
Solo que, por ejemplo, en el API

492
00:20:33,940 --> 00:20:37,279
Muchos objetos son serializables

493
00:20:37,279 --> 00:20:38,660
Pero hay algunos objetos

494
00:20:38,660 --> 00:20:40,019
Que no son serializables

495
00:20:40,019 --> 00:20:42,359
Esos objetos ni se pueden escribir en fichero

496
00:20:42,359 --> 00:20:43,779
Ni se pueden mandar

497
00:20:43,779 --> 00:20:45,920
Por ejemplo

498
00:20:45,920 --> 00:20:47,319
Por sockets

499
00:20:47,319 --> 00:20:49,240
A otras aplicaciones

500
00:20:49,240 --> 00:20:51,519
Entonces, a lo mejor eso

501
00:20:51,519 --> 00:20:53,880
Me condiciona también

502
00:20:53,880 --> 00:20:55,039
A la hora de elegir

503
00:20:55,039 --> 00:20:57,819
Que clases utilizar, que colecciones utilizar

504
00:20:57,819 --> 00:20:58,500
O cosas por el estilo

505
00:20:58,500 --> 00:21:01,380
De saber si las tengo que escribir en un fichero

506
00:21:01,380 --> 00:21:03,720
Pues elegiré una colección que también sea real

507
00:21:03,720 --> 00:21:05,140
La tengo que ir a comprobar

508
00:21:05,140 --> 00:21:07,619
O si me la estoy haciendo yo la implementación

509
00:21:07,619 --> 00:21:09,460
Pues todo lo que estoy utilizando tendrá que ser

510
00:21:09,460 --> 00:21:11,339
Las clases que me creo tendrán que ser

511
00:21:11,339 --> 00:21:12,859
Serializable, porque si no

512
00:21:12,859 --> 00:21:13,940
No le puedo

513
00:21:13,940 --> 00:21:16,740
No le puedo guardar, ¿vale?

514
00:21:17,700 --> 00:21:19,660
Entonces, ¿cómo se escriben objetos

515
00:21:19,660 --> 00:21:20,980
En disco? ¿vale?

516
00:21:21,279 --> 00:21:23,779
O sea, materializar y desmaterializar

517
00:21:23,779 --> 00:21:25,680
Pues existe una clase

518
00:21:25,680 --> 00:21:27,859
Que es la object output stream

519
00:21:27,859 --> 00:21:29,779
¿Vale? El output stream

520
00:21:29,779 --> 00:21:31,039
De objetos

521
00:21:31,039 --> 00:21:34,200
¿Vale? Que, sustantivamente, cuando lo creas

522
00:21:34,200 --> 00:21:35,400
Dentro le pones

523
00:21:35,400 --> 00:21:36,920
Un file output stream

524
00:21:36,920 --> 00:21:38,599
De un fichero

525
00:21:38,599 --> 00:21:41,079
Entonces, esto

526
00:21:41,079 --> 00:21:44,140
La object output stream tiene un método

527
00:21:44,140 --> 00:21:46,000
De escribirme un objeto

528
00:21:46,000 --> 00:21:47,500
Tú le pasas un objeto

529
00:21:47,500 --> 00:21:48,420
Y él lo escribe

530
00:21:48,420 --> 00:21:52,500
Siempre y cuando este objeto sea un objeto serializable

531
00:21:52,500 --> 00:21:59,079
Y con os.writeObject

532
00:21:59,079 --> 00:22:03,660
Este es el método que se usa

533
00:22:03,660 --> 00:22:05,539
De un objeto serializable

534
00:22:05,539 --> 00:22:06,960
Y luego lo cierro

535
00:22:06,960 --> 00:22:09,240
Esto me escribe, ya está

536
00:22:09,240 --> 00:22:15,339
Para leer, pues tengo un object input stream

537
00:22:15,339 --> 00:22:19,079
Al que le pongo dentro un file input stream

538
00:22:19,079 --> 00:22:19,980
De un fichero

539
00:22:19,980 --> 00:22:22,440
Y sustancialmente para leerlo

540
00:22:22,440 --> 00:22:24,420
Tengo la función, leo un objeto

541
00:22:24,420 --> 00:22:26,460
Vale, tened en cuenta que esto

542
00:22:26,460 --> 00:22:27,680
Normalmente funciona

543
00:22:27,680 --> 00:22:30,440
Para iniciar o acabar

544
00:22:30,440 --> 00:22:32,660
O sea, los programas no pueden

545
00:22:32,660 --> 00:22:35,059
Constantemente estar trabajando con ficheros

546
00:22:35,059 --> 00:22:36,819
Los ficheros son lentos

547
00:22:36,819 --> 00:22:38,980
Aquí hago una modificación y la esquivo en el fichero

548
00:22:38,980 --> 00:22:41,059
La otra modificación, la leo en el fichero

549
00:22:41,059 --> 00:22:42,740
Pues, yo trabajo

550
00:22:42,740 --> 00:22:44,079
Con los objetos

551
00:22:44,079 --> 00:22:46,839
En memoria normal, lo que hemos hecho hasta ahora

552
00:22:46,839 --> 00:22:48,980
Esto será un botón

553
00:22:48,980 --> 00:22:50,960
Guardar o un botón importar

554
00:22:50,960 --> 00:22:52,539
Que yo pincho al principio

555
00:22:52,539 --> 00:22:55,279
Para que importe todos los datos que están guardados

556
00:22:55,279 --> 00:22:57,779
Y guardar al final de mi operación

557
00:22:57,779 --> 00:22:59,519
Cuando voy a apagar la cosa

558
00:22:59,519 --> 00:23:01,279
Pues antes de cerrar todo

559
00:23:01,279 --> 00:23:03,440
Pues guardo

560
00:23:03,440 --> 00:23:03,759
¿Sí?

561
00:23:08,579 --> 00:23:09,740
Leo un objeto

562
00:23:09,740 --> 00:23:11,299
Si este objeto no es null

563
00:23:11,299 --> 00:23:13,299
¿Vale? Entonces lo proceso

564
00:23:13,299 --> 00:23:14,960
Hago lo que sea allí

565
00:23:14,960 --> 00:23:17,380
Para poder leer todos los objetos

566
00:23:17,380 --> 00:23:19,299
Que están allí, cuando leeré el último

567
00:23:19,299 --> 00:23:21,480
Pues o explota con un end of file

568
00:23:21,480 --> 00:23:23,579
O explota dándome un o igual a 0

569
00:23:23,579 --> 00:23:25,039
Entonces salgo, pues eso ya

570
00:23:25,039 --> 00:23:27,180
Haremos pruebas y veremos un poco que pasa

571
00:23:27,180 --> 00:23:27,880
¿Sí?

572
00:23:29,019 --> 00:23:31,559
También se suele utilizar la serialización para transmitir objetos

573
00:23:31,559 --> 00:23:32,559
Por una red, ¿vale?

574
00:23:32,680 --> 00:23:35,880
Los sockets, repito que algunos de vosotros se lo verán antes o después

575
00:23:35,880 --> 00:23:37,200
En ambos casos

576
00:23:37,200 --> 00:23:39,119
La Java Desktop Machine gestiona el formato

577
00:23:39,119 --> 00:23:41,539
De los datos de objetos o objetos serializados

578
00:23:41,539 --> 00:23:43,019
O sea que aquí yo estoy perdiendo

579
00:23:43,019 --> 00:23:45,259
¿Cómo se guardan dentro estos objetos?

580
00:23:45,700 --> 00:23:46,460
No tengo ni idea

581
00:23:46,460 --> 00:23:49,579
Que decide como guardar los varios

582
00:23:49,579 --> 00:23:51,599
Atributos, compactarlos

583
00:23:51,599 --> 00:23:53,700
Ponerles separadores, poner lo que sea

584
00:23:53,700 --> 00:23:55,420
Me da igual, porque tanto yo

585
00:23:55,420 --> 00:23:58,240
Lo que escribo, luego lo leeré

586
00:23:58,240 --> 00:23:59,319
Con este método de aquí

587
00:23:59,319 --> 00:24:01,839
Y entonces son métodos

588
00:24:01,839 --> 00:24:03,680
Digamos duales

589
00:24:03,680 --> 00:24:05,279
Bien, funciona

590
00:24:05,279 --> 00:24:08,059
Nota y consejo

591
00:24:08,059 --> 00:24:09,619
Aquí estamos viendo

592
00:24:09,619 --> 00:24:12,099
Parejas de input y output

593
00:24:12,099 --> 00:24:14,279
¿Vale? Desde input stream a output stream

594
00:24:14,279 --> 00:24:16,259
File input stream, file output stream

595
00:24:16,259 --> 00:24:18,420
FileReader o FileWriter

596
00:24:18,420 --> 00:24:21,460
ObjectAutoStream o InputStream

597
00:24:21,460 --> 00:24:24,059
Intentad en la medida de lo posible

598
00:24:24,059 --> 00:24:26,480
Utilizar siempre las mismas parejas

599
00:24:26,480 --> 00:24:30,720
No escribáis con ObjectAutoStream

600
00:24:30,720 --> 00:24:33,680
Y luego leéis con un FileReader

601
00:24:33,680 --> 00:24:36,140
Porque os buscáis problemas

602
00:24:36,140 --> 00:24:37,980
¿Sí?

603
00:24:39,559 --> 00:24:40,480
¿Dudas?

604
00:24:43,009 --> 00:24:46,470
Pero la selección no es tan bonita como parece

605
00:24:46,470 --> 00:24:48,809
Hay problemas con la serialización

606
00:24:48,809 --> 00:24:49,309
¿Vale?

607
00:24:49,950 --> 00:24:52,329
La clase Object-AutoStreamer

608
00:24:52,329 --> 00:24:54,049
No funciona bien del todo, ¿cuándo?

609
00:24:54,950 --> 00:24:55,650
Primero

610
00:24:55,650 --> 00:24:57,809
Intentamos reutilizar la misma

611
00:24:57,809 --> 00:24:59,589
Referencia para

612
00:24:59,589 --> 00:25:02,009
Serializar objetos diferentes

613
00:25:02,009 --> 00:25:03,890
Incluso utilizando

614
00:25:03,890 --> 00:25:05,329
Setters para un mismo objeto

615
00:25:05,329 --> 00:25:08,009
O sea, esto funciona cuando yo tengo

616
00:25:08,009 --> 00:25:09,529
Mi persona P

617
00:25:09,529 --> 00:25:11,769
Que le he puesto una persona y digo

618
00:25:11,769 --> 00:25:13,690
¿Me la escribes a esa persona? Sí, fenomenal

619
00:25:13,690 --> 00:25:15,710
Ahora, si yo he escrito la persona P

620
00:25:15,710 --> 00:25:18,109
Ahora cambio la persona P

621
00:25:18,109 --> 00:25:19,829
Le cambio el nombre, lo que sea

622
00:25:19,829 --> 00:25:21,509
Y digo, me la vuelves a escribir

623
00:25:21,509 --> 00:25:23,309
Eso le molesta

624
00:25:23,309 --> 00:25:26,690
Hasta si yo tengo persona P

625
00:25:26,690 --> 00:25:28,829
Y le digo new persona

626
00:25:28,829 --> 00:25:31,230
O sea, estoy usando la misma referencia

627
00:25:31,230 --> 00:25:33,269
Pero a un nuevo objeto

628
00:25:33,269 --> 00:25:34,970
Pues eso le puede molestar

629
00:25:34,970 --> 00:25:36,990
Por cómo está hecho dentro

630
00:25:36,990 --> 00:25:38,230
La serialización

631
00:25:38,230 --> 00:25:40,210
Entonces cuidado con eso

632
00:25:40,210 --> 00:25:45,250
También, cuando yo guardo en un fichero

633
00:25:45,250 --> 00:25:47,970
Él en automático crea una cabecera

634
00:25:47,970 --> 00:25:48,710
¿Vale?

635
00:25:48,809 --> 00:25:51,150
Crea una parte de datos que me dice

636
00:25:51,150 --> 00:25:53,630
Más o menos lo que me voy a encontrar en este fichero

637
00:25:53,630 --> 00:25:54,289
¿Vale?

638
00:25:55,029 --> 00:25:57,190
Ahora, si yo, por ejemplo

639
00:25:57,190 --> 00:25:59,109
Añado objetos personas

640
00:25:59,109 --> 00:26:00,490
A un fichero, ¿vale?

641
00:26:00,509 --> 00:26:02,970
Luego lo cierro, me voy a hacer otras cosas

642
00:26:02,970 --> 00:26:05,950
Y después de un rato, abro el mismo fichero

643
00:26:05,950 --> 00:26:08,210
E intento ponerle al final

644
00:26:08,210 --> 00:26:09,569
Otras personas

645
00:26:09,569 --> 00:26:11,329
Explota

646
00:26:11,329 --> 00:26:14,009
Porque la segunda vez

647
00:26:14,009 --> 00:26:15,490
Que voy a añadir personas

648
00:26:15,490 --> 00:26:17,769
Intenta poner otra vez

649
00:26:17,769 --> 00:26:18,890
Una cabecera allí

650
00:26:18,890 --> 00:26:20,930
Entonces en vez de tener una cabecera

651
00:26:20,930 --> 00:26:23,609
Y luego los datos, tengo cabecera, un poco de datos

652
00:26:23,609 --> 00:26:25,349
Otra cabecera y otros datos

653
00:26:25,349 --> 00:26:26,670
Y esto le lía

654
00:26:26,670 --> 00:26:27,789
Y explota

655
00:26:27,789 --> 00:26:29,589
¿Sí?

656
00:26:30,069 --> 00:26:32,809
Entonces, para poder utilizar estas cosas

657
00:26:32,809 --> 00:26:34,470
Tengo que saber

658
00:26:34,470 --> 00:26:35,589
Qué estoy haciendo

659
00:26:35,589 --> 00:26:37,190
Y hacerlo bien

660
00:26:37,190 --> 00:26:38,890
¿Sí?

661
00:26:39,490 --> 00:26:41,710
Y por esas razones

662
00:26:41,710 --> 00:26:44,509
Utilizar los ficheros a veces es un poco

663
00:26:44,509 --> 00:26:46,970
Complejo

664
00:26:46,970 --> 00:26:48,710
Es un poco ineficiente

665
00:26:48,710 --> 00:26:50,609
Y entonces se usan otros métodos

666
00:26:50,609 --> 00:26:51,369
Para ver el sistema

667
00:26:51,369 --> 00:26:52,210
¿Sí?

668
00:26:53,789 --> 00:26:56,069
¿Trucos para solucionar estos problemas?

669
00:26:56,569 --> 00:26:58,589
Es que siempre escriba de golpe

670
00:26:58,589 --> 00:27:02,529
Yo pillo los ficheros

671
00:27:02,529 --> 00:27:03,970
Los objetos

672
00:27:03,970 --> 00:27:05,430
Escribo todos los objetos

673
00:27:05,430 --> 00:27:07,269
Y dejo allí el fichero

674
00:27:07,269 --> 00:27:07,690
Ya está

675
00:27:07,690 --> 00:27:11,390
Si llega un momento en que tengo que escribir algo más

676
00:27:11,390 --> 00:27:12,990
Lo que debería hacer es

677
00:27:12,990 --> 00:27:14,369
Me leo el fichero

678
00:27:14,369 --> 00:27:16,890
Sacando todos los objetos que están allí

679
00:27:16,890 --> 00:27:18,769
Y luego me creo otro objeto

680
00:27:18,769 --> 00:27:20,650
O el mismo objeto, lo borro

681
00:27:20,650 --> 00:27:22,730
Y vuelvo, el mismo file, perdón

682
00:27:22,730 --> 00:27:24,410
O un nuevo file

683
00:27:24,410 --> 00:27:27,069
Y vuelvo a reescribir lo que estaba antes

684
00:27:27,069 --> 00:27:28,730
Más las cosas nuevas, de golpe

685
00:27:28,730 --> 00:27:30,970
Otra opción

686
00:27:30,970 --> 00:27:33,750
Empaqueto todos los objetos

687
00:27:33,750 --> 00:27:35,369
En una colección

688
00:27:35,369 --> 00:27:37,509
Pongo todo en un array

689
00:27:37,509 --> 00:27:39,450
Y cuando voy a escribir

690
00:27:39,450 --> 00:27:40,250
Escribo el array

691
00:27:40,250 --> 00:27:43,069
Entonces cuando me lo voy a cargar

692
00:27:43,069 --> 00:27:45,329
No cargo una sola persona

693
00:27:45,329 --> 00:27:46,690
Mas cargo un array de personas

694
00:27:46,690 --> 00:27:49,109
Lo cargo entero, ahora tengo todas las personas

695
00:27:49,109 --> 00:27:51,609
Hago lo que tengo que hacer, le añado las cosas así

696
00:27:51,609 --> 00:27:52,589
Y cuando voy a escribir

697
00:27:52,589 --> 00:27:54,789
Borro lo que está dentro y vuelvo a escribir

698
00:27:54,789 --> 00:27:56,230
El array en bloque

699
00:27:56,230 --> 00:27:58,589
O...

700
00:27:58,589 --> 00:28:00,130
La shmap o lo que sea

701
00:28:00,130 --> 00:28:01,549
¿Si?

702
00:28:02,309 --> 00:28:03,789
Teniendo en cuenta que, repito

703
00:28:03,789 --> 00:28:06,890
Estas operaciones son costosas

704
00:28:06,890 --> 00:28:08,970
Trabajar con el disco duro es lento

705
00:28:08,970 --> 00:28:11,690
Entonces no es una cosa que debería estar constantemente haciendo

706
00:28:11,690 --> 00:28:12,869
Cambio algo, lo escribo en Word

707
00:28:12,869 --> 00:28:15,230
De hecho, nuestros programas no lo hacen

708
00:28:15,230 --> 00:28:16,789
Vosotros escribís en Word

709
00:28:16,789 --> 00:28:18,730
No es que cada vez que tecleáis algo

710
00:28:18,730 --> 00:28:20,890
Lo escriben en el fichero directamente

711
00:28:20,890 --> 00:28:24,349
Espera que vosotros le deis a guardar

712
00:28:24,349 --> 00:28:25,390
Para que escriba

713
00:28:25,390 --> 00:28:26,089
¿Sí?

714
00:28:26,569 --> 00:28:28,369
A lo mejor, si el sistema está en idle

715
00:28:28,369 --> 00:28:29,849
Algunos sistemas avanzados

716
00:28:29,849 --> 00:28:32,049
Escriben lo que estáis haciendo

717
00:28:32,049 --> 00:28:33,369
En un fichero temporal

718
00:28:33,369 --> 00:28:35,349
Que si tú le das a guardar

719
00:28:35,349 --> 00:28:36,750
Copian eso en Word

720
00:28:36,750 --> 00:28:38,069
Y si tú no le das a guardar

721
00:28:38,069 --> 00:28:40,109
Pues te lo dejan allí por si acaso te has equivocado

722
00:28:40,109 --> 00:28:40,769
Y se ha ido la luz

723
00:28:40,769 --> 00:28:43,309
Pero bueno

724
00:28:43,309 --> 00:28:46,470
Tiene un coste

725
00:28:46,470 --> 00:28:47,369
Entonces

726
00:28:47,369 --> 00:28:50,069
La última parte de esta

727
00:28:50,069 --> 00:28:51,589
De esta

728
00:28:51,589 --> 00:28:53,970
¿Cómo se llama? De esta presentación

729
00:28:53,970 --> 00:28:56,930
Son una serie de códigos

730
00:28:56,930 --> 00:28:58,829
Para hacer varias cosas

731
00:28:58,829 --> 00:29:00,069
¿Vale? Como por ejemplo

732
00:29:00,069 --> 00:29:02,089
Esto es un escribir

733
00:29:02,089 --> 00:29:03,670
Texto en un fichero

734
00:29:03,670 --> 00:29:05,549
¿Vale? Entonces os viene aquí

735
00:29:05,549 --> 00:29:07,630
Como se hace, luego está

736
00:29:07,630 --> 00:29:09,069
Leer un fichero

737
00:29:09,069 --> 00:29:11,789
Pues aquí viene un ejemplo

738
00:29:11,789 --> 00:29:14,990
Escritura en ficheros binarios

739
00:29:14,990 --> 00:29:17,670
Es lectura

740
00:29:17,670 --> 00:29:19,250
En ficheros binarios

741
00:29:19,250 --> 00:29:21,309
Lectura

742
00:29:21,309 --> 00:29:22,829
Perdón, ¿esto qué es?

743
00:29:23,829 --> 00:29:25,410
Escritura de un objeto

744
00:29:25,410 --> 00:29:27,730
A lo mejor ahora esto lo miramos con un poco más de detalle

745
00:29:27,730 --> 00:29:29,730
Lectura de un objeto

746
00:29:29,730 --> 00:29:33,910
Y un ejemplo de una clase

747
00:29:33,910 --> 00:29:35,230
Serializable, ¿vale?

748
00:29:35,549 --> 00:29:40,089
Una clase serializable es que, sustancialmente, la clase de persona implementa el serializable.

749
00:29:40,210 --> 00:29:42,470
Con esto ya esta cosa es serializable.

750
00:29:42,869 --> 00:29:45,109
Y dentro tiene las cosas que tiene que tener.

751
00:29:46,150 --> 00:29:46,369
¿Vale?

752
00:29:48,809 --> 00:29:54,750
Y entonces esto de aquí es siempre una escritura con un objeto serializable.

753
00:29:55,269 --> 00:29:55,490
¿Vale?

754
00:29:56,630 --> 00:29:59,049
Y lectura de un objeto serializable.

755
00:29:59,569 --> 00:30:04,009
Y esta es un poco la jerarquía de clases que tenemos.

756
00:30:04,009 --> 00:30:05,869
Nosotros hemos visto

757
00:30:05,869 --> 00:30:08,569
Esto, FileInputStream

758
00:30:08,569 --> 00:30:11,069
BufferInputStream

759
00:30:11,069 --> 00:30:12,509
Esto puede ser interesante

760
00:30:12,509 --> 00:30:13,569
DataInputStream

761
00:30:13,569 --> 00:30:16,630
DataInputStream os permite

762
00:30:16,630 --> 00:30:19,890
Leer

763
00:30:19,890 --> 00:30:22,329
Ojetos, o sea leer

764
00:30:22,329 --> 00:30:23,890
Cosas de un determinado tipo

765
00:30:23,890 --> 00:30:25,849
Puedo leer un double

766
00:30:25,849 --> 00:30:28,329
Leer un char

767
00:30:28,329 --> 00:30:29,650
Leer un entero

768
00:30:29,650 --> 00:30:31,750
Mientras

769
00:30:31,750 --> 00:30:34,250
un input stream lee

770
00:30:34,250 --> 00:30:35,829
byte por byte

771
00:30:35,829 --> 00:30:38,349
esto ya te da un formato al dato

772
00:30:38,349 --> 00:30:39,329
que estás leyendo

773
00:30:39,329 --> 00:30:42,369
buffer de input stream lo hemos visto

774
00:30:42,369 --> 00:30:44,670
file input stream lo hemos visto

775
00:30:44,670 --> 00:30:47,109
object input stream

776
00:30:47,109 --> 00:30:48,009
lo hemos visto

777
00:30:48,009 --> 00:30:50,109
del output los mismos

778
00:30:50,109 --> 00:30:51,630
hay otros

779
00:30:51,630 --> 00:30:54,549
a lo mejor en determinadas situaciones pueden ser

780
00:30:54,549 --> 00:30:56,170
estos son

781
00:30:56,170 --> 00:30:58,230
a nivel de byte a byte

782
00:30:58,230 --> 00:31:00,589
estos son a nivel de caracteres

783
00:31:00,589 --> 00:31:02,630
Entonces si uso cosas textuales

784
00:31:02,630 --> 00:31:04,250
Me voy a este lado con los readers

785
00:31:04,250 --> 00:31:06,069
Buffered reader en particular

786
00:31:06,069 --> 00:31:07,450
File reader

787
00:31:07,450 --> 00:31:08,809
Y cosas por el estilo

788
00:31:08,809 --> 00:31:10,930
¿Si?

789
00:31:12,569 --> 00:31:14,529
Vale, vamos a ver

790
00:31:14,529 --> 00:31:17,069
O este o este

791
00:31:17,069 --> 00:31:18,150
Que diferencia hay

792
00:31:18,150 --> 00:31:20,490
Si os fijáis aquí voy a escribir

793
00:31:20,490 --> 00:31:21,789
Objetos, vale

794
00:31:21,789 --> 00:31:23,029
Con el object

795
00:31:23,029 --> 00:31:25,069
Object output stream

796
00:31:25,069 --> 00:31:27,589
Puedo escribir cosas como estas

797
00:31:27,589 --> 00:31:29,710
Un booleano, un double

798
00:31:29,710 --> 00:31:32,230
Un char, un int, un string

799
00:31:32,230 --> 00:31:33,009
¿Vale?

800
00:31:34,369 --> 00:31:36,009
Sostancialmente los tipos

801
00:31:36,009 --> 00:31:38,569
Básicos, los tipos primitivos

802
00:31:38,569 --> 00:31:40,009
Transformados

803
00:31:40,009 --> 00:31:41,930
En su clase wrapper, en su clase

804
00:31:41,930 --> 00:31:44,049
Contenedor, que es un

805
00:31:44,049 --> 00:31:45,789
Objeto, ¿vale? Como int tiene

806
00:31:45,789 --> 00:31:48,190
Integer o double tiene double

807
00:31:48,190 --> 00:31:49,910
Con la D mayúscula y cosas por el estilo

808
00:31:49,910 --> 00:31:51,609
Y luego este objeto se escribe

809
00:31:51,609 --> 00:31:53,750
¿Vale? Y tienen

810
00:31:53,750 --> 00:31:55,950
Las operaciones para escribir

811
00:31:55,950 --> 00:31:57,630
Cada uno de estos tipos

812
00:31:57,630 --> 00:31:59,789
Lo que puedo hacer luego es

813
00:31:59,789 --> 00:32:01,849
Leerlos, tengo el read boolean

814
00:32:01,849 --> 00:32:03,690
Para leer un booleano, un read double

815
00:32:03,690 --> 00:32:05,589
Para leer el double y cosas por el estilo

816
00:32:05,589 --> 00:32:07,829
Todo esto en object input string

817
00:32:07,829 --> 00:32:08,430
¿Vale?

818
00:32:08,750 --> 00:32:11,809
Si en vez quiero escribir un objeto de verdad

819
00:32:11,809 --> 00:32:12,789
¿Vale?

820
00:32:13,329 --> 00:32:14,329
Tengo mi

821
00:32:14,329 --> 00:32:16,650
Objeto

822
00:32:16,650 --> 00:32:18,849
Que es objeto persona

823
00:32:18,849 --> 00:32:21,130
Persona tendrá que ser serializable

824
00:32:21,130 --> 00:32:23,230
¿Vale? Aquí tengo cuatro personas

825
00:32:23,230 --> 00:32:26,009
Y lo que puedo hacer es un write object

826
00:32:26,009 --> 00:32:27,069
Del objeto

827
00:32:27,069 --> 00:32:30,450
Entonces, he abierto el fichero

828
00:32:30,450 --> 00:32:32,470
Escribo los cuatro

829
00:32:32,470 --> 00:32:36,470
Objetos uno seguido al otro

830
00:32:36,470 --> 00:32:37,809
No pasa nada, ¿vale?

831
00:32:37,869 --> 00:32:38,769
Esto lo puede hacer

832
00:32:38,769 --> 00:32:41,289
Al final cierro el

833
00:32:41,289 --> 00:32:45,029
El fichero, ¿vale?

834
00:32:45,049 --> 00:32:46,470
El canal de comunicación

835
00:32:46,470 --> 00:32:48,950
Cuidado que si ahora lo vuelvo a abrir

836
00:32:48,950 --> 00:32:50,670
Y vuelvo a poner otro objeto

837
00:32:50,670 --> 00:32:52,069
Allí es donde me puede dar problema

838
00:32:52,069 --> 00:32:53,430
¿Sí?

839
00:32:54,750 --> 00:32:55,349
Y

840
00:32:55,349 --> 00:33:05,289
o te creas

841
00:33:05,289 --> 00:33:07,210
una serie de ficheros distintos

842
00:33:07,210 --> 00:33:09,410
y luego cuando

843
00:33:09,410 --> 00:33:11,730
cada vez que añades algo

844
00:33:11,730 --> 00:33:13,430
añades, si esto es alumnos

845
00:33:13,430 --> 00:33:15,190
añade alumno 2 y los añade allí

846
00:33:15,190 --> 00:33:17,769
alumno 3 y cuando luego lo vas a leer

847
00:33:17,769 --> 00:33:18,630
te vas a mirar

848
00:33:18,630 --> 00:33:20,650
hasta que número has llegado

849
00:33:20,650 --> 00:33:22,769
y te importa todos los alumnos

850
00:33:22,769 --> 00:33:25,430
todos los ficheros dentro de esa carpeta

851
00:33:25,430 --> 00:33:27,049
y te lo vas a ir añadiendo uno y otro

852
00:33:27,049 --> 00:33:29,289
pero eso te puede llegar al momento que tienes

853
00:33:29,289 --> 00:33:30,329
50.000

854
00:33:30,329 --> 00:33:31,950
alumnos

855
00:33:31,950 --> 00:33:35,069
pero repito

856
00:33:35,069 --> 00:33:37,089
si son pocos datos

857
00:33:37,089 --> 00:33:39,369
es viable, si son muchos datos

858
00:33:39,369 --> 00:33:40,710
estamos hablando de 50.000 datos

859
00:33:40,710 --> 00:33:43,470
no lo haces con ficheros, lo haces con una base de datos

860
00:33:43,470 --> 00:33:45,910
y

861
00:33:45,910 --> 00:33:48,529
esto es para leer

862
00:33:48,529 --> 00:33:51,529
entonces acordaos que cuando voy a leer

863
00:33:51,529 --> 00:33:53,869
read object

864
00:33:53,869 --> 00:33:55,789
el resultado de esta cosa

865
00:33:55,789 --> 00:33:57,470
aquí es un objeto

866
00:33:57,470 --> 00:33:59,529
entonces lo tendré que castear

867
00:33:59,529 --> 00:34:00,150
A persona

868
00:34:00,150 --> 00:34:02,970
O leerlo como objeto

869
00:34:02,970 --> 00:34:05,789
Comprobar que es una instancia de persona

870
00:34:05,789 --> 00:34:06,930
Y a ese punto

871
00:34:06,930 --> 00:34:08,269
Guardarlo en la persona

872
00:34:08,269 --> 00:34:13,949
¿Se pueden mezclar

873
00:34:13,949 --> 00:34:14,809
Entre ellos

874
00:34:14,809 --> 00:34:16,630
Objetos raros

875
00:34:16,630 --> 00:34:18,809
Se podrá

876
00:34:18,809 --> 00:34:20,190
Es aconsejable

877
00:34:20,190 --> 00:34:21,670
Cuidado

878
00:34:21,670 --> 00:34:25,610
Con lo que no sabes

879
00:34:25,610 --> 00:34:26,389
Que estás leyendo

880
00:34:26,389 --> 00:34:30,719
Y esto más o menos

881
00:34:30,719 --> 00:34:34,780
lo que tenéis que saber de ficheros