1
00:00:01,649 --> 00:00:07,650
¿Vale? Si yo ahora vuelvo a escribirlo con este parámetro a true, ¿lo vuelvo a ejecutar?

2
00:00:12,119 --> 00:00:17,140
Un segundito. Vale, líneas. Líneas, que existe. Vale.

3
00:00:17,679 --> 00:00:23,440
Introduzca texto. Esto, esto y esto. Tres líneas nuevas he metido. Fin.

4
00:00:24,339 --> 00:00:26,019
Vamos a ver ahora qué tiene líneas.

5
00:00:27,620 --> 00:00:31,179
Nos vamos a líneas y efectivamente las ha añadido.

6
00:00:31,179 --> 00:00:34,700
no ha sobrescrito lo de antes

7
00:00:34,700 --> 00:00:35,420
lo ha añadido

8
00:00:35,420 --> 00:00:37,320
porque este parámetro está

9
00:00:37,320 --> 00:00:41,450
porque este parámetro está a true

10
00:00:41,450 --> 00:00:48,039
no, no, porque estoy trabajando

11
00:00:48,039 --> 00:00:49,679
con el nombre, con lo cual asume que es

12
00:00:49,679 --> 00:00:50,500
la raíz del proyecto

13
00:00:50,500 --> 00:00:53,119
en la raíz del proyecto, aquí

14
00:00:53,119 --> 00:00:55,560
tú dale a refresh, si no lo ves, dale a F5

15
00:00:55,560 --> 00:00:57,759
a refresh, y lo verás ahí colgando

16
00:00:57,759 --> 00:00:59,299
directamente de la raíz del proyecto

17
00:00:59,299 --> 00:01:03,520
porque esa es la ruta por defecto

18
00:01:03,520 --> 00:01:05,859
si tú no especificas nada

19
00:01:05,859 --> 00:01:07,500
lo que tú pongas, cuelga de ahí

20
00:01:07,500 --> 00:01:13,549
vale, y hay más variantes de constructor

21
00:01:13,549 --> 00:01:15,209
también le puedes pasar

22
00:01:15,209 --> 00:01:17,590
en lugar de un string, un objeto file

23
00:01:17,590 --> 00:01:19,310
hay variantes de constructor

24
00:01:19,310 --> 00:01:21,450
y variantes del método

25
00:01:21,450 --> 00:01:22,409
de escribir, bueno

26
00:01:22,409 --> 00:01:25,269
mil cosas, pero lo básico para

27
00:01:25,269 --> 00:01:27,430
escribir texto en un archivo sería esto

28
00:01:27,430 --> 00:01:29,670
bueno, pues ahora vámonos a leer

29
00:01:29,670 --> 00:01:31,569
que esto es un pelinín

30
00:01:31,569 --> 00:01:33,090
un pelinín más útil

31
00:01:33,090 --> 00:01:35,409
vamos ahora a leer

32
00:01:35,409 --> 00:01:36,469
el contenido de un fichero

33
00:01:36,469 --> 00:01:37,870
vale

34
00:01:37,870 --> 00:01:43,469
A ver

35
00:01:43,469 --> 00:02:00,510
Vale, pues

36
00:02:00,510 --> 00:02:08,930
¿Qué métodos?

37
00:02:11,870 --> 00:02:13,569
No, hombre, es que si leo, se escribe

38
00:02:13,569 --> 00:02:17,169
Pero para

39
00:02:17,169 --> 00:02:19,110
Escribir es file writer

40
00:02:19,110 --> 00:02:20,090
Y para leer es la otra

41
00:02:20,090 --> 00:02:22,270
Pero son dos fases distintas

42
00:02:22,270 --> 00:02:25,069
Lo que no se hace es leer

43
00:02:25,069 --> 00:02:26,370
Y escribir simultáneamente

44
00:02:26,370 --> 00:02:27,409
Porque como he dicho antes

45
00:02:27,409 --> 00:02:29,389
que se podrían generar efectos secundarios

46
00:02:29,389 --> 00:02:29,849
un poquito

47
00:02:29,849 --> 00:02:32,229
porque tú has leído

48
00:02:32,229 --> 00:02:34,830
se ha quedado posicionado en un sitio, escribes donde

49
00:02:34,830 --> 00:02:37,349
en la mitad, tienes que volver el puntero

50
00:02:37,349 --> 00:02:39,289
arriba, hay muy pocas clases

51
00:02:39,289 --> 00:02:43,469
que te admitan ambas cosas a la vez

52
00:02:43,469 --> 00:02:44,169
porque no se

53
00:02:44,169 --> 00:02:46,849
suelen usar, vale, está en la pizarra

54
00:02:46,849 --> 00:02:53,250
bueno, pues a ver, leer es un poquito

55
00:02:53,250 --> 00:02:59,370
más útil

56
00:02:59,370 --> 00:03:00,389
repito

57
00:03:00,389 --> 00:03:03,069
vale

58
00:03:03,069 --> 00:03:06,409
pues a ver, en cualquier caso

59
00:03:06,409 --> 00:03:07,789
la lectura y escritura

60
00:03:07,789 --> 00:03:10,810
siempre va de variables

61
00:03:10,810 --> 00:03:15,159
al fichero

62
00:03:15,159 --> 00:03:18,699
o del fichero a variables

63
00:03:18,699 --> 00:03:20,979
si fuera una base de datos

64
00:03:20,979 --> 00:03:22,520
pues sería una base de datos, me da igual

65
00:03:22,520 --> 00:03:23,560
en este caso es un fichero

66
00:03:23,560 --> 00:03:28,979
entonces escribir está claro

67
00:03:28,979 --> 00:03:30,219
escribir es

68
00:03:30,219 --> 00:03:33,180
yo mediante el método write correspondiente

69
00:03:33,180 --> 00:03:34,659
el método write

70
00:03:34,659 --> 00:03:35,319
que yo elija

71
00:03:35,319 --> 00:03:38,360
paso de aquí a aquí

72
00:03:38,360 --> 00:03:40,580
entonces en la primera escritura

73
00:03:40,580 --> 00:03:42,620
escribo donde esté posicionado

74
00:03:42,620 --> 00:03:44,560
el puntero interno, un puntero

75
00:03:44,560 --> 00:03:45,780
que yo ni gestiono ni manejo

76
00:03:45,780 --> 00:03:48,620
repito, si el fichero

77
00:03:48,620 --> 00:03:50,620
para escribir lo he abierto en modo

78
00:03:50,620 --> 00:03:52,479
añadir false, en el false

79
00:03:52,479 --> 00:03:55,000
el puntero se queda posicionado

80
00:03:55,000 --> 00:03:56,620
aquí, con lo cual la primera

81
00:03:56,620 --> 00:03:57,939
escritura se escribe aquí

82
00:03:57,939 --> 00:04:00,780
y ahora ya el puntero interno, ese que yo no manejo

83
00:04:00,780 --> 00:04:02,219
se queda posicionado aquí

84
00:04:02,219 --> 00:04:04,379
con lo cual la siguiente vez que haga write

85
00:04:04,379 --> 00:04:06,580
pues se escribe aquí debajo

86
00:04:06,580 --> 00:04:08,659
y el puntero interno se queda posicionado

87
00:04:08,659 --> 00:04:10,620
que necesito el rato, ¿vale? Eso está claro.

88
00:04:11,319 --> 00:04:12,759
Hay un posicionador

89
00:04:12,759 --> 00:04:14,000
interno que yo no manejo

90
00:04:14,000 --> 00:04:16,279
que va avanzando según hago escritura

91
00:04:16,279 --> 00:04:18,399
para que no se escriba una cosa encima de la otra.

92
00:04:19,120 --> 00:04:20,620
¿Vale? Bueno, pues ahora

93
00:04:20,620 --> 00:04:22,680
vamos a leer. Leer es lo contrario.

94
00:04:25,449 --> 00:04:26,649
Leer, yo tengo un fichero

95
00:04:26,649 --> 00:04:28,250
que supone que tiene bytes,

96
00:04:28,410 --> 00:04:30,569
tiene datos, o si es de texto, tiene caracteres

97
00:04:30,569 --> 00:04:32,310
y yo quiero

98
00:04:32,310 --> 00:04:34,610
mover

99
00:04:34,610 --> 00:04:36,889
lo que tiene a variables, porque la aplicación

100
00:04:36,889 --> 00:04:38,649
solo puede trabajar con lo que haya en variables,

101
00:04:38,810 --> 00:04:39,949
no puede trabajar con nada más.

102
00:04:40,490 --> 00:04:45,790
Bueno, pues entonces, ahora tendré que abrir el fichero con la clase que sirve para leer caracteres.

103
00:04:46,269 --> 00:04:51,670
Pues si la de escribir a FileWriter, la de leer es FileReader.

104
00:04:53,009 --> 00:04:54,709
¿Vale? Esa sería la de leer, FileReader.

105
00:04:57,079 --> 00:05:01,459
Bueno, pues entonces, en cuanto hablo FileReader, ese posicionador interno del fichero,

106
00:05:01,459 --> 00:05:06,300
que no gestionamos nosotros, ese posicionador interno se queda posicionado al principio.

107
00:05:07,240 --> 00:05:11,480
¿Eso qué significa? Que la primera lectura se hace del primer carácter.

108
00:05:11,480 --> 00:05:13,720
entonces la primera vez que hagamos un read

109
00:05:13,720 --> 00:05:18,269
se cogerá el primer carácter

110
00:05:18,269 --> 00:05:20,209
e irá a la variable

111
00:05:20,209 --> 00:05:21,850
que yo le diga, ahora veremos

112
00:05:21,850 --> 00:05:22,629
como usamos read

113
00:05:22,629 --> 00:05:26,329
pero la primera lectura cogerá el primer carácter

114
00:05:26,329 --> 00:05:27,769
que viajará a la variable

115
00:05:27,769 --> 00:05:30,009
que yo le diga, y ahora ese posicionador

116
00:05:30,009 --> 00:05:31,750
ese posicionador interno

117
00:05:31,750 --> 00:05:32,670
bajará al siguiente

118
00:05:32,670 --> 00:05:34,569
y se quedaría apuntando

119
00:05:34,569 --> 00:05:36,509
¿que vuelvo a hacer otro read?

120
00:05:36,730 --> 00:05:37,550
¿que vuelvo a hacer otro?

121
00:05:38,490 --> 00:05:40,430
pues entonces ahora se lee este carácter

122
00:05:40,430 --> 00:05:43,290
se lee este carácter que irá a la variable

123
00:05:43,290 --> 00:05:44,370
que yo le diga

124
00:05:44,370 --> 00:05:47,050
y el posicionador interno

125
00:05:47,050 --> 00:05:48,709
se quedará colocado aquí abajo

126
00:05:48,709 --> 00:05:51,029
y así

127
00:05:51,029 --> 00:05:53,370
tanto React como caracteres que irá yo leer

128
00:05:53,370 --> 00:05:55,430
vale

129
00:05:55,430 --> 00:05:56,850
aquí lo que pasa es que tenemos un problema

130
00:05:56,850 --> 00:05:58,490
cuando uno trabaja con un fichero

131
00:05:58,490 --> 00:06:01,009
no sabe el tamaño que tiene

132
00:06:01,009 --> 00:06:03,509
no tiene por qué saberlo la aplicación

133
00:06:03,509 --> 00:06:05,470
entonces no sabemos

134
00:06:05,470 --> 00:06:06,990
cuántos React hay que hacer

135
00:06:06,990 --> 00:06:08,810
no sabemos cuántos hay que hacer

136
00:06:08,810 --> 00:06:10,430
un bucle va a haber que hacer

137
00:06:10,430 --> 00:06:12,069
porque hay que hacer muchos React

138
00:06:12,069 --> 00:06:13,430
un bucle va a haber que hacer

139
00:06:13,430 --> 00:06:16,050
¿cuántos READ? pues no sé

140
00:06:16,050 --> 00:06:17,550
depende del tamaño

141
00:06:17,550 --> 00:06:21,029
entonces, ¿cómo funciona esta clase?

142
00:06:21,629 --> 00:06:22,709
esta clase funciona

143
00:06:22,709 --> 00:06:24,250
para que READ

144
00:06:24,250 --> 00:06:25,850
te devuelva una marca

145
00:06:25,850 --> 00:06:28,610
que es menos uno, ahora vemos cómo se usa

146
00:06:28,610 --> 00:06:30,829
cuando has llegado a fin de archivo

147
00:06:30,829 --> 00:06:32,750
esa es la manera de leer

148
00:06:32,750 --> 00:06:34,209
tendrás que hacerte un bucle

149
00:06:34,209 --> 00:06:36,250
obligatoriamente un bucle

150
00:06:36,250 --> 00:06:38,970
que va haciendo READ, READ, READ

151
00:06:38,970 --> 00:06:39,889
hasta

152
00:06:39,889 --> 00:06:42,629
que alcance la marca de fin de archivo

153
00:06:42,629 --> 00:06:44,949
y cuando alcance la marca de fin de archivo

154
00:06:44,949 --> 00:06:46,750
el bucle terminará porque ya no hay más que leer

155
00:06:46,750 --> 00:06:50,860
luego el funcionamiento de file reader es ese

156
00:06:50,860 --> 00:06:52,800
lo abres, se queda posicionado al principio

157
00:06:52,800 --> 00:06:54,959
y ahora ya cada lectura

158
00:06:54,959 --> 00:06:56,620
te va leyendo uno, te lee este

159
00:06:56,620 --> 00:06:57,620
y se queda posicionado aquí

160
00:06:57,620 --> 00:07:01,019
que le vuelves a mandar otro rea, te lee este y se queda posicionado aquí

161
00:07:01,019 --> 00:07:03,019
que los quieres leer todos

162
00:07:03,019 --> 00:07:03,800
pues un bucle

163
00:07:03,800 --> 00:07:06,420
te queda más remedio, un bucle de rea

164
00:07:06,420 --> 00:07:08,360
ese bucle cuando acabará

165
00:07:08,360 --> 00:07:11,459
cuando alcancemos la marca de fin de archivo

166
00:07:11,459 --> 00:07:12,680
vale

167
00:07:12,680 --> 00:07:15,240
bueno pues ahora hay que ver

168
00:07:15,240 --> 00:07:17,000
como se escribe en java esto

169
00:07:17,000 --> 00:07:19,740
esto es read y todo eso

170
00:07:19,740 --> 00:07:24,639
bueno pues a ver

171
00:07:24,639 --> 00:07:27,100
como se escribe en java

172
00:07:27,100 --> 00:07:35,439
todo esto, bueno pues el método

173
00:07:35,439 --> 00:07:37,199
nosotros tenemos el file reader este

174
00:07:37,199 --> 00:07:38,620
que lo habremos instanciado

175
00:07:38,620 --> 00:07:41,300
a un objeto fichero

176
00:07:41,300 --> 00:07:41,879
un file

177
00:07:41,879 --> 00:07:44,120
o al nombre del fichero

178
00:07:44,120 --> 00:07:47,560
tengo constructores con las dos variantes

179
00:07:47,560 --> 00:07:54,040
bueno, pues al file reader le pasamos un objeto file

180
00:07:54,040 --> 00:07:56,759
o un nombre del fichero

181
00:07:56,759 --> 00:07:59,459
porque el constructor te admite tanto un objeto file

182
00:07:59,459 --> 00:08:00,740
que guarde ese fichero

183
00:08:00,740 --> 00:08:02,920
o el string con el nombre, lo que sea

184
00:08:02,920 --> 00:08:06,279
bueno, pues abrimos el file reader

185
00:08:06,279 --> 00:08:07,680
y ahora ya

186
00:08:07,680 --> 00:08:09,920
¿qué hace cada read?

187
00:08:13,639 --> 00:08:15,860
pues el read no tiene parámetros

188
00:08:15,860 --> 00:08:17,500
el read no tiene parámetros

189
00:08:17,500 --> 00:08:19,240
lo que te hace es lo que hemos dicho

190
00:08:19,240 --> 00:08:24,000
te lee un carácter

191
00:08:24,000 --> 00:08:27,000
de donde esté posicionado el puntero interno

192
00:08:27,000 --> 00:08:27,959
te lee un carácter

193
00:08:27,959 --> 00:08:30,860
y te devuelve ese carácter como valor de retorno

194
00:08:30,860 --> 00:08:32,860
entonces lo que sí

195
00:08:32,860 --> 00:08:34,379
que tenemos que hacer, sí o sí

196
00:08:34,379 --> 00:08:36,639
es guardar ese valor de retorno

197
00:08:36,639 --> 00:08:37,299
en algún sitio

198
00:08:37,299 --> 00:08:40,720
FRA, lee el carácter de donde esté

199
00:08:40,720 --> 00:08:42,179
posicionado el puntero

200
00:08:42,179 --> 00:08:43,919
te lo devuelve como valor de retorno

201
00:08:43,919 --> 00:08:46,179
vosotros podéis pensar

202
00:08:46,179 --> 00:08:47,320
como es un carácter

203
00:08:47,320 --> 00:08:50,340
lo natural será

204
00:08:50,340 --> 00:08:52,519
que el FRA te devuelva

205
00:08:52,519 --> 00:08:54,340
un char que tú puedas guardar

206
00:08:54,340 --> 00:08:56,460
en una variable char? Pues no.

207
00:08:57,740 --> 00:08:58,559
El frrear

208
00:08:58,559 --> 00:08:59,600
no te devuelve un char.

209
00:09:00,299 --> 00:09:01,759
El frrear, ¿qué hace?

210
00:09:02,700 --> 00:09:03,980
Coge este carácter,

211
00:09:04,279 --> 00:09:05,960
que sí que es un char que tiene 8 bits,

212
00:09:06,059 --> 00:09:08,240
coge este carácter, imaginaos que es el carácter a,

213
00:09:09,159 --> 00:09:09,740
lo coge

214
00:09:09,740 --> 00:09:12,299
y lo mete en una variable int

215
00:09:12,299 --> 00:09:14,159
y lo coloca

216
00:09:14,159 --> 00:09:15,799
en el byte menos significativo.

217
00:09:16,399 --> 00:09:17,879
Y el resto lo deja limpio.

218
00:09:18,679 --> 00:09:19,960
Todo a ceros, ahí sin tocar.

219
00:09:21,159 --> 00:09:22,360
Es decir, esto es lo que

220
00:09:22,360 --> 00:09:24,440
hace, te construye un int

221
00:09:24,440 --> 00:09:26,419
mete

222
00:09:26,419 --> 00:09:28,679
el char en el menos significativo

223
00:09:28,679 --> 00:09:30,279
y el resto lo deja

224
00:09:30,279 --> 00:09:32,179
a cero, y tú ya te quedas

225
00:09:32,179 --> 00:09:34,320
con ese int, porque eso es lo que te

226
00:09:34,320 --> 00:09:35,720
devuelve

227
00:09:35,720 --> 00:09:37,840
ya vemoslo como quedamos

228
00:09:37,840 --> 00:09:40,399
luego te devuelve, te devuelve el int, FR te lo devuelve

229
00:09:40,399 --> 00:09:41,559
el int, entonces hay que guardarlo en int

230
00:09:41,559 --> 00:09:44,379
que tú lo quieres ya como

231
00:09:44,379 --> 00:09:46,000
char, no pasa nada, le haces el casting

232
00:09:46,000 --> 00:09:47,779
y al hacer el casting se queda con este

233
00:09:47,779 --> 00:09:49,639
¿vale?

234
00:09:50,139 --> 00:09:52,139
si uno ya hace el casting de esto

235
00:09:52,139 --> 00:09:57,750
char carácter igual a

236
00:09:57,750 --> 00:10:00,509
char de c

237
00:10:00,509 --> 00:10:03,149
pues ya está, ya tiene el carácter car

238
00:10:03,149 --> 00:10:05,289
que estaba guardado aquí

239
00:10:05,289 --> 00:10:06,950
en este int

240
00:10:06,950 --> 00:10:08,250
que me ha devuelto el fread

241
00:10:08,250 --> 00:10:10,690
y luego además el fread ya se encarga

242
00:10:10,690 --> 00:10:12,769
repito, de bajar el posicionador aquí

243
00:10:12,769 --> 00:10:15,529
para que en el siguiente fread

244
00:10:15,529 --> 00:10:16,769
se lea el siguiente que haya

245
00:10:16,769 --> 00:10:17,370
el siguiente

246
00:10:17,370 --> 00:10:18,549
¿vale?

247
00:10:18,970 --> 00:10:21,490
para que lea, si o si

248
00:10:21,490 --> 00:10:23,429
hay que hacer el cast

249
00:10:23,429 --> 00:10:26,230
Bueno, más que para que lea

250
00:10:26,230 --> 00:10:28,750
Para obtenerlo en variable char

251
00:10:28,750 --> 00:10:30,509
O sea, ha leído, lo ha leído

252
00:10:30,509 --> 00:10:31,269
Y lo ha guardado aquí

253
00:10:31,269 --> 00:10:33,929
Otra cosa es que tú, si lo quieres en char

254
00:10:33,929 --> 00:10:35,169
Tienes que hacer el casting

255
00:10:35,169 --> 00:10:37,049
¿Vale?

256
00:10:38,610 --> 00:10:40,210
Porque está guardado de esta manera

257
00:10:40,210 --> 00:10:41,250
Está guardado en un int

258
00:10:41,250 --> 00:10:43,909
Y está guardado en la parte menos significativa

259
00:10:43,909 --> 00:10:46,330
Entonces, si lo quieres en char, tienes que hacer el casting

260
00:10:46,330 --> 00:10:49,230
Para que te lo muestre en consola

261
00:10:49,230 --> 00:10:49,970
Por ejemplo

262
00:10:49,970 --> 00:10:51,970
O para pasarlo a un stream, para lo que quieras

263
00:10:51,970 --> 00:10:52,889
¿Vale?

264
00:10:53,429 --> 00:10:54,970
si lo quieres en chat

265
00:10:54,970 --> 00:10:57,029
lo tienes que hacer el casting

266
00:10:57,029 --> 00:10:58,149
¿vale?

267
00:10:59,230 --> 00:11:01,289
el casting también se hace de forma implícita

268
00:11:01,289 --> 00:11:03,090
pero cuando tú pasas a system.out.printl

269
00:11:03,090 --> 00:11:05,370
en una variable, como ella siempre unita caracteres

270
00:11:05,370 --> 00:11:07,470
él te hace el casting de forma implícita

271
00:11:07,470 --> 00:11:09,250
pero porque lo haga el método

272
00:11:09,250 --> 00:11:10,710
de forma implícita, porque lo hagas tú

273
00:11:10,710 --> 00:11:12,549
el casting lo tiene que hacer alguien

274
00:11:12,549 --> 00:11:15,370
porque ahora mismo el f-react te lo deja guardado

275
00:11:15,370 --> 00:11:17,750
aquí, en el byte menos significativo

276
00:11:17,750 --> 00:11:18,149
de unit

277
00:11:18,149 --> 00:11:21,549
y luego además te posiciona para quedarse

278
00:11:21,549 --> 00:11:23,370
preparado para la siguiente lectura

279
00:11:23,370 --> 00:11:46,720
Bueno, con lo cual la pregunta sería, pues, ¿y para qué hace esta tontería de meterlo en un int si lo único que cuenta es este? No lo hace precisamente para habilitarse la opción de avisar de cuándo has llegado al final, para avisar de cuándo has llegado al final.

280
00:11:46,720 --> 00:11:49,820
porque él, cuando ha llegado al final

281
00:11:49,820 --> 00:11:52,539
lo que hace Ferrea es devolverte menos uno

282
00:11:52,539 --> 00:11:55,000
el numerito menos uno

283
00:11:55,000 --> 00:11:58,960
y claro, si tú no has llegado al final

284
00:11:58,960 --> 00:12:00,539
y has leído cualquier otro carácter

285
00:12:00,539 --> 00:12:03,019
es imposible que este int sea menos uno

286
00:12:03,019 --> 00:12:05,059
porque aquí hay ceros en todas partes

287
00:12:05,059 --> 00:12:06,740
aquí está el carácter y aquí hay ceros

288
00:12:06,740 --> 00:12:09,799
y el menos uno es un número negativo

289
00:12:09,799 --> 00:12:12,480
y el negativo se codifica con el bit de signo uno

290
00:12:12,480 --> 00:12:16,360
con lo cual, si el resultado de Ferrea

291
00:12:16,360 --> 00:12:19,080
este int, tú lo comparas

292
00:12:19,080 --> 00:12:20,340
con doble o igual

293
00:12:20,340 --> 00:12:22,019
y resulta que es menos uno

294
00:12:22,019 --> 00:12:24,200
estás en fin de archivo

295
00:12:24,200 --> 00:12:26,399
y si no es menos uno

296
00:12:26,399 --> 00:12:27,740
no estás en fin de archivo

297
00:12:27,740 --> 00:12:30,259
si no es menos uno, habrás leído un carácter

298
00:12:30,259 --> 00:12:32,820
que habrás bajado para apuntar al siguiente

299
00:12:32,820 --> 00:12:34,820
y ese carácter estará ahí

300
00:12:34,820 --> 00:12:37,840
luego lo de meterlo en un int

301
00:12:37,840 --> 00:12:40,639
es para habilitar esta forma de avisar

302
00:12:40,639 --> 00:12:42,779
de que estás en fin de

303
00:12:42,779 --> 00:12:44,720
de fichero

304
00:12:44,720 --> 00:12:47,679
porque si devolviera un char no habría manera

305
00:12:47,679 --> 00:12:52,159
¿vale? entonces te habilita

306
00:12:52,159 --> 00:12:54,279
estos bits extra para con estos bits

307
00:12:54,279 --> 00:12:56,279
extra en función de si esto es 0 o 1

308
00:12:56,279 --> 00:12:58,299
avisarte de si es fin de fichero

309
00:12:58,299 --> 00:13:00,240
entonces

310
00:13:00,240 --> 00:13:01,720
ahora ya con esto

311
00:13:01,720 --> 00:13:03,840
podemos ya meter esto en el bucle

312
00:13:03,840 --> 00:13:06,440
pues tranquilamente, podríamos hacer un bucle

313
00:13:06,440 --> 00:13:07,460
pues por ejemplo así

314
00:13:07,460 --> 00:13:12,090
que es el bucle habitual para leer del fichero

315
00:13:12,090 --> 00:13:13,909
aquí

316
00:13:13,909 --> 00:13:15,970
vamos a, esta va a ser nuestra variable

317
00:13:15,970 --> 00:13:17,429
para guardar lo que hemos leído

318
00:13:17,429 --> 00:13:19,750
y ahora hacemos

319
00:13:19,750 --> 00:13:22,149
pues mientras C

320
00:13:22,149 --> 00:13:24,149
siendo C

321
00:13:24,149 --> 00:13:26,330
el resultado de leerlo

322
00:13:26,330 --> 00:13:28,289
mientras C sea diferente

323
00:13:28,289 --> 00:13:30,289
de menos uno, y este sería mi bucle

324
00:13:30,289 --> 00:13:32,309
ahora yo ya hago aquí con

325
00:13:32,309 --> 00:13:33,629
C lo que me dé la gana

326
00:13:33,629 --> 00:13:36,269
¿vale? este es un bucle

327
00:13:36,269 --> 00:13:38,330
que está, C lo leo

328
00:13:38,330 --> 00:13:40,350
es diferente de menos uno, entro

329
00:13:40,350 --> 00:13:41,470
y hago con C lo que quiera

330
00:13:41,470 --> 00:13:44,529
mostrarlo, haciendo el casting a char

331
00:13:44,529 --> 00:13:46,350
lo que a mí me dé la gana, concatenarlo con

332
00:13:46,350 --> 00:13:47,570
otro lo que quiera

333
00:13:47,570 --> 00:13:49,009
lo que quiera

334
00:13:49,009 --> 00:13:51,929
¿ahí estás teniendo esas condiciones así?

335
00:13:52,210 --> 00:13:53,370
igual que en el if de antes

336
00:13:53,370 --> 00:13:54,909
¿eso es como hacer una ternaria?

337
00:13:56,429 --> 00:13:58,809
no, no es como hacer una ternaria

338
00:13:58,809 --> 00:13:59,629
esto es como

339
00:13:59,629 --> 00:14:02,210
en el momento de usar una variable

340
00:14:02,210 --> 00:14:04,429
para compararlo con algo, en ese momento le asigno

341
00:14:04,429 --> 00:14:04,730
valor

342
00:14:04,730 --> 00:14:07,690
es decir, esto es una condición

343
00:14:07,690 --> 00:14:10,409
es una condición que compara c con esto

344
00:14:10,409 --> 00:14:12,429
como podríamos decir una condición

345
00:14:12,429 --> 00:14:14,889
que compara f con otra cosa

346
00:14:14,889 --> 00:14:16,070
lo que fuera

347
00:14:16,070 --> 00:14:17,990
entonces cuando uno usa una variable

348
00:14:17,990 --> 00:14:19,970
aquí, aquí, en una condición

349
00:14:19,970 --> 00:14:22,230
aunque sea una condición muy compleja

350
00:14:22,230 --> 00:14:24,169
cuando usas una variable dentro de esa condición

351
00:14:24,169 --> 00:14:26,070
puedes en el momento de usarla

352
00:14:26,070 --> 00:14:27,110
en ese momento darle un valor

353
00:14:27,110 --> 00:14:30,350
¿vale? por ejemplo, esta condición también es válida

354
00:14:30,350 --> 00:14:32,210
si f siendo f

355
00:14:32,210 --> 00:14:33,250
igual a 3

356
00:14:33,250 --> 00:14:35,590
resulta que es distinto de 5

357
00:14:35,590 --> 00:14:37,769
esta condición sería siempre true

358
00:14:37,769 --> 00:14:39,950
obviamente, porque en el momento de usar f

359
00:14:39,950 --> 00:14:41,330
le estoy dando el valor 3

360
00:14:41,330 --> 00:14:43,370
¿vale? luego en una condición

361
00:14:43,370 --> 00:14:45,690
cualquier variable puedes además

362
00:14:45,690 --> 00:14:47,809
darle un valor, entonces se le da primero

363
00:14:47,809 --> 00:14:49,549
el valor y luego se evalúa la condición

364
00:14:49,549 --> 00:14:51,590
entonces se usa mucho

365
00:14:51,590 --> 00:14:53,789
esa, porque te ahorras

366
00:14:53,789 --> 00:14:54,309
líneas

367
00:14:54,309 --> 00:14:57,570
bueno, pues si c es diferente de menos uno

368
00:14:57,570 --> 00:14:58,909
siendo c

369
00:14:58,909 --> 00:15:01,690
el resultado de haberla leído del fichero

370
00:15:01,690 --> 00:15:03,570
pues ahora yo hago con c lo que me dé la gana

371
00:15:03,570 --> 00:15:05,629
y ya está, y ese es el famoso

372
00:15:05,629 --> 00:15:07,090
buque de lectura de ficheros

373
00:15:07,090 --> 00:15:09,690
y ahí ya podemos hacer lo que

374
00:15:10,470 --> 00:15:11,710
queramos

375
00:15:11,710 --> 00:15:15,289
entonces, por ejemplo

376
00:15:15,289 --> 00:16:00,070
por ejemplo, vamos a hacer nuestro método

377
00:16:00,070 --> 00:16:00,870
de leer fichero

378
00:16:00,870 --> 00:16:03,629
le pasamos un nombre de fichero

379
00:16:03,629 --> 00:16:06,350
y que nos muestre

380
00:16:06,350 --> 00:16:07,629
por consola el contenido

381
00:16:07,629 --> 00:16:15,320
¿vale? entonces este método, ¿qué haría?

382
00:16:16,419 --> 00:16:17,379
pues este método

383
00:16:17,379 --> 00:16:19,200
recibe un

384
00:16:19,200 --> 00:16:20,179
nombre de fichero

385
00:16:20,179 --> 00:16:27,659
que se supone que es de texto, porque si no va a funcionar

386
00:16:27,659 --> 00:16:29,340
porque es file reader y nos haría

387
00:16:29,340 --> 00:16:30,759
cosas raras si no tiene texto

388
00:16:30,759 --> 00:16:33,990
y muestra

389
00:16:33,990 --> 00:16:39,830
por consola el contenido

390
00:16:39,830 --> 00:16:42,330
lo que sea que tenga

391
00:16:42,330 --> 00:16:46,129
pues ala, pues entonces

392
00:16:46,129 --> 00:16:47,809
como vamos a leer

393
00:16:47,809 --> 00:16:49,830
¿qué necesitamos? un file reader

394
00:16:49,830 --> 00:16:53,840
asociado a ese

395
00:16:53,840 --> 00:16:54,720
nombre de archivo

396
00:16:54,720 --> 00:17:02,980
aquí lo mismo, file reader, de nuevo

397
00:17:02,980 --> 00:17:05,339
sobrecargado, el constructor, le podemos pasar un string

398
00:17:05,339 --> 00:17:06,819
un objeto file

399
00:17:06,819 --> 00:17:09,339
con que le pasemos una referencia

400
00:17:09,339 --> 00:17:10,180
a esa ruta

401
00:17:10,180 --> 00:17:13,460
vale, importamos

402
00:17:13,460 --> 00:17:15,480
y de nuevo el throwsio exception

403
00:17:15,480 --> 00:17:17,720
no, en este caso file not found

404
00:17:17,720 --> 00:17:19,960
pues throws para que sea

405
00:17:19,960 --> 00:17:23,309
¿vale? porque este método

406
00:17:23,309 --> 00:17:25,130
si tratamos de leer, de abrir para leer

407
00:17:25,130 --> 00:17:27,069
uno que no exista nos va a salir una excepción

408
00:17:27,069 --> 00:17:28,269
file not found exception

409
00:17:28,269 --> 00:17:30,349
entonces le hacemos el throws y ya está

410
00:17:30,349 --> 00:17:32,890
¿vale? pues aquí

411
00:17:32,890 --> 00:17:35,170
esta va a ser la variable que habilitamos

412
00:17:35,170 --> 00:17:37,109
para leer los caracteres y ahora ya hacemos

413
00:17:37,109 --> 00:17:41,150
el bucle, mientras c

414
00:17:41,150 --> 00:17:42,509
siendo c

415
00:17:42,509 --> 00:17:44,950
el resultado

416
00:17:44,950 --> 00:17:46,509
de hacer una lectura

417
00:17:46,509 --> 00:17:48,470
del fichero

418
00:17:48,470 --> 00:17:52,170
sea diferente del numerito menos uno

419
00:17:52,170 --> 00:17:56,130
pues en ese caso vamos a mostrar por consola

420
00:17:56,130 --> 00:18:01,650
ese carácter que hemos leído

421
00:18:01,650 --> 00:18:05,430
que lo extraemos de ese int

422
00:18:05,430 --> 00:18:06,769
haciendo el casting

423
00:18:06,769 --> 00:18:09,170
que se quedará con el byte menos significativo

424
00:18:09,170 --> 00:18:10,029
que es el que nos importa

425
00:18:10,029 --> 00:18:12,569
el frr de nuevo una excepción

426
00:18:12,569 --> 00:18:13,410
pues otro throws

427
00:18:13,410 --> 00:18:18,500
println le vamos a poner print

428
00:18:18,500 --> 00:18:21,099
para que no nos saque todo el contenido

429
00:18:21,099 --> 00:18:22,819
cada carácter una línea

430
00:18:22,819 --> 00:18:25,799
queremos que todos los caracteres salgan tal cual

431
00:18:25,799 --> 00:18:31,180
y ahora ya lo mismo

432
00:18:31,180 --> 00:18:33,119
un recurso que se ha abierto

433
00:18:33,119 --> 00:18:35,279
pues deberíamos cerrarlo

434
00:18:35,279 --> 00:18:37,460
al apagar el programa

435
00:18:37,460 --> 00:18:39,000
al cerrar el programa se cierran solos

436
00:18:39,000 --> 00:18:40,599
pero podría a lo mejor no cerrarse

437
00:18:40,599 --> 00:18:42,559
entonces se queda ese recurso bloqueado, etc

438
00:18:42,559 --> 00:18:44,480
pues ya está

439
00:18:44,480 --> 00:18:46,400
este va leyendo ese fichero

440
00:18:46,400 --> 00:18:49,960
y ahora

441
00:18:49,960 --> 00:18:55,549
en el main nuestro

442
00:18:55,549 --> 00:18:57,829
hemos escrito ya un fichero

443
00:18:57,829 --> 00:18:59,609
y ahora vamos a mostrar por consola el contenido

444
00:18:59,609 --> 00:19:01,750
Vamos a ponerlo aquí

445
00:19:01,750 --> 00:19:09,880
El contenido del fichero es

446
00:19:09,880 --> 00:19:11,720
Y ese mismo fichero que acabamos de escribir

447
00:19:11,720 --> 00:19:12,539
Que nos lo muestre

448
00:19:12,539 --> 00:19:17,359
Leer fichero

449
00:19:17,359 --> 00:19:18,420
Se llama el método, ¿no?

450
00:19:19,220 --> 00:19:20,319
Leer fichero

451
00:19:20,319 --> 00:19:22,539
Y el nombre del fichero es este

452
00:19:22,539 --> 00:19:27,099
Es el que acabamos de crear

453
00:19:27,099 --> 00:19:38,480
¿Vale? Es decir, este método

454
00:19:38,480 --> 00:19:39,640
Ha creado un fichero f

455
00:19:39,640 --> 00:19:42,099
con el nombre fgetname

456
00:19:42,099 --> 00:19:44,559
y vamos ahora a leerlo

457
00:19:44,559 --> 00:19:46,380
ese fichero con ese nombre getname

458
00:19:46,380 --> 00:19:52,759
venga, nombre del fichero

459
00:19:52,759 --> 00:19:53,619
líneas

460
00:19:53,619 --> 00:19:56,960
vamos a escribir cualquier cosa que se va a concatenar

461
00:19:56,960 --> 00:19:57,420
al otro

462
00:19:57,420 --> 00:20:00,480
porque estaba con true, creo

463
00:20:00,480 --> 00:20:03,180
fin, ya no escribimos más

464
00:20:03,180 --> 00:20:05,579
y el contenido del fichero es

465
00:20:05,579 --> 00:20:06,960
pues efectivamente

466
00:20:06,960 --> 00:20:08,319
es el contenido del fichero

467
00:20:08,319 --> 00:20:12,349
con las nuevas líneas

468
00:20:12,349 --> 00:20:13,869
que hemos incorporado

469
00:20:13,869 --> 00:20:48,339
vale, pues vamos a poner aquí unos métodos vacíos

470
00:20:48,339 --> 00:20:50,400
para que hagáis vosotros

471
00:20:50,400 --> 00:20:52,339
un poco de más

472
00:20:52,339 --> 00:20:54,019
sencillo y más complicado

473
00:20:54,019 --> 00:20:55,740
por ejemplo

474
00:20:55,740 --> 00:20:56,920
este método

475
00:20:56,920 --> 00:21:05,039
pues un método que dado un objeto file

476
00:21:05,039 --> 00:21:10,359
te cuente

477
00:21:10,359 --> 00:21:11,480
cuantas líneas tiene

478
00:21:11,480 --> 00:21:18,000
yo pongo esto así para

479
00:21:18,000 --> 00:21:21,420
que tiene que devolver las líneas que tiene ese fichero

480
00:21:21,420 --> 00:21:24,579
vale

481
00:21:24,579 --> 00:21:25,980
otro

482
00:21:25,980 --> 00:21:46,579
un método

483
00:21:46,579 --> 00:21:48,420
para concatenar dos ficheros

484
00:21:48,420 --> 00:21:50,920
y generar un tercero con la concatenación

485
00:21:50,920 --> 00:21:51,480
de los otros

486
00:21:51,480 --> 00:21:57,559
se le pasa un fichero

487
00:21:57,559 --> 00:21:58,220
F1

488
00:21:58,220 --> 00:22:00,880
y se le pasa un fichero F2

489
00:22:00,880 --> 00:22:02,759
y tiene que devolver

490
00:22:02,759 --> 00:22:03,940
otro fichero

491
00:22:03,940 --> 00:22:07,440
cuyo contenido sea la concatenación

492
00:22:07,440 --> 00:22:08,059
de estos

493
00:22:08,059 --> 00:22:11,500
luego le da de este, le da de este

494
00:22:11,500 --> 00:22:13,279
irá escribiendo en uno

495
00:22:13,279 --> 00:22:21,730
y ahora otro

496
00:22:21,730 --> 00:22:23,589
que en lugar de

497
00:22:23,589 --> 00:22:26,069
coger los dos y concatear uno detrás de otro

498
00:22:26,069 --> 00:22:28,309
vaya intercalando las líneas

499
00:22:28,309 --> 00:22:39,710
que este es más

500
00:22:39,710 --> 00:22:42,089
complicado

501
00:22:42,089 --> 00:22:52,890
vale, este está claro

502
00:22:52,890 --> 00:22:53,809
no hay que hacer

503
00:22:53,809 --> 00:23:02,960
que devuelve este

504
00:23:02,960 --> 00:23:04,400
devuelve el

505
00:23:04,400 --> 00:23:08,500
número de líneas

506
00:23:08,500 --> 00:23:10,500
del fichero

507
00:23:10,500 --> 00:23:11,400
vale

508
00:23:11,400 --> 00:23:13,180
este otro

509
00:23:13,180 --> 00:23:20,700
primer fichero

510
00:23:20,700 --> 00:23:26,210
segundo fichero

511
00:23:26,210 --> 00:23:28,829
que devuelve

512
00:23:28,829 --> 00:23:31,269
un fichero

513
00:23:31,269 --> 00:23:33,750
cuyo contenido

514
00:23:33,750 --> 00:23:35,710
es la concatenación de los anteriores

515
00:23:35,710 --> 00:23:46,400
anteriores

516
00:23:46,400 --> 00:23:48,759
y ahora

517
00:23:48,759 --> 00:23:50,319
el de intercala líneas

518
00:23:50,319 --> 00:23:54,650
pues es un fichero, otro fichero

519
00:23:54,650 --> 00:23:59,299
prácticamente lo mismo

520
00:23:59,299 --> 00:24:01,240
un fichero

521
00:24:01,240 --> 00:24:02,799
que tiene la concatenación de los anteriores

522
00:24:02,799 --> 00:24:05,180
pero intercalando sus líneas

523
00:24:05,180 --> 00:24:13,240
sus líneas

524
00:24:13,240 --> 00:24:18,319
pues ahora ya tenéis esos tres métodos

525
00:24:18,319 --> 00:24:20,299
como ejemplo para practicar con FileReader

526
00:24:20,299 --> 00:24:20,960
FileWriter

527
00:24:20,960 --> 00:24:26,390
el de

528
00:24:26,390 --> 00:24:28,309
leer fichero

529
00:24:28,309 --> 00:24:28,609
¿has dicho?

530
00:24:28,609 --> 00:24:29,750
esto