1
00:00:00,000 --> 00:00:03,960
este máximo es uno de los más

2
00:00:03,960 --> 00:00:05,519
claros

3
00:00:05,519 --> 00:00:07,700
que podemos encontrar

4
00:00:07,700 --> 00:00:09,900
mi resultado final

5
00:00:09,900 --> 00:00:11,859
es un objeto file, ese es mi resultado

6
00:00:11,859 --> 00:00:13,679
final, el más grande de todos

7
00:00:13,679 --> 00:00:15,980
vale, pues de partida asumo que el primero

8
00:00:15,980 --> 00:00:17,899
de todos, que el primero es

9
00:00:17,899 --> 00:00:20,100
el mayor, y ahora empiezo a recorrer los demás

10
00:00:20,100 --> 00:00:24,100
si uno de ellos

11
00:00:24,100 --> 00:00:25,359
supera en tamaño

12
00:00:25,359 --> 00:00:27,739
al que es máximo en ese instante

13
00:00:27,739 --> 00:00:31,800
ya tengo nuevo máximo y ya está

14
00:00:31,800 --> 00:00:34,899
cuando el for ha terminado, ya tengo en esta referencia

15
00:00:34,899 --> 00:00:36,200
el que era máximo y se acabó

16
00:00:36,200 --> 00:00:37,820
vale

17
00:00:37,820 --> 00:00:40,590
no hay más

18
00:00:40,590 --> 00:00:47,750
bueno, alguna duda sobre esto

19
00:00:47,750 --> 00:00:49,909
no

20
00:00:49,909 --> 00:00:51,929
vale, pues vamos a usarlo

21
00:00:51,929 --> 00:00:54,130
pasándole un array de ficheros

22
00:00:54,130 --> 00:00:59,780
entonces, ¿de dónde sacamos

23
00:00:59,780 --> 00:01:01,219
aquí un array de ficheros?

24
00:01:01,740 --> 00:01:03,259
pues por ejemplo, vamos a usar

25
00:01:03,259 --> 00:01:05,719
alguno de los métodos de file para coger

26
00:01:05,719 --> 00:01:07,079
un array de ficheros como ejemplo

27
00:01:07,079 --> 00:01:09,019
por ejemplo, en la ruta

28
00:01:09,019 --> 00:01:10,340
Primera

29
00:01:10,340 --> 00:01:12,579
La ruta primera

30
00:01:12,579 --> 00:01:17,219
Vamos a hacer una ruta que sea un subdirectorio

31
00:01:17,219 --> 00:01:19,519
Esta primera

32
00:01:19,519 --> 00:01:21,159
Por ejemplo vamos a coger aquí

33
00:01:21,159 --> 00:01:25,250
Lo voy a poner como ruta absoluta

34
00:01:25,250 --> 00:01:27,290
Por si luego usáis el proyecto

35
00:01:27,290 --> 00:01:27,870
Lo que sea

36
00:01:27,870 --> 00:01:29,230
Entonces vamos a

37
00:01:29,230 --> 00:01:32,629
En esta carpeta ficheros de aquí

38
00:01:32,629 --> 00:01:36,739
En esta carpeta ficheros

39
00:01:36,739 --> 00:01:39,099
Que está en mi proyecto

40
00:01:39,099 --> 00:01:46,239
Ficheros

41
00:01:46,239 --> 00:01:47,159
Ahora tiene un fichero

42
00:01:47,159 --> 00:01:47,900
Vamos a hacer

43
00:01:47,900 --> 00:01:50,519
Vamos a hacer tres más

44
00:01:50,519 --> 00:01:56,629
Fichero 2

45
00:01:56,629 --> 00:02:01,090
Al que le ponemos también unos caracteres

46
00:02:01,090 --> 00:02:05,859
Creía que me iba a preguntar si guardaba

47
00:02:05,859 --> 00:02:06,760
No me ha preguntado

48
00:02:06,760 --> 00:02:12,500
Vale, y vamos a hacer otro

49
00:02:18,159 --> 00:02:28,909
Vale, pues le voy a pasar

50
00:02:28,909 --> 00:02:31,310
Un array con estos tres ficheros

51
00:02:31,310 --> 00:02:32,930
Un array con estos tres

52
00:02:32,930 --> 00:02:35,090
Podría

53
00:02:35,090 --> 00:02:36,669
Lógicamente hacer esto

54
00:02:36,669 --> 00:02:44,439
Podría hacer esto

55
00:02:44,439 --> 00:02:52,189
New file de tres

56
00:02:52,189 --> 00:02:53,689
Voy a meter tres

57
00:02:53,689 --> 00:02:55,909
Y ahora ya

58
00:02:55,909 --> 00:02:58,169
Files de

59
00:02:58,169 --> 00:02:58,969
Cero

60
00:02:58,969 --> 00:03:04,000
Igual a pues new file

61
00:03:04,000 --> 00:03:06,780
Y la ruta del primero

62
00:03:06,780 --> 00:03:35,479
Vale, podría ir así a lo cutre

63
00:03:35,479 --> 00:03:36,460
Ir uno por uno

64
00:03:36,460 --> 00:03:45,379
Fichero, fichero 1 y fichero 2

65
00:03:45,379 --> 00:03:46,479
Creo que se llaman

66
00:03:46,479 --> 00:03:50,689
Fichero, fichero 2 y fichero 3

67
00:03:50,689 --> 00:03:52,849
No, se llaman fichero, fichero 2

68
00:03:52,849 --> 00:03:55,409
Y fichero 3

69
00:03:55,409 --> 00:03:57,650
Bueno, pues para hacer mi prueba

70
00:03:57,650 --> 00:04:01,110
He puesto 11

71
00:04:01,110 --> 00:04:03,050
Pues me saldría un

72
00:04:03,050 --> 00:04:04,610
Arraindes va un exception, ¿verdad?

73
00:04:05,550 --> 00:04:08,210
vale, bueno, pues podría ir así a lo

74
00:04:08,210 --> 00:04:09,930
a lo bestia

75
00:04:09,930 --> 00:04:11,930
como sé que voy a pasar 3

76
00:04:11,930 --> 00:04:13,689
en concreto 3

77
00:04:13,689 --> 00:04:16,009
pues me hago un array con espacio para 3

78
00:04:16,009 --> 00:04:18,230
y ahora en cada uno de ellos 0, 1 y 2

79
00:04:18,230 --> 00:04:19,430
me creo el objeto file

80
00:04:19,430 --> 00:04:22,009
con la ruta, y ahora llamo

81
00:04:22,009 --> 00:04:23,930
entonces, esto me va a devolver

82
00:04:23,930 --> 00:04:26,209
el fichero más grande, si yo lo llamo sin guardarlo

83
00:04:26,209 --> 00:04:28,209
en algún sitio, pues pierdo

84
00:04:28,209 --> 00:04:29,730
la referencia, vaya tontería

85
00:04:29,730 --> 00:04:32,129
y ahora ya podría decir

86
00:04:32,129 --> 00:04:34,629
mostrar el resultado

87
00:04:34,629 --> 00:04:42,649
El fichero de más tamaño es

88
00:04:42,649 --> 00:04:47,050
Y ahora voy a concatenarlo

89
00:04:47,050 --> 00:04:54,050
Con el nombre del fichero que está aquí

90
00:04:54,050 --> 00:04:55,170
Que no sé cuál es

91
00:04:55,170 --> 00:04:58,189
Pero de nuevo la clase File me permite mil cosas

92
00:04:58,189 --> 00:05:00,970
Por ejemplo, tiene un método que es GetName

93
00:05:00,970 --> 00:05:04,129
¿Verdad? Tiene un método que es GetName

94
00:05:04,129 --> 00:05:06,829
y este método me devuelve el nombre

95
00:05:06,829 --> 00:05:09,069
del objeto que está asociado a esta referencia

96
00:05:09,069 --> 00:05:11,699
entonces

97
00:05:11,699 --> 00:05:13,579
el objeto file

98
00:05:13,579 --> 00:05:15,720
resultado de la llamada al método

99
00:05:15,720 --> 00:05:18,000
ese objeto file es el que tiene el mayor

100
00:05:18,000 --> 00:05:19,980
tamaño, pues puedo mostrar ya

101
00:05:19,980 --> 00:05:20,899
el resultado aquí

102
00:05:20,899 --> 00:05:22,879
es este

103
00:05:22,879 --> 00:05:25,560
los métodos de la clase file

104
00:05:25,560 --> 00:05:26,779
permiten hacer muchas cosas

105
00:05:26,779 --> 00:05:28,480
entonces vamos a probarlo

106
00:05:28,480 --> 00:05:31,120
para estos tres

107
00:05:31,120 --> 00:05:33,600
que me he hecho yo aquí a mano, 0, 1 y 2

108
00:05:33,600 --> 00:05:34,480
para estos tres

109
00:05:34,480 --> 00:05:38,079
entonces si ejecutamos esto

110
00:05:38,079 --> 00:05:40,199
pues me dice

111
00:05:40,199 --> 00:05:42,680
que el 2 es el que tiene más

112
00:05:42,680 --> 00:05:44,899
más bytes

113
00:05:44,899 --> 00:05:47,949
vamos a ver

114
00:05:47,949 --> 00:05:48,490
si es verdad

115
00:05:48,490 --> 00:05:56,620
pues si tiene toda la pinta

116
00:05:56,620 --> 00:05:59,500
de que este es el que tenía

117
00:05:59,500 --> 00:06:00,420
más caracteres

118
00:06:00,420 --> 00:06:02,839
bueno

119
00:06:02,839 --> 00:06:05,259
para probar otros métodos de la clase file

120
00:06:05,259 --> 00:06:07,939
antes de pasar ya a clases que nos permiten leer y escribir

121
00:06:07,939 --> 00:06:09,860
por ejemplo

122
00:06:09,860 --> 00:06:11,660
imaginaos que lo que me dicen

123
00:06:11,660 --> 00:06:17,819
Oye, pero esto de pasármelos así uno por uno, este, este, este, no.

124
00:06:18,660 --> 00:06:22,019
Quiero ver cuál es el más grande de todos los que están en un directorio.

125
00:06:22,899 --> 00:06:24,839
Tendría más sentido a lo mejor plantearse eso, ¿no?

126
00:06:25,459 --> 00:06:30,600
Yo tengo un directorio y el fichero más grande de todos los que están en ese directorio.

127
00:06:31,620 --> 00:06:31,819
¿Vale?

128
00:06:32,899 --> 00:06:35,980
Vale, pues por ejemplo, vamos a hacerlo con otro método.

129
00:06:35,980 --> 00:06:40,709
un objeto file

130
00:06:40,709 --> 00:06:42,009
me va a devolver

131
00:06:42,009 --> 00:06:45,959
fichero más grande

132
00:06:45,959 --> 00:06:48,060
y ahora que le pasamos

133
00:06:48,060 --> 00:06:49,819
un único objeto file

134
00:06:49,819 --> 00:06:51,980
que es

135
00:06:51,980 --> 00:06:54,519
una referencia

136
00:06:54,519 --> 00:06:56,139
a una ruta que es el

137
00:06:56,139 --> 00:06:58,100
directorio al cual yo quiero

138
00:06:58,100 --> 00:06:59,899
entrar para ver los que son más grandes

139
00:06:59,899 --> 00:07:03,519
vale, voy a poner aquí un return null

140
00:07:03,519 --> 00:07:05,199
para que el compilador

141
00:07:05,199 --> 00:07:06,800
se me quite

142
00:07:06,800 --> 00:07:08,560
el error, vale

143
00:07:08,560 --> 00:07:11,000
pues esta es otra versión del método

144
00:07:11,000 --> 00:07:13,379
otra versión a la que le paso una ruta

145
00:07:13,379 --> 00:07:14,879
asociada a un objeto file

146
00:07:14,879 --> 00:07:15,839
le paso una ruta

147
00:07:15,839 --> 00:07:18,680
esta ruta en particular no es de un fichero

148
00:07:18,680 --> 00:07:20,339
esta ruta es de un directorio

149
00:07:20,339 --> 00:07:21,920
y ahora

150
00:07:21,920 --> 00:07:25,199
este método tendrá que mirar todos los archivos

151
00:07:25,199 --> 00:07:26,959
de ese directorio a ver cuál es mayor

152
00:07:26,959 --> 00:07:28,100
y devolverlo

153
00:07:28,100 --> 00:07:32,439
por ejemplo, he dejado el mismo

154
00:07:32,439 --> 00:07:34,439
nombre que el de arriba

155
00:07:34,439 --> 00:07:36,480
¿pasa algo porque he dejado el mismo

156
00:07:36,480 --> 00:07:36,819
nombre?

157
00:07:37,920 --> 00:07:40,199
¿por qué el compilador me permite

158
00:07:40,199 --> 00:07:42,600
que dos métodos

159
00:07:42,600 --> 00:07:44,220
se llamen igual, me lo está permitiendo

160
00:07:44,220 --> 00:07:45,560
se llaman igual y no pasa nada

161
00:07:45,560 --> 00:07:48,720
¿por qué? estamos volviendo al primer trimestre

162
00:07:48,720 --> 00:07:49,399
todo el rato

163
00:07:49,399 --> 00:07:52,420
efectivamente

164
00:07:52,420 --> 00:07:53,600
porque

165
00:07:53,600 --> 00:07:56,139
se puede distinguir en la llamada

166
00:07:56,139 --> 00:07:58,180
por el parámetro, si tú le pasas un array de fichero

167
00:07:58,180 --> 00:07:58,899
estás llamando a este

168
00:07:58,899 --> 00:08:02,220
pero si le pasas un único file

169
00:08:02,220 --> 00:08:03,060
le estás llamando al otro

170
00:08:03,060 --> 00:08:06,459
entonces nunca va a haber confusión respecto a cuál estás llamando

171
00:08:06,459 --> 00:08:08,019
por la lista de parámetros

172
00:08:08,019 --> 00:08:11,139
Esto es lo que se llama que el método está sobrecargado

173
00:08:11,139 --> 00:08:11,560
¿Verdad?

174
00:08:12,740 --> 00:08:14,139
Vale, pues entonces ahora ¿Qué hacemos?

175
00:08:14,199 --> 00:08:15,220
Vamos a hacer este otro método

176
00:08:15,220 --> 00:08:19,079
¿Cómo podemos sacar los ficheros

177
00:08:19,079 --> 00:08:20,600
Que están en esa ruta?

178
00:08:21,420 --> 00:08:22,360
Bueno, pues de nuevo

179
00:08:22,360 --> 00:08:24,259
Vamos a ver

180
00:08:24,259 --> 00:08:27,399
¿Qué métodos tiene File que me permitan hacer eso?

181
00:08:28,579 --> 00:08:29,779
Vamos a ver este dir

182
00:08:29,779 --> 00:08:31,220
Que a mí me han pasado como parámetro

183
00:08:31,220 --> 00:08:33,799
Si yo cotilleo

184
00:08:33,799 --> 00:08:34,820
Los métodos que tiene

185
00:08:34,820 --> 00:08:37,480
Pues resulta que tiene uno

186
00:08:37,480 --> 00:08:39,720
que es listFiles

187
00:08:39,720 --> 00:08:41,539
directamente, que te devuelve

188
00:08:41,539 --> 00:08:43,019
un array de file, pues justo

189
00:08:43,019 --> 00:08:44,820
lo que estamos buscando

190
00:08:44,820 --> 00:08:47,879
este método

191
00:08:47,879 --> 00:08:50,000
listFiles te devuelve

192
00:08:50,000 --> 00:08:50,840
un array de file

193
00:08:50,840 --> 00:08:53,480
con todos los ficheros

194
00:08:53,480 --> 00:08:55,340
que hay en ese directorio

195
00:08:55,340 --> 00:09:01,559
con el contenido

196
00:09:01,559 --> 00:09:07,340
ala, pues ya tengo

197
00:09:07,340 --> 00:09:09,320
un array de ficheros

198
00:09:09,320 --> 00:09:10,779
un array de ficheros

199
00:09:10,779 --> 00:09:13,559
que es el contenido

200
00:09:13,559 --> 00:09:15,279
de este dir

201
00:09:15,279 --> 00:09:18,259
Y ahora ya puedo hacer lo que he hecho antes

202
00:09:18,259 --> 00:09:23,700
Entonces, para repetir el código

203
00:09:23,700 --> 00:09:25,080
¿Para qué voy a repetir el código?

204
00:09:25,659 --> 00:09:27,179
Si ya tengo un método que me lo hace

205
00:09:27,179 --> 00:09:28,200
¿Para qué lo voy a repetir?

206
00:09:28,720 --> 00:09:31,000
Pues vamos a hacer esto y apañado

207
00:09:31,000 --> 00:09:32,799
retum

208
00:09:32,799 --> 00:09:34,840
fichero más grande

209
00:09:34,840 --> 00:09:37,279
contenido

210
00:09:37,279 --> 00:09:38,340
¡Hala!

211
00:09:39,799 --> 00:09:41,419
Y terminado este método

212
00:09:41,419 --> 00:09:43,080
¿No?

213
00:09:43,980 --> 00:09:45,159
O sea, fichero más grande

214
00:09:45,159 --> 00:09:47,220
cuando le pasas un array se refiere al método

215
00:09:47,220 --> 00:09:47,980
de arriba, ¿verdad?

216
00:09:48,000 --> 00:09:55,820
fijaos que uno mirando esto

217
00:09:55,820 --> 00:09:58,220
podría decir, uy, esto es una cosa recursiva

218
00:09:58,220 --> 00:09:59,879
estoy desde un método

219
00:09:59,879 --> 00:10:01,419
volviéndose a llamar a sí mismo

220
00:10:01,419 --> 00:10:03,379
no, no, no, no se está volviendo a llamar a sí mismo

221
00:10:03,379 --> 00:10:04,820
está llamando al de arriba

222
00:10:04,820 --> 00:10:07,000
¿por qué? porque lo que le estamos pasando

223
00:10:07,000 --> 00:10:09,240
es un array de ficheros

224
00:10:09,240 --> 00:10:11,740
entonces como lo que le estamos pasando es un array de ficheros

225
00:10:11,740 --> 00:10:13,159
no estamos llamando a este

226
00:10:13,159 --> 00:10:15,740
estamos llamando al que reciba

227
00:10:15,740 --> 00:10:16,840
un array de ficheros

228
00:10:16,840 --> 00:10:19,539
y el que recibe un array de ficheros es este

229
00:10:19,539 --> 00:10:21,120
luego entonces

230
00:10:21,120 --> 00:10:23,279
aquí estamos llamando al de arriba

231
00:10:23,279 --> 00:10:25,500
¿vale?

232
00:10:26,139 --> 00:10:27,340
entonces esta es otra versión

233
00:10:27,340 --> 00:10:29,620
de ese método que le pasas un directorio

234
00:10:29,620 --> 00:10:31,159
y te dice de todos los que haya

235
00:10:31,159 --> 00:10:33,100
20, 30, 50, no sabemos

236
00:10:33,100 --> 00:10:35,159
los que salgan aquí, no sabemos

237
00:10:35,159 --> 00:10:36,779
de todos los que haya cuál es el más grande

238
00:10:36,779 --> 00:10:41,120
bueno pues si lo probamos desde

239
00:10:41,120 --> 00:10:42,720
está claro ¿no?

240
00:10:45,330 --> 00:10:47,070
si lo probamos desde nuestro main

241
00:10:47,070 --> 00:10:49,009
a este lo llamaríamos así

242
00:10:49,009 --> 00:10:51,710
sería mucho más fácil

243
00:10:51,710 --> 00:10:53,610
porque le llamaríamos

244
00:10:53,610 --> 00:10:55,289
Vamos a ver cuál es el más grande

245
00:10:55,289 --> 00:11:03,529
Ejemplo file

246
00:11:03,529 --> 00:11:04,929
Porque como no lo tengo static

247
00:11:04,929 --> 00:11:06,870
Lo estoy llamando como un objeto de la clase

248
00:11:06,870 --> 00:11:07,490
Todo el rato

249
00:11:07,490 --> 00:11:12,659
New ejemplo file

250
00:11:12,659 --> 00:11:15,039
¿Y qué hay que pasarle?

251
00:11:15,360 --> 00:11:17,519
Hay que pasarle la ruta del directorio que queremos

252
00:11:17,519 --> 00:11:19,899
La ruta del directorio

253
00:11:19,899 --> 00:11:23,289
Pero en objeto file

254
00:11:23,289 --> 00:11:24,889
Pues entonces

255
00:11:24,889 --> 00:11:26,809
Le puedo pasar esto, new file

256
00:11:26,809 --> 00:11:28,649
Y ahora ya le pongo

257
00:11:28,649 --> 00:11:31,549
ficheros

258
00:11:31,549 --> 00:11:33,210
barra barra, ya está

259
00:11:33,210 --> 00:11:34,970
ficheros, ya la tengo

260
00:11:34,970 --> 00:11:38,159
vale

261
00:11:38,159 --> 00:11:41,500
entonces esta es una ruta relativa

262
00:11:41,500 --> 00:11:43,360
que es la carpeta

263
00:11:43,360 --> 00:11:45,039
ficheros que cuelga del

264
00:11:45,039 --> 00:11:47,419
de la raíz del proyecto, la carpeta

265
00:11:47,419 --> 00:11:49,440
ficheros, vale, se la estoy pasando a este método

266
00:11:49,440 --> 00:11:51,399
instanciada

267
00:11:51,399 --> 00:11:53,299
como file, se la estoy pasando a este método y ahora este

268
00:11:53,299 --> 00:11:55,320
método es

269
00:11:55,320 --> 00:11:55,700
este

270
00:11:55,700 --> 00:11:58,679
que ya lista el contenido

271
00:11:58,679 --> 00:12:00,659
de esa carpeta que yo le he pasado

272
00:12:00,659 --> 00:12:02,720
y apoyándose en el de arriba

273
00:12:02,720 --> 00:12:04,240
pues ya me devuelve el más grande

274
00:12:04,240 --> 00:12:08,700
pues venga, y ahora podría hacer lo mismo

275
00:12:08,700 --> 00:12:15,700
el fichero de más tamaño

276
00:12:15,700 --> 00:12:17,620
es F2, el que me haya salido

277
00:12:17,620 --> 00:12:28,039
vale, pues entonces si ejecutamos

278
00:12:28,039 --> 00:12:30,080
esto me tendrá que dar el mismo

279
00:12:30,080 --> 00:12:30,899
mensaje dos veces

280
00:12:30,899 --> 00:12:35,139
esto me lo ha hecho

281
00:12:35,139 --> 00:12:37,539
con la primera versión

282
00:12:37,539 --> 00:12:39,740
y esto me lo ha hecho con la segunda

283
00:12:39,740 --> 00:12:40,399
que es lo mismo

284
00:12:40,399 --> 00:12:43,220
vale, que es lo mismo

285
00:12:43,220 --> 00:12:57,269
bueno hasta aquí vamos bien más o menos

286
00:12:57,269 --> 00:13:03,269
vale

287
00:13:03,269 --> 00:13:05,830
entonces el método

288
00:13:05,830 --> 00:13:07,830
listFiles para listar contenido

289
00:13:07,830 --> 00:13:08,970
de un fichero está muy bien

290
00:13:08,970 --> 00:13:12,149
de hecho

291
00:13:12,149 --> 00:13:15,429
voy a hacer para luego dejaros planteado

292
00:13:15,429 --> 00:13:17,009
una cosa ya para que hagáis vosotros

293
00:13:17,009 --> 00:13:19,149
por ejemplo un método

294
00:13:19,149 --> 00:13:21,769
que te muestra por consola

295
00:13:21,769 --> 00:13:23,809
simplemente te muestra por consola

296
00:13:23,809 --> 00:13:25,490
el contenido

297
00:13:25,490 --> 00:13:26,289
de un directorio

298
00:13:26,289 --> 00:13:32,330
listar directorio

299
00:13:32,330 --> 00:13:35,210
y yo le paso aquí un directorio

300
00:13:35,210 --> 00:13:38,789
entonces este sería

301
00:13:38,789 --> 00:13:41,029
sacaría

302
00:13:41,029 --> 00:13:42,990
todo el contenido de ese directorio

303
00:13:42,990 --> 00:13:44,230
con el list files

304
00:13:44,230 --> 00:13:45,929
lo sacaría

305
00:13:45,929 --> 00:13:49,370
y ahora ya podemos recorrerlo y mostrarlo

306
00:13:49,370 --> 00:13:58,009
contenido

307
00:13:58,009 --> 00:14:04,759
f.getname

308
00:14:04,759 --> 00:14:15,159
vale, por ejemplo

309
00:14:15,159 --> 00:14:16,679
este sería como el comando dir

310
00:14:16,679 --> 00:14:19,059
del sistema operativo

311
00:14:19,059 --> 00:14:20,860
como el comando

312
00:14:20,860 --> 00:14:22,559
dir, le pasas un directorio

313
00:14:22,559 --> 00:14:24,500
y te lista todo lo que contiene

314
00:14:24,500 --> 00:14:29,250
porque este método te devolvía

315
00:14:29,250 --> 00:14:31,110
un array de objetos file con lo que tiene

316
00:14:31,110 --> 00:14:32,850
y este

317
00:14:32,850 --> 00:14:34,970
te lo recorre ya lo que tiene

318
00:14:34,970 --> 00:14:38,909
además podemos hacer

319
00:14:38,909 --> 00:14:41,049
para que me diga en el listado

320
00:14:41,049 --> 00:14:43,009
si es fichero o si es directorio

321
00:14:43,009 --> 00:14:44,529
podemos hacer

322
00:14:44,529 --> 00:14:50,860
f.is

323
00:14:50,860 --> 00:14:53,179
es directorio

324
00:14:53,179 --> 00:14:56,120
porque si es directorio

325
00:14:56,120 --> 00:14:57,679
entonces

326
00:14:57,679 --> 00:15:00,940
lo que nos muestre

327
00:15:00,940 --> 00:15:01,700
que sea

328
00:15:01,700 --> 00:15:06,009
f.getName

329
00:15:06,009 --> 00:15:08,830
y si no, que f.getName

330
00:15:08,830 --> 00:15:09,990
concatenado con

331
00:15:09,990 --> 00:15:12,370
f

332
00:15:12,370 --> 00:15:14,509
para que se vea que es un fichero, por ejemplo

333
00:15:14,509 --> 00:15:16,649
y si no, que nos muestre

334
00:15:16,649 --> 00:15:17,950
f.getName

335
00:15:19,950 --> 00:15:21,149
pero concatenado con d

336
00:15:21,149 --> 00:15:24,909
para que se vea que es un directorio

337
00:15:24,909 --> 00:15:28,419
vale, voy a pasar

338
00:15:28,419 --> 00:15:31,080
este paréntesis abajo para que se vea mejor

339
00:15:31,080 --> 00:15:33,220
lo he pasado

340
00:15:33,220 --> 00:15:34,720
aquí abajo, entonces

341
00:15:34,720 --> 00:15:37,059
¿qué me muestra el system.out.println? pues depende

342
00:15:37,059 --> 00:15:39,080
depende

343
00:15:39,080 --> 00:15:40,639
¿f

344
00:15:40,639 --> 00:15:43,019
es un directorio? me hago la pregunta

345
00:15:43,019 --> 00:15:44,539
antes de pasarle el parámetro

346
00:15:44,539 --> 00:15:46,639
¿f es un directorio?

347
00:15:47,080 --> 00:15:49,179
si es un directorio, pues entonces

348
00:15:49,179 --> 00:15:51,299
muéstrame, lo he hecho justo al revés

349
00:15:51,299 --> 00:15:53,039
entonces muéstrame el nombre

350
00:15:53,039 --> 00:15:55,440
seguido de d, ¿no lo es?

351
00:15:55,440 --> 00:15:57,000
pues entonces la alternativa

352
00:15:57,000 --> 00:15:58,659
que será el nombre seguido de f

353
00:15:58,659 --> 00:16:00,659
vale

354
00:16:00,659 --> 00:16:06,809
pues este sería un dir

355
00:16:06,809 --> 00:16:09,210
que le pasas tú un fichero y te muestra

356
00:16:09,210 --> 00:16:11,789
todo lo que hay, si es fichero o es directorio

357
00:16:11,789 --> 00:16:16,539
vale, vamos a probarlo

358
00:16:16,539 --> 00:16:18,360
bueno y vamos a ponerle un barra n

359
00:16:18,360 --> 00:16:20,399
porque si no va a salir todo seguido y va a ser bastante horrible

360
00:16:20,399 --> 00:16:22,559
vamos a ponerle

361
00:16:22,559 --> 00:16:23,860
un barra n por aquí

362
00:16:23,860 --> 00:16:26,440
ah no, que ya tiene

363
00:16:26,440 --> 00:16:28,159
un println, perdón, perdón, no hace falta

364
00:16:28,159 --> 00:16:30,519
porque cada uno se va en la línea distinta

365
00:16:30,519 --> 00:16:31,500
ya tiene el println

366
00:16:31,500 --> 00:16:35,019
vale, vamos a probar este dir

367
00:16:35,019 --> 00:16:36,700
este listar directorio

368
00:16:36,700 --> 00:16:39,200
lo vamos a probar

369
00:16:39,200 --> 00:16:40,960
aquí al final de este código

370
00:16:40,960 --> 00:16:57,179
y lo vamos, ¿qué directorio vamos a listar?

371
00:16:57,299 --> 00:16:58,919
a listar, bueno, vamos a listar el actual

372
00:16:58,919 --> 00:16:59,500
por ejemplo

373
00:16:59,500 --> 00:17:02,940
punto, recordad que punto siempre se refiere

374
00:17:02,940 --> 00:17:04,180
al directorio en el que estoy

375
00:17:04,180 --> 00:17:05,920
vale

376
00:17:05,920 --> 00:17:08,619
punto se refiere al que estoy

377
00:17:08,619 --> 00:17:10,440
pero claro, se lo tengo que pasar como file

378
00:17:10,440 --> 00:17:12,779
new file

379
00:17:12,779 --> 00:17:20,779
vale, pues con este método

380
00:17:20,779 --> 00:17:22,680
estaría listando todo el contenido

381
00:17:22,680 --> 00:17:23,640
¿de qué directorio?

382
00:17:24,220 --> 00:17:25,119
de este

383
00:17:25,119 --> 00:17:27,799
¿y este cuál es? el actual

384
00:17:27,799 --> 00:17:28,980
el actual

385
00:17:28,980 --> 00:17:32,160
¿cuál es? la raíz del proyecto

386
00:17:32,160 --> 00:17:33,740
la raíz del proyecto es

387
00:17:33,740 --> 00:17:35,839
la ruta

388
00:17:35,839 --> 00:17:38,420
por defecto

389
00:17:38,420 --> 00:17:40,740
de la máquina virtual

390
00:17:40,740 --> 00:17:42,200
pues venga

391
00:17:42,200 --> 00:17:43,619
vamos a ver que tiene mi

392
00:17:43,619 --> 00:17:45,500
proyecto

393
00:17:45,500 --> 00:17:50,430
lo ejecutamos

394
00:17:52,670 --> 00:17:59,920
y

395
00:17:59,920 --> 00:18:01,920
tiene, efectivamente tiene

396
00:18:01,920 --> 00:18:05,940
esto que es un fichero, esto que es un fichero, eso que es un fichero

397
00:18:05,940 --> 00:18:08,380
bin que es un directorio

398
00:18:08,380 --> 00:18:12,920
esto que era otro directorio y esto que era otro directorio

399
00:18:12,920 --> 00:18:16,940
efectivamente esto es lo que está contenido dentro de la carpeta de mi

400
00:18:16,940 --> 00:18:18,259
proyecto

401
00:18:18,259 --> 00:18:24,710
me está diciendo si es fichero y directorio

402
00:18:24,710 --> 00:18:26,309
y esto ya

403
00:18:26,309 --> 00:18:28,309
pero esto ya sí que os lo dejo

404
00:18:28,309 --> 00:18:33,269
como trabajo de curiosidad avanzada, entre comillas,

405
00:18:33,430 --> 00:18:35,269
porque en la recursividad no nos hemos metido.

406
00:18:36,529 --> 00:18:41,670
Lo ideal sería hacer un dir que se siga metiendo en todo el árbol de directorios.

407
00:18:42,349 --> 00:18:45,369
Miguel, escucha. Y tú, Kevin, también, que eso me lo tenéis que hacer.

408
00:18:47,930 --> 00:18:52,750
Lo ideal sería modificar listar directorio para que cuando se encuentre un directorio

409
00:18:52,750 --> 00:18:55,430
se vuelva a meter y te saque abajo lo que tiene.

410
00:18:55,990 --> 00:18:57,369
A ser posible tabulado.

411
00:18:57,369 --> 00:19:17,730
Y si dentro del otro directorio se vuelve a meter recursividad, eso. Pues entonces, la mejora estupendísima ya de este método sería la mejora estupendísima de listar directorio.

412
00:19:17,730 --> 00:19:26,650
Esta ya como recibe lo mismo

413
00:19:26,650 --> 00:19:28,529
A este sí que tenemos que darle

414
00:19:28,529 --> 00:19:30,549
Otro nombre

415
00:19:30,549 --> 00:19:41,569
Esta sería

416
00:19:41,569 --> 00:19:44,109
Que muestra

417
00:19:44,109 --> 00:19:46,309
Todo el árbol de directorios

418
00:19:46,309 --> 00:19:48,210
Todo, y si hay una carpeta se mete dentro

419
00:19:48,210 --> 00:20:01,769
¿Vale? Bueno, esto lo dejo ahí

420
00:20:01,769 --> 00:20:04,049
Porque si alguien quiere investigar la recursividad

421
00:20:04,049 --> 00:20:04,549
De ahí hacerlo

422
00:20:04,549 --> 00:20:08,049
Pero no lo digo en general que lo hagáis todos

423
00:20:08,049 --> 00:20:09,809
Bueno

424
00:20:09,809 --> 00:20:12,049
Pues estos son los misterios de la clase

425
00:20:12,049 --> 00:20:14,250
file, que no tiene más que estos

426
00:20:14,250 --> 00:20:16,210
un punto

427
00:20:16,210 --> 00:20:18,069
de mi sistema de archivos, un punto

428
00:20:18,069 --> 00:20:19,789
lo puedo asociar a un objeto file

429
00:20:19,789 --> 00:20:22,009
y ahora ya con ese objeto file puedo

430
00:20:22,009 --> 00:20:24,089
hacer cosas que llegan hasta donde llegan

431
00:20:24,089 --> 00:20:26,150
pues ver los permisos que tengo, el tamaño

432
00:20:26,150 --> 00:20:28,369
ver contenido si es un directorio

433
00:20:28,369 --> 00:20:29,690
algunas cositas de esas ya

434
00:20:29,690 --> 00:20:30,910
poco más, ¿vale?

435
00:20:31,869 --> 00:20:33,890
bueno, pero nosotros habíamos empezado

436
00:20:33,890 --> 00:20:34,549
todo esto

437
00:20:34,549 --> 00:20:39,690
de entrada y salida

438
00:20:39,690 --> 00:20:42,069
y de ficheros para poder hacer aplicaciones

439
00:20:42,069 --> 00:20:44,309
que leyeran el contenido de archivos

440
00:20:44,309 --> 00:20:47,650
y guardaran el resultado en archivos

441
00:20:47,650 --> 00:20:48,869
para eso lo habíamos hecho

442
00:20:48,869 --> 00:20:50,950
la clase file no nos vale para eso

443
00:20:50,950 --> 00:20:53,950
no nos vale para escribir variables dentro de archivos

444
00:20:53,950 --> 00:20:55,789
ni para leer contenido de archivos

445
00:20:55,789 --> 00:20:56,369
las variables

446
00:20:56,369 --> 00:20:58,190
con la clase file

447
00:20:58,190 --> 00:21:02,069
el contenido de estos archivos

448
00:21:02,069 --> 00:21:12,019
estos de aquí

449
00:21:12,019 --> 00:21:12,740
que yo he creado

450
00:21:12,740 --> 00:21:15,759
este contenido con la clase file a él no llego

451
00:21:15,759 --> 00:21:17,039
no llego

452
00:21:17,039 --> 00:21:20,000
Bueno, pues necesitamos otras clases

453
00:21:20,000 --> 00:21:21,720
Otras clases para

454
00:21:21,720 --> 00:21:25,720
Acceder, leer y escribir archivos

455
00:21:25,720 --> 00:21:28,259
Vale, pues vamos a hacerlo en otro paquete

456
00:21:28,259 --> 00:21:30,599
Que en lugar de file se va a llamar

457
00:21:30,599 --> 00:21:31,680
Ahora ya

458
00:21:31,680 --> 00:21:33,880
Entrada-salida o leer-escribir

459
00:21:33,880 --> 00:21:37,819
Lectura-escritura

460
00:21:37,819 --> 00:21:40,019
Porque ahora ya sí que vamos a leer y escribir en archivos

461
00:21:40,019 --> 00:21:46,450
Bueno, pues a ver

462
00:21:46,450 --> 00:21:47,170
Vamos a ver

463
00:21:47,170 --> 00:21:57,059
Ay no, me deja así

464
00:21:57,059 --> 00:22:07,349
bueno, pues a ver

465
00:22:07,349 --> 00:22:11,930
clases para hacer

466
00:22:11,930 --> 00:22:13,690
ahora ya sí, lectura y

467
00:22:13,690 --> 00:22:14,869
escritura en archivos

468
00:22:14,869 --> 00:22:23,619
bueno, pues aquí hay varias cosas

469
00:22:23,619 --> 00:22:25,980
de esta, esto va a ser

470
00:22:25,980 --> 00:22:28,119
repito, una visión muy por

471
00:22:28,119 --> 00:22:30,099
encima, luego ya hay

472
00:22:30,099 --> 00:22:31,960
más clases y más cosas para hacer cosas más

473
00:22:31,960 --> 00:22:34,039
específicas, pero va a ser una visión muy

474
00:22:34,039 --> 00:22:35,720
por encima de la base, de cómo funciona

475
00:22:35,720 --> 00:22:37,319
bueno, pues hay varias cosas

476
00:22:37,319 --> 00:22:39,279
que vamos a ir

477
00:22:39,279 --> 00:22:41,359
dejando claras

478
00:22:41,359 --> 00:22:44,619
primero, lo habitual es que uno

479
00:22:44,619 --> 00:22:48,039
cuando usa un archivo

480
00:22:48,039 --> 00:22:51,059
lo use o solo para leer

481
00:22:51,059 --> 00:22:52,880
o solo para escribir

482
00:22:52,880 --> 00:22:55,539
es decir, yo necesito leer de un archivo

483
00:22:55,539 --> 00:22:58,559
lo abro, como se dice, lo abro, me conecto a él

484
00:22:58,559 --> 00:23:00,700
ahora veremos qué significa abrirlo o conectarse a él

485
00:23:00,700 --> 00:23:04,619
lo abro para leer, leo, recojo y llevo variables

486
00:23:04,619 --> 00:23:06,980
y luego ya lo cierro

487
00:23:06,980 --> 00:23:09,339
y ya está, acaba ese proceso

488
00:23:09,339 --> 00:23:11,980
Ahora no, ahora lo que quiero es escribir

489
00:23:11,980 --> 00:23:14,359
Pues lo abro para escribir

490
00:23:14,359 --> 00:23:18,519
Cojo mis variables y las voy pasando al fichero

491
00:23:18,519 --> 00:23:20,380
Cuando he terminado

492
00:23:20,380 --> 00:23:21,099
Lo cierro

493
00:23:21,099 --> 00:23:24,000
Luego cuando uno se conecta o abre

494
00:23:24,000 --> 00:23:26,259
Ahora veremos qué significa eso en Java

495
00:23:26,259 --> 00:23:27,160
Un fichero

496
00:23:27,160 --> 00:23:28,980
O lo hace para leer

497
00:23:28,980 --> 00:23:31,059
O lo hace para escribir

498
00:23:31,059 --> 00:23:33,819
Más que nada porque si no es un desmadre

499
00:23:33,819 --> 00:23:35,880
Porque tú

500
00:23:35,880 --> 00:23:37,039
Tú estás leyendo

501
00:23:37,039 --> 00:23:38,380
Cuando vas leyendo

502
00:23:38,380 --> 00:23:40,599
vas leyendo secuencialmente

503
00:23:40,599 --> 00:23:42,700
lees este, entonces el puntero interno

504
00:23:42,700 --> 00:23:44,079
se queda en el siguiente carácter

505
00:23:44,079 --> 00:23:46,980
ahora lees este, el puntero interno

506
00:23:46,980 --> 00:23:47,579
se queda aquí

507
00:23:47,579 --> 00:23:49,680
y si ahora mandas a escribir, ¿dónde se escribe?

508
00:23:50,359 --> 00:23:51,880
¿se escribe donde está el puntero de lectura?

509
00:23:51,980 --> 00:23:52,819
¿se escribe desde arriba?

510
00:23:53,599 --> 00:23:56,460
se pueden generar muchos efectos indeseados

511
00:23:56,460 --> 00:23:58,140
entonces hay muy pocas clases

512
00:23:58,140 --> 00:24:00,619
que permitan que un archivo puedas abrirlo

513
00:24:00,619 --> 00:24:02,460
para leer y escribir a la vez, muy pocas

514
00:24:02,460 --> 00:24:05,119
lo normal es que tú tengas

515
00:24:05,119 --> 00:24:06,960
que organizar tus aplicaciones

516
00:24:06,960 --> 00:24:09,420
para decidir cuándo quieres leer

517
00:24:09,420 --> 00:24:11,339
y entonces lees. Ahora ya tengo

518
00:24:11,339 --> 00:24:13,279
la información, hago lo que sea. Ahora

519
00:24:13,279 --> 00:24:15,519
quiero escribir. Pues voy y escribo.

520
00:24:16,160 --> 00:24:17,640
Hay que organizar nuestras aplicaciones

521
00:24:17,640 --> 00:24:19,240
para que el recurso

522
00:24:19,240 --> 00:24:21,579
esté abierto o para recoger

523
00:24:21,579 --> 00:24:22,579
los datos a variables

524
00:24:22,579 --> 00:24:25,500
o para mandar los datos de variables al archivo.

525
00:24:26,339 --> 00:24:27,240
Eso es la primera cosa.

526
00:24:28,160 --> 00:24:29,279
Entonces lo escribimos aquí

527
00:24:29,279 --> 00:24:30,839
de cualquier manera para que

528
00:24:30,839 --> 00:24:34,740
se abre

529
00:24:34,740 --> 00:24:37,359
para leer o

530
00:24:37,359 --> 00:24:39,039
para escribir.

531
00:24:39,559 --> 00:24:41,180
para eso se abre

532
00:24:41,180 --> 00:24:41,839
vale

533
00:24:41,839 --> 00:24:44,279
bueno, pues vamos a

534
00:24:44,279 --> 00:24:47,579
plantearnos primero escribir un archivo

535
00:24:47,579 --> 00:24:49,220
vamos a plantearnos

536
00:24:49,220 --> 00:24:51,299
que tenemos un método, una aplicación

537
00:24:51,299 --> 00:24:53,000
que ha hecho cosas y ahora yo quiero

538
00:24:53,000 --> 00:24:55,519
mis resultados pasarlos a un archivo

539
00:24:55,519 --> 00:24:57,640
vale, pues como escribimos en un archivo

540
00:24:57,640 --> 00:25:00,529
bueno, pues para escribir

541
00:25:00,529 --> 00:25:02,309
en un archivo, tanto las lecturas

542
00:25:02,309 --> 00:25:03,230
como las escrituras

543
00:25:03,230 --> 00:25:05,910
Java tiene dos modos

544
00:25:05,910 --> 00:25:07,630
o el modo byte

545
00:25:07,630 --> 00:25:10,410
que se llama, que es el básico

546
00:25:10,410 --> 00:25:13,069
tú lees byte por byte

547
00:25:13,069 --> 00:25:15,109
porque los ficheros ya sabéis

548
00:25:15,109 --> 00:25:16,970
que son sucesiones de bytes, bueno cada byte

549
00:25:16,970 --> 00:25:19,009
a su vez son 8 bits, pero bueno

550
00:25:19,009 --> 00:25:20,750
el byte es la

551
00:25:20,750 --> 00:25:21,950
unidad

552
00:25:21,950 --> 00:25:24,430
mínima

553
00:25:24,430 --> 00:25:27,130
de transporte, de llevar de acá para allá

554
00:25:27,130 --> 00:25:29,069
datos para cualquier programa

555
00:25:29,069 --> 00:25:30,589
el byte

556
00:25:30,589 --> 00:25:33,230
de hecho tenemos una variable primitiva

557
00:25:33,230 --> 00:25:35,150
que es byte, que permite alojar un byte

558
00:25:35,150 --> 00:25:37,049
que son 8 bits, pero tenemos una variable

559
00:25:37,049 --> 00:25:39,130
primitiva que sea bit, que permite alojar

560
00:25:39,130 --> 00:25:40,930
un bit, esa variable primitiva no existe

561
00:25:40,930 --> 00:25:43,109
o sea, la unidad más pequeñita

562
00:25:43,109 --> 00:25:44,529
en la cual

563
00:25:44,529 --> 00:25:46,849
se puede guardar información

564
00:25:46,849 --> 00:25:49,089
en cualquier lenguaje de programación es el bytes, son 8 bits

565
00:25:49,089 --> 00:25:50,089
el byte, ¿vale?

566
00:25:50,750 --> 00:25:52,930
bueno, pues entonces, Java

567
00:25:52,930 --> 00:25:54,809
considera que tú puedes trabajar de dos modos

568
00:25:54,809 --> 00:25:57,109
o transfiriendo, tanto para

569
00:25:57,109 --> 00:25:58,789
escribir como para leer bytes directamente

570
00:25:58,789 --> 00:26:01,009
o, como se

571
00:26:01,009 --> 00:26:03,250
usan mucho y muy a menudo los ficheros de texto

572
00:26:03,250 --> 00:26:05,549
transfiriendo caracteres

573
00:26:05,549 --> 00:26:07,210
teniendo en cuenta

574
00:26:07,210 --> 00:26:09,170
que son caracteres y por tanto

575
00:26:09,170 --> 00:26:10,789
haciendo las correspondientes

576
00:26:10,789 --> 00:26:13,769
transformaciones para que

577
00:26:13,769 --> 00:26:15,490
el ASCII

578
00:26:15,490 --> 00:26:16,809
siempre se conserve

579
00:26:16,809 --> 00:26:18,329
entonces

580
00:26:18,329 --> 00:26:27,130
es posible

581
00:26:27,130 --> 00:26:29,390
modo byte

582
00:26:29,390 --> 00:26:34,099
o modo carácter

583
00:26:34,099 --> 00:26:41,319
el primer ejemplo que vamos a hacer es en modo carácter

584
00:26:41,319 --> 00:26:43,059
porque es lo más sencillo

585
00:26:43,059 --> 00:26:45,099
para que lo entendamos porque un fichero de texto

586
00:26:45,099 --> 00:26:47,220
como lo podemos abrir y ver

587
00:26:47,220 --> 00:26:48,220
con un editor de notas

588
00:26:48,220 --> 00:26:50,460
con un blog de notas como lo podemos ver

589
00:26:50,460 --> 00:26:52,119
nos va a ser más fácil

590
00:26:52,119 --> 00:26:54,299
al principio entenderlo con un fichero de texto

591
00:26:54,299 --> 00:26:55,579
pero es a los que estamos acostumbrados

592
00:26:55,579 --> 00:26:57,359
un fichero que no es ASCII

593
00:26:57,359 --> 00:27:00,180
tú no lo puedes visualizar con ningún

594
00:27:00,180 --> 00:27:02,079
programa que no sea el fichero que lo hizo

595
00:27:02,079 --> 00:27:03,640
con ningún otro

596
00:27:03,640 --> 00:27:06,039
pero sin embargo un fichero de texto lo puedes

597
00:27:06,039 --> 00:27:08,059
visualizar con cualquier editor de texto

598
00:27:08,059 --> 00:27:10,099
y siempre vas a ver su contenido

599
00:27:10,099 --> 00:27:10,839
sin problemas

600
00:27:10,839 --> 00:27:14,039
pero eso solo pasa con los ficheros de texto

601
00:27:14,039 --> 00:27:16,019
los que tienen ASCII

602
00:27:16,019 --> 00:27:18,359
que lo puedes visualizar con cualquier editor de texto

603
00:27:18,359 --> 00:27:20,099
cualquier otro

604
00:27:20,099 --> 00:27:22,000
fichero que no tenga ASCII

605
00:27:22,000 --> 00:27:24,279
que no esté codificado

606
00:27:24,279 --> 00:27:25,460
con el código ASCII

607
00:27:25,460 --> 00:27:28,059
estará codificado con el código

608
00:27:28,059 --> 00:27:30,000
propio de la aplicación que lo generó

609
00:27:30,000 --> 00:27:32,140
¿no? como un fichero de Word

610
00:27:32,140 --> 00:27:34,400
solo lo puedes visualizar con Word

611
00:27:34,400 --> 00:27:36,299
o con otro que sea capaz de

612
00:27:36,299 --> 00:27:38,460
convertirlo, pero no con un editor de texto

613
00:27:38,460 --> 00:27:40,359
por ejemplo, un fichero de Excel

614
00:27:40,359 --> 00:27:42,500
igual, no tiene código

615
00:27:42,500 --> 00:27:44,240
ASCII, entonces solo lo puedes visualizar con

616
00:27:44,240 --> 00:27:45,740
Excel o aplicaciones compatibles

617
00:27:45,740 --> 00:27:48,380
bueno, pues entonces vamos a empezar

618
00:27:48,380 --> 00:27:50,220
con modo carácter

619
00:27:50,220 --> 00:27:52,119
que nos va a ser lo más fácil de entender

620
00:27:52,119 --> 00:27:53,200
bueno

621
00:27:53,200 --> 00:27:54,960
pues las clases

622
00:27:54,960 --> 00:27:57,619
para leer y escribir

623
00:27:57,619 --> 00:28:00,970
en modo carácter

624
00:28:00,970 --> 00:28:02,250
las clases son

625
00:28:02,250 --> 00:28:04,490
file

626
00:28:04,490 --> 00:28:07,109
reader para leer

627
00:28:07,109 --> 00:28:08,630
ahora vemos como usarlas

628
00:28:08,630 --> 00:28:11,309
y file writer

629
00:28:11,309 --> 00:28:16,180
para escribir

630
00:28:16,180 --> 00:28:18,319
estas son dos clases muy sencillas

631
00:28:18,319 --> 00:28:19,859
de usar y que

632
00:28:19,859 --> 00:28:22,220
sí que se usan porque en cualquier

633
00:28:22,220 --> 00:28:23,680
momento uno tiene un fichero de texto

634
00:28:23,680 --> 00:28:25,980
sea un fichero de propiedades, de proper

635
00:28:25,980 --> 00:28:27,740
que sea un fichero de log, sea lo que sea

636
00:28:27,740 --> 00:28:30,259
y FileReader es una clase sencillísima

637
00:28:30,259 --> 00:28:31,920
para leer el contenido de lo que tiene

638
00:28:31,920 --> 00:28:34,259
bueno, pues vamos

639
00:28:34,259 --> 00:28:35,779
a usar estas clases

640
00:28:35,779 --> 00:28:37,420
vamos primero a escribir un archivo

641
00:28:37,420 --> 00:28:42,690
a ver, pues venga

642
00:28:42,690 --> 00:28:46,630
vamos al otro paquete que teníamos

643
00:28:46,630 --> 00:28:51,160
y vamos a hacernos

644
00:28:51,160 --> 00:28:52,259
una clase nueva

645
00:28:52,259 --> 00:29:00,619
venga, esta clase

646
00:29:00,619 --> 00:29:03,619
ejemplo, lectura

647
00:29:03,619 --> 00:29:05,319
la escritura. Y aquí en métodos lo

648
00:29:05,319 --> 00:29:06,140
metemos todo.

649
00:29:14,039 --> 00:29:15,259
Siempre se me olvida el main.

650
00:29:33,819 --> 00:29:35,940
Nunca, en todos estos meses que llevamos

651
00:29:35,940 --> 00:29:37,819
ya de relación, nadie

652
00:29:37,819 --> 00:29:39,559
me ha preguntado qué es eso.

653
00:29:43,900 --> 00:29:45,519
Sí, pero ¿por qué está ahí? ¿Qué pinta?

654
00:29:46,619 --> 00:29:47,759
¿Qué pinta? Porque es que no lo hemos

655
00:29:47,759 --> 00:29:49,759
usado jamás. ¿Alguna vez lo hemos usado aquí dentro

656
00:29:49,759 --> 00:29:51,900
de ARCS? ¿Este parámetro ARCS? Nunca jamás,

657
00:29:51,960 --> 00:29:53,980
¿verdad? Nadie me lo había preguntado

658
00:29:53,980 --> 00:29:54,599
nunca jamás.

659
00:29:58,000 --> 00:30:02,019
Bueno, pues para pasar, luego lo comentaremos, ¿eh?

660
00:30:02,779 --> 00:30:05,519
Para pasar parámetros en la llamada al programa.

661
00:30:06,140 --> 00:30:06,799
¿Qué está ocurriendo?

662
00:30:07,000 --> 00:30:09,720
Nosotros hasta ahora, siempre que hemos ejecutado el programa,

663
00:30:10,359 --> 00:30:12,259
lo hemos ejecutado, hemos dicho, ejecútate.

664
00:30:12,700 --> 00:30:15,160
Bien con la flechita verde, como fuera.

665
00:30:15,980 --> 00:30:17,240
Pero hemos dicho, ejecútate.

666
00:30:17,740 --> 00:30:19,220
Y ya está, no le hemos dado ninguna información adicional.

667
00:30:19,759 --> 00:30:23,099
Pero cuando uno manda a un programa que tiene método main

668
00:30:23,099 --> 00:30:27,220
a ejecutarse, le puede mandar a ejecutarse

669
00:30:27,220 --> 00:30:31,220
Y además, pasarle unos parámetros adicionales.

670
00:30:32,740 --> 00:30:37,039
Pues esos parámetros adicionales, si yo se los paso, van a caer aquí.

671
00:30:38,160 --> 00:30:41,539
Si yo no se los he pasado, aquí no cae nada.

672
00:30:42,880 --> 00:30:47,380
Vamos a hacer un main simplemente que recorra este array a ver qué tiene.

673
00:30:59,920 --> 00:31:00,920
Uy, perdón, ese.

674
00:31:02,920 --> 00:31:05,319
Vale, voy a ejecutar este programita.

675
00:31:05,319 --> 00:31:07,559
a ver qué me dice que tiene ahí

676
00:31:07,559 --> 00:31:08,880
qué me dice que tiene

677
00:31:08,880 --> 00:31:20,180
pues no tiene nada

678
00:31:20,180 --> 00:31:22,119
porque no le ha pasado nada

679
00:31:22,119 --> 00:31:24,319
pero yo podría llamar a este programa

680
00:31:24,319 --> 00:31:25,680
pasándole parámetros

681
00:31:25,680 --> 00:31:28,619
porque le quiero dar unos parámetros

682
00:31:28,619 --> 00:31:30,259
en función de los cuales a lo mejor

683
00:31:30,259 --> 00:31:32,440
este programa hace una cosa o hace otra

684
00:31:32,440 --> 00:31:33,859
¿vale?

685
00:31:34,220 --> 00:31:35,700
entonces, ¿cómo se los puedo pasar?

686
00:31:35,940 --> 00:31:38,960
si yo ejecutara este programa llamándole por la consola

687
00:31:38,960 --> 00:31:40,420
que eso lo hemos hecho

688
00:31:40,420 --> 00:31:42,079
¿no?

689
00:31:42,079 --> 00:31:44,500
cuando vimos compilar, ejecutar

690
00:31:44,500 --> 00:31:46,700
vimos que uno podía compilar con javac

691
00:31:46,700 --> 00:31:47,819
y el nombre del programa

692
00:31:47,819 --> 00:31:50,759
luego ejecutarlo con java y el nombre del programa

693
00:31:50,759 --> 00:31:52,859
pues si yo lo llamo desde la consola

694
00:31:52,859 --> 00:31:54,759
la ejecución, hago java

695
00:31:54,759 --> 00:31:56,579
y nombre de la clase ya compilada

696
00:31:56,579 --> 00:31:57,759
que eso ya lo hicimos

697
00:31:57,759 --> 00:31:59,859
la forma de pasarle parámetros

698
00:31:59,859 --> 00:32:02,740
sería si los voy pasando separados por espacios

699
00:32:02,740 --> 00:32:04,960
en este caso haría en la consola

700
00:32:04,960 --> 00:32:07,200
java, ejemplo, lectura, escritura

701
00:32:07,200 --> 00:32:09,160
que es el nombre del programa que tiene el main

702
00:32:09,160 --> 00:32:10,619
de la clase que tiene el main y luego le diría

703
00:32:10,619 --> 00:32:12,579
parámetro 1, parámetro 2, parámetro 3

704
00:32:12,579 --> 00:32:14,480
todo eso en la lista de comandos y ya está

705
00:32:14,480 --> 00:32:16,880
y este arc se llenaría de esos

706
00:32:16,880 --> 00:32:19,500
si estoy con el eclipse

707
00:32:19,500 --> 00:32:20,900
o con otro entorno de desarrollo

708
00:32:20,900 --> 00:32:22,759
como yo entonces no ejecuto con la consola

709
00:32:22,759 --> 00:32:23,880
sino con la flechita verde

710
00:32:23,880 --> 00:32:26,259
entonces tengo que configurar

711
00:32:26,259 --> 00:32:28,559
lo que se llama la configuración de ejecución

712
00:32:28,559 --> 00:32:30,420
le dice, y esta ejecución

713
00:32:30,420 --> 00:32:32,279
configúramela, ¿qué quieres meter en ella?

714
00:32:32,400 --> 00:32:33,680
pues en esa configuración de ejecución

715
00:32:33,680 --> 00:32:35,839
que nunca hemos entrado

716
00:32:35,839 --> 00:32:37,180
porque siempre hemos usado por defecto

717
00:32:37,180 --> 00:32:39,700
en esa configuración de ejecución puedo yo decirle

718
00:32:39,700 --> 00:32:41,839
oye, estos parámetros, si es que quiero

719
00:32:41,839 --> 00:32:44,299
entonces esa configuración de ejecución

720
00:32:44,299 --> 00:32:46,359
se verá

721
00:32:46,359 --> 00:32:49,680
en run configurations

722
00:32:49,680 --> 00:32:51,200
¿veis? cuando yo doy a ejecutar

723
00:32:51,200 --> 00:32:52,740
que me sale aquí

724
00:32:52,740 --> 00:32:54,420
o java application o

725
00:32:54,420 --> 00:32:56,680
configuración de ejecución

726
00:32:56,680 --> 00:32:58,740
pues le doy ahí

727
00:32:58,740 --> 00:33:01,160
y fijaos lo que me ha salido

728
00:33:01,160 --> 00:33:04,779
me sale aquí una pestañita

729
00:33:04,779 --> 00:33:06,640
que me dice argumentos

730
00:33:06,640 --> 00:33:08,839
primero ¿veis?

731
00:33:09,259 --> 00:33:10,259
me dice argumentos

732
00:33:10,259 --> 00:33:15,180
y yo aquí en argumentos le puedo escribir

733
00:33:15,180 --> 00:33:17,599
lo que yo quiera, que entiendo, voy a probarlo

734
00:33:17,599 --> 00:33:18,759
que

735
00:33:18,759 --> 00:33:21,579
con ponerse, no sé si separas

736
00:33:21,579 --> 00:33:22,680
por espacio, aquí no

737
00:33:22,680 --> 00:33:25,480
voy a ponerle

738
00:33:25,480 --> 00:33:27,579
venga, param1, param2

739
00:33:28,359 --> 00:33:31,299
param3, estoy poniendo

740
00:33:31,299 --> 00:33:33,019
tal y como yo los pondría en la consola

741
00:33:33,019 --> 00:33:34,660
si llamara mi programa desde la consola

742
00:33:34,660 --> 00:33:37,539
pero no sé si él me lo va a pedir ahora

743
00:33:37,539 --> 00:33:39,500
como él luego lo transforma a consola

744
00:33:39,500 --> 00:33:41,460
no sé si le valdrá así o querrá salto de línea

745
00:33:41,460 --> 00:33:42,480
vamos a probarlo y ya está

746
00:33:42,480 --> 00:33:44,720
venga, estos parámetros

747
00:33:44,720 --> 00:33:49,599
ala, vamos a

748
00:33:49,599 --> 00:33:51,180
ejecutarlo

749
00:33:51,180 --> 00:33:53,279
y a ver que ha pasado

750
00:33:53,279 --> 00:33:55,720
pues aquí están

751
00:33:55,720 --> 00:33:56,759
vale

752
00:33:56,759 --> 00:33:59,500
ahora ya esos tres parámetros

753
00:33:59,500 --> 00:34:01,680
que yo he escrito, se han usado

754
00:34:01,680 --> 00:34:03,720
para rellenar este array

755
00:34:03,720 --> 00:34:05,960
y aquí los tengo

756
00:34:05,960 --> 00:34:10,159
entonces pues

757
00:34:10,159 --> 00:34:12,400
esto en algunos casos puede tener su utilidad

758
00:34:12,400 --> 00:34:14,059
un programa a lo mejor

759
00:34:14,059 --> 00:34:16,480
pues un programa se ejecuta en dos modos

760
00:34:16,480 --> 00:34:18,780
modo admin o modo usuario

761
00:34:18,780 --> 00:34:19,380
por ejemplo

762
00:34:19,380 --> 00:34:20,920
Tiene dos formas de uso

763
00:34:20,920 --> 00:34:22,820
Entonces tú puedes pasarle

764
00:34:22,820 --> 00:34:24,179
La aplicación

765
00:34:24,179 --> 00:34:26,360
La interfaz gráfica o lo que sea

766
00:34:26,360 --> 00:34:28,340
En función de si tu perfil es admin o no

767
00:34:28,340 --> 00:34:30,659
Pues llamará al main

768
00:34:30,659 --> 00:34:33,039
Poniéndole después admin o poniéndole después usuario

769
00:34:33,039 --> 00:34:33,559
Por ejemplo

770
00:34:33,559 --> 00:34:36,219
Y ahora este ya distinguirá en este ans

771
00:34:36,219 --> 00:34:37,920
Si eres admin, si eres usuario

772
00:34:37,920 --> 00:34:40,980
Pues bueno, esto tiene todos los usos que uno quiera darle

773
00:34:40,980 --> 00:34:42,179
¿Vale?

774
00:34:43,800 --> 00:34:44,679
Luego repito

775
00:34:44,679 --> 00:34:46,599
Esto es una manera, una posibilidad

776
00:34:46,599 --> 00:34:48,659
De pasar parámetros al programa

777
00:34:48,659 --> 00:34:49,960
en el momento en el que lo llamas

778
00:34:49,960 --> 00:34:51,539
solo en ese momento

779
00:34:51,539 --> 00:34:55,179
y esos parámetros que siempre son cadenas de texto

780
00:34:55,179 --> 00:34:56,480
irán a este array

781
00:34:56,480 --> 00:34:57,539
y ya está

782
00:34:57,539 --> 00:35:00,480
y tú lo usas si lo necesitas, si te da la gana, lo que sea

783
00:35:00,480 --> 00:35:02,679
pero bueno

784
00:35:02,679 --> 00:35:04,179
nosotros ahora no lo vamos a

785
00:35:04,179 --> 00:35:05,219
no lo estamos usando

786
00:35:05,219 --> 00:35:07,900
entonces vamos a quitar

787
00:35:07,900 --> 00:35:09,500
para que no pierda tiempo

788
00:35:09,500 --> 00:35:11,039
cogiendo parámetros que no va a usar

789
00:35:11,039 --> 00:35:14,139
vamos a quitarle esto

790
00:35:14,139 --> 00:35:15,940
y ya está

791
00:35:15,940 --> 00:35:20,780
vale

792
00:35:20,780 --> 00:35:23,760
Bueno, pues para qué estábamos haciendo este programa

793
00:35:23,760 --> 00:35:24,760
Nuestro nosotros

794
00:35:24,760 --> 00:35:27,920
Primero para escribir un fichero

795
00:35:27,920 --> 00:35:29,760
Pues ahora vamos a hacer un método

796
00:35:29,760 --> 00:35:31,599
Para escribir

797
00:35:31,599 --> 00:35:32,559
En un fichero

798
00:35:32,559 --> 00:35:38,550
Pues una serie

799
00:35:38,550 --> 00:35:41,670
De caracteres que nos dé un usuario

800
00:35:41,670 --> 00:35:44,170
Pues venga

801
00:35:44,170 --> 00:35:47,630
El método nos va a devolver

802
00:35:47,630 --> 00:35:49,590
El objeto

803
00:35:49,590 --> 00:35:51,670
File que ha creado

804
00:35:51,670 --> 00:35:55,090
escribir

805
00:35:55,090 --> 00:35:59,190
fichero

806
00:35:59,190 --> 00:36:04,030
vale

807
00:36:04,030 --> 00:36:10,719
vale, entonces este método

808
00:36:10,719 --> 00:36:11,300
que va a hacer

809
00:36:11,300 --> 00:36:13,300
este método

810
00:36:13,300 --> 00:36:15,800
este método

811
00:36:15,800 --> 00:36:21,650
devuelve un objeto

812
00:36:21,650 --> 00:36:23,829
file

813
00:36:23,829 --> 00:36:25,110
con el

814
00:36:25,110 --> 00:36:27,449
texto que se ha solicitado

815
00:36:27,449 --> 00:36:28,030
al usuario

816
00:36:28,030 --> 00:36:36,760
vale, y vamos a ponerle aquí

817
00:36:36,760 --> 00:36:38,679
un return null para que el compilador

818
00:36:38,679 --> 00:36:41,119
no nos dé la brasa hasta que no acabemos

819
00:36:41,119 --> 00:36:44,219
y

820
00:36:44,219 --> 00:36:46,480
me falta importar, claro

821
00:36:46,480 --> 00:36:48,300
vale

822
00:36:48,300 --> 00:36:53,699
vale, pues entonces

823
00:36:53,699 --> 00:36:56,099
nosotros primero tenemos que

824
00:36:56,099 --> 00:36:57,519
darnos cuenta de que queremos hacer

825
00:36:57,519 --> 00:37:00,260
lo que queremos es pasar información a un

826
00:37:00,260 --> 00:37:01,199
fichero, vale

827
00:37:01,199 --> 00:37:04,239
ahora, ¿esa información son caracteres

828
00:37:04,239 --> 00:37:06,460
de texto? sí, son caracteres

829
00:37:06,460 --> 00:37:08,139
de texto porque es texto que me va a meter el

830
00:37:08,139 --> 00:37:10,059
usuario por la consola, es texto

831
00:37:10,059 --> 00:37:37,599
Vale, pues entonces, la clase que vamos a usar es FileWriter, pues ahora la podemos ya, esta clase, FileWriter, esta referencia es la que vamos a necesitar, y la importamos de Java.io, porque esta clase es la que vale para escribir en un fichero caracteres, esta es, para escribir caracteres en un fichero.

832
00:37:37,599 --> 00:37:41,099
vale, tenemos que instanciarla

833
00:37:41,099 --> 00:37:43,400
para poder usarla, claro, tendremos que instanciarla

834
00:37:43,400 --> 00:37:44,980
bueno, pues de nuevo

835
00:37:44,980 --> 00:37:47,139
FileWriter se instancia con su

836
00:37:47,139 --> 00:37:47,719
constructor

837
00:37:47,719 --> 00:37:50,940
y el constructor

838
00:37:50,940 --> 00:37:53,159
está sobrecargado, admite varias

839
00:37:53,159 --> 00:37:54,860
modalidades

840
00:37:54,860 --> 00:37:57,039
una de ellas, la más básica

841
00:37:57,039 --> 00:37:59,280
es pasarle directamente

842
00:37:59,280 --> 00:38:01,199
un string con el nombre del fichero

843
00:38:01,199 --> 00:38:02,579
en el que yo voy a escribir

844
00:38:02,579 --> 00:38:05,139
por ejemplo, podríamos decirle aquí

845
00:38:05,139 --> 00:38:05,760
el usuario

846
00:38:05,760 --> 00:38:09,500
Introduzca el nombre del fichero

847
00:38:09,500 --> 00:38:17,599
Introduzca el nombre del fichero

848
00:38:17,599 --> 00:38:19,599
Vale, pues entonces él

849
00:38:19,599 --> 00:38:22,760
Vamos a leer con un

850
00:38:22,760 --> 00:38:27,480
Bueno, yo voy a leer con la clase en teclado para no

851
00:38:27,480 --> 00:38:31,699
Tener problemas

852
00:38:31,699 --> 00:38:36,599
Le añado un jar

853
00:38:36,599 --> 00:38:39,260
Que estaba en el escritorio

854
00:38:40,539 --> 00:38:41,099
Ahí

855
00:38:41,099 --> 00:38:44,199
Pero vamos, si lo hacéis con el escáner

856
00:38:44,199 --> 00:38:46,780
Pues venga

857
00:38:46,780 --> 00:38:52,429
Aquí como

858
00:38:52,429 --> 00:38:54,110
El nombre del fichero

859
00:38:54,110 --> 00:38:55,170
Stream

860
00:38:55,170 --> 00:38:58,730
Non fichero

861
00:38:58,730 --> 00:39:01,710
Va a ser igual a

862
00:39:01,710 --> 00:39:04,829
Teclado punto leer cadena

863
00:39:04,829 --> 00:39:06,849
Ala ya está

864
00:39:06,849 --> 00:39:09,269
Ese es el nombre del fichero que ha metido el usuario

865
00:39:09,269 --> 00:39:10,789
Pues venga

866
00:39:10,789 --> 00:39:12,550
Yo ya le puedo pasar directamente aquí

867
00:39:12,550 --> 00:39:13,289
Un stream

868
00:39:13,289 --> 00:39:15,949
Con el nombre del fichero

869
00:39:15,949 --> 00:39:19,659
¿Vale?

870
00:39:20,079 --> 00:39:22,139
entonces ya he instanciado este objeto

871
00:39:22,139 --> 00:39:23,900
y este objeto ya me va a permitir

872
00:39:23,900 --> 00:39:26,219
escribir en un fichero

873
00:39:26,219 --> 00:39:27,139
con este nombre

874
00:39:27,139 --> 00:39:28,820
es para eso

875
00:39:28,820 --> 00:39:32,559
este objeto, para escribir caracteres

876
00:39:32,559 --> 00:39:33,880
en un fichero con este nombre

877
00:39:33,880 --> 00:39:36,199
ahora ya

878
00:39:36,199 --> 00:39:37,920
podría empezar a escribir caracteres

879
00:39:37,920 --> 00:39:40,000
¿por qué me dice el compilador eso?

880
00:39:40,119 --> 00:39:42,699
pues porque FileWriter puede sacar una excepción

881
00:39:42,699 --> 00:39:44,000
de tipo

882
00:39:44,000 --> 00:39:46,159
ioException

883
00:39:46,159 --> 00:39:47,360
entonces las clases

884
00:39:47,360 --> 00:39:49,820
que trabajan con entrada y salida

885
00:39:49,820 --> 00:39:50,960
como las entradas y salidas

886
00:39:50,960 --> 00:39:53,340
son peligrosas porque dependen

887
00:39:53,340 --> 00:39:55,599
que existan recursos externos, ajenos

888
00:39:55,599 --> 00:39:57,639
todas están hechas

889
00:39:57,639 --> 00:39:58,960
para que lancen excepciones

890
00:39:58,960 --> 00:40:01,619
y avisarte, excepción de tipo exception

891
00:40:01,619 --> 00:40:03,539
ni siquiera runtime exception, sino exception

892
00:40:03,539 --> 00:40:04,460
y a ti te avisan

893
00:40:04,460 --> 00:40:07,840
y tú usas este método, en este caso el constructor

894
00:40:07,840 --> 00:40:09,659
usas el método constructor

895
00:40:09,659 --> 00:40:11,059
y te dicen, oye cuidado

896
00:40:11,059 --> 00:40:13,159
que puede salir

897
00:40:13,159 --> 00:40:15,480
te puede salir una

898
00:40:15,480 --> 00:40:17,039
excepción de entrada y salida

899
00:40:17,039 --> 00:40:20,679
porque no esté disponible

900
00:40:20,679 --> 00:40:21,300
algo

901
00:40:21,300 --> 00:40:24,539
vale, pues entonces no te queda más remedio

902
00:40:24,539 --> 00:40:26,719
que o capturar o propagar

903
00:40:26,719 --> 00:40:28,500
ahora mismo por no engrosar

904
00:40:28,500 --> 00:40:30,320
el código y porque quede

905
00:40:30,320 --> 00:40:32,440
claro lo que nos interesa que es la lectura y la escritura

906
00:40:32,440 --> 00:40:34,480
por no engrosarlo vamos a ponerle

907
00:40:34,480 --> 00:40:36,099
un throws, propagamos y ya está

908
00:40:36,099 --> 00:40:38,599
porque si hago un try catch pongo más líneas

909
00:40:38,599 --> 00:40:39,920
de código y se hace más pesado

910
00:40:39,920 --> 00:40:44,269
entonces la propago, throws exception y ya está

911
00:40:44,269 --> 00:40:45,150
vale

912
00:40:45,150 --> 00:40:46,750
bueno pues ahora

913
00:40:46,750 --> 00:40:52,289
ahora ya, ¿qué tendríamos que hacerle?

914
00:40:52,349 --> 00:40:53,489
pues pedirle al usuario

915
00:40:53,489 --> 00:40:55,909
que vaya introduciendo las líneas

916
00:40:55,909 --> 00:40:58,409
las líneas que va a querer ir escribiendo

917
00:40:58,409 --> 00:41:00,329
en el fichero, pues venga, se lo podemos decir

918
00:41:00,329 --> 00:41:00,769
así

919
00:41:00,769 --> 00:41:02,630
ala

920
00:41:02,630 --> 00:41:06,550
introduzca texto

921
00:41:06,550 --> 00:41:08,349
y le podemos decir

922
00:41:08,349 --> 00:41:10,309
que introduzca fin cuando ya quiera terminar

923
00:41:10,309 --> 00:41:12,070
de introducir el contenido en el fichero

924
00:41:12,070 --> 00:41:16,639
fin para terminar

925
00:41:16,639 --> 00:41:19,579
Terminar, por ejemplo.

926
00:41:20,420 --> 00:41:22,880
Vale, pues ahora ya empezaría un bucle que está todo el rato.

927
00:41:23,599 --> 00:41:25,659
Leyendo línea, mandando al fichero.

928
00:41:25,900 --> 00:41:27,679
Leyendo línea, mandando al fichero.

929
00:41:27,760 --> 00:41:29,300
Leyendo línea, mandando al fichero.

930
00:41:30,139 --> 00:41:32,860
Así mientras la línea leída sea diferente de fin.

931
00:41:33,719 --> 00:41:33,960
¿Vale?

932
00:41:35,219 --> 00:41:40,559
Bueno, pues entonces ahora ya podemos hacer lo siguiente.

933
00:41:40,699 --> 00:41:41,820
Aquí la línea leída.

934
00:41:45,570 --> 00:41:47,809
Inicialmente vacío, por ejemplo.

935
00:41:47,809 --> 00:41:52,590
Y ahora, mientras línea no sea fin

936
00:41:52,590 --> 00:41:58,469
O sea, leemos la primera, perdón

937
00:41:58,469 --> 00:42:01,630
Leo la primera línea

938
00:42:01,630 --> 00:42:07,699
Mientras línea sea diferente de fin

939
00:42:07,699 --> 00:42:10,300
Que es la marca que dice el usuario cuando ya ha terminado

940
00:42:10,300 --> 00:42:14,420
Pues mientras sea diferente de fin, ¿qué tenemos que hacer aquí?

941
00:42:15,300 --> 00:42:18,519
Escribir esa línea leída y leer la siguiente

942
00:42:18,519 --> 00:42:30,900
esta sería la estructura de mi programa

943
00:42:30,900 --> 00:42:33,440
escribo esa línea

944
00:42:33,440 --> 00:42:34,599
y leo la siguiente

945
00:42:34,599 --> 00:42:36,219
sigue siendo diferente de fin

946
00:42:36,219 --> 00:42:38,739
escribo la línea y leo la siguiente

947
00:42:38,739 --> 00:42:40,000
sigue siendo diferente de fin

948
00:42:40,000 --> 00:42:41,380
escribo la línea y leo la siguiente

949
00:42:41,380 --> 00:42:44,000
he leído la primera fuera

950
00:42:44,000 --> 00:42:45,739
porque si la primera ya es fin

951
00:42:45,739 --> 00:42:47,039
directamente no escribo nada

952
00:42:47,039 --> 00:42:48,420
fin es solo la marca

953
00:42:48,420 --> 00:42:51,840
bueno pues entonces

954
00:42:51,840 --> 00:42:53,199
leer la siguiente

955
00:42:53,199 --> 00:42:55,079
es esto otra vez

956
00:42:55,079 --> 00:42:57,420
leer la siguiente tiene poco que pensar

957
00:42:57,420 --> 00:42:59,760
leer la siguiente es esto

958
00:42:59,760 --> 00:43:02,659
y ahora, ¿cómo escribo una línea en el fichero?

959
00:43:02,739 --> 00:43:04,619
pues para eso tengo el objeto

960
00:43:04,619 --> 00:43:05,480
fw

961
00:43:05,480 --> 00:43:07,980
que sirve para escribir

962
00:43:07,980 --> 00:43:09,920
¿qué métodos tiene?

963
00:43:12,500 --> 00:43:14,119
pues bueno, se trata de ver qué métodos tiene

964
00:43:14,119 --> 00:43:15,679
a ver cuál me es interesante

965
00:43:15,679 --> 00:43:18,340
pues aquí si uno se pone

966
00:43:18,340 --> 00:43:19,239
a mirar

967
00:43:19,239 --> 00:43:21,820
pues los que empiezan por write

968
00:43:21,820 --> 00:43:23,900
tiene toda la pinta que son los que son para escribir

969
00:43:23,900 --> 00:43:26,000
vale, son los que son

970
00:43:26,000 --> 00:43:26,559
para escribir

971
00:43:26,559 --> 00:43:29,300
y tengo

972
00:43:29,300 --> 00:43:30,880
uno, great string

973
00:43:30,880 --> 00:43:33,039
que tiene toda la pinta que me escribe

974
00:43:33,039 --> 00:43:35,400
directamente todo un string

975
00:43:35,400 --> 00:43:36,619
todo un string en el fichero

976
00:43:36,619 --> 00:43:39,219
pues esa estaría bien utilizarla

977
00:43:39,219 --> 00:43:40,579
porque es justo lo que quiero, un string

978
00:43:40,579 --> 00:43:44,739
tengo otra que es great

979
00:43:44,739 --> 00:43:46,559
que solo admite

980
00:43:46,559 --> 00:43:49,460
una variable, esto es para escribir un carácter

981
00:43:49,460 --> 00:43:50,179
de uno en uno

982
00:43:50,179 --> 00:43:54,780
diréis, ¿y por qué

983
00:43:54,780 --> 00:43:56,820
lo mete como int en vez de como c?

984
00:43:58,019 --> 00:43:59,139
porque se lo tienes que dar

985
00:43:59,139 --> 00:44:01,000
como int, aunque el char vaya

986
00:44:01,000 --> 00:44:02,860
en el menos significativo.

987
00:44:02,980 --> 00:44:04,780
¿Por qué? Lo entenderemos cuando veamos

988
00:44:04,780 --> 00:44:05,280
cómo lee.

989
00:44:08,849 --> 00:44:10,369
Vale, pero de los que hay,

990
00:44:10,449 --> 00:44:12,309
por ejemplo, este, le pasas un array

991
00:44:12,309 --> 00:44:13,869
de char, tiene toda la pinta, un array de char,

992
00:44:13,909 --> 00:44:15,230
y te escribe un array de char, estupendo.

993
00:44:16,289 --> 00:44:18,170
Este tiene toda la pinta, si uno mira

994
00:44:18,170 --> 00:44:20,429
en la ayuda, que le pasas un array de char,

995
00:44:21,429 --> 00:44:22,389
una posición

996
00:44:22,389 --> 00:44:24,030
de partida y una cantidad,

997
00:44:24,710 --> 00:44:26,210
y te escribe de ese array de char

998
00:44:26,210 --> 00:44:28,550
desde esa posición, esa cantidad.

999
00:44:29,650 --> 00:44:30,289
Bueno, diferentes

1000
00:44:30,289 --> 00:44:32,409
Variantes de write, write está sobrecargado

1001
00:44:32,409 --> 00:44:33,150
Tiene diferentes

1002
00:44:33,150 --> 00:44:35,670
Pero esta es la que más nos gusta

1003
00:44:35,670 --> 00:44:37,869
Porque le pasamos un string directamente

1004
00:44:37,869 --> 00:44:40,030
Y me lo escribe

1005
00:44:40,030 --> 00:44:45,159
Bueno, pues entonces

1006
00:44:45,159 --> 00:44:46,260
¿Qué hace

1007
00:44:46,260 --> 00:44:48,679
El método write?

1008
00:44:49,219 --> 00:44:50,920
Mueve, o sea, cuando mueve

1009
00:44:50,920 --> 00:44:53,179
No interpretéis que lo saca del string, ¿no?

1010
00:44:53,199 --> 00:44:54,460
Línea se queda teniendo lo que tiene

1011
00:44:54,460 --> 00:44:55,940
O sea, lo que hay en línea

1012
00:44:55,940 --> 00:44:58,119
Lo lleva al archivo

1013
00:44:58,119 --> 00:44:59,840
Entonces

1014
00:44:59,840 --> 00:45:03,440
Silencio por ahí atrás

1015
00:45:03,440 --> 00:45:10,739
Pero, si este es mi archivo

1016
00:45:10,739 --> 00:45:17,960
¿Dónde están aquí los cuadraditos?

1017
00:45:18,079 --> 00:45:18,460
Ah, aquí

1018
00:45:18,460 --> 00:45:24,039
Vale, imaginaos que este es mi archivo

1019
00:45:24,039 --> 00:45:25,019
¿Vale?

1020
00:45:25,599 --> 00:45:28,420
Y este es mi variable string

1021
00:45:28,420 --> 00:45:32,780
Esta es mi variable string

1022
00:45:32,780 --> 00:45:33,519
Esta es línea

1023
00:45:33,519 --> 00:45:46,179
No se le da igual

1024
00:45:46,179 --> 00:45:48,219
Vale

1025
00:45:48,219 --> 00:45:51,400
Esta es mi variable string, este es mi fichero

1026
00:45:51,400 --> 00:45:53,239
Entonces, el primer write

1027
00:45:53,239 --> 00:45:54,420
me llevará

1028
00:45:54,420 --> 00:45:56,679
el primer white me llevará

1029
00:45:56,679 --> 00:45:58,900
esto

1030
00:45:58,900 --> 00:46:00,059
al fichero

1031
00:46:00,059 --> 00:46:03,239
¿y dónde se queda posicionado en la siguiente lectura?

1032
00:46:03,360 --> 00:46:04,900
se queda posicionado después

1033
00:46:04,900 --> 00:46:06,260
de donde acabó

1034
00:46:06,260 --> 00:46:09,420
ahora, la siguiente vez que llevo línea

1035
00:46:09,420 --> 00:46:10,739
lo lleva

1036
00:46:10,739 --> 00:46:12,380
a continuación

1037
00:46:12,380 --> 00:46:14,079
e internamente este fichero

1038
00:46:14,079 --> 00:46:16,099
sin que nosotros tengamos que gestionar nada

1039
00:46:16,099 --> 00:46:18,119
si que tengamos que gestionar nada

1040
00:46:18,119 --> 00:46:19,699
se queda posicionado

1041
00:46:19,699 --> 00:46:22,239
después de la última escritura, se queda aquí a la espera

1042
00:46:22,239 --> 00:46:25,079
ahora, vuelvo a hacer un

1043
00:46:25,079 --> 00:46:27,000
write línea, pues esta línea

1044
00:46:27,000 --> 00:46:28,519
se viene aquí

1045
00:46:28,519 --> 00:46:31,119
e internamente, sin que tengamos que gestionar

1046
00:46:31,119 --> 00:46:33,119
nada, este fichero se queda

1047
00:46:33,119 --> 00:46:35,300
posicionado para escribir después

1048
00:46:35,300 --> 00:46:37,260
con lo cual

1049
00:46:37,260 --> 00:46:38,880
las líneas se van escribiendo

1050
00:46:38,880 --> 00:46:41,199
una debajo de la otra, yo no tengo que gestionar

1051
00:46:41,199 --> 00:46:43,139
que el fichero internamente se vaya

1052
00:46:43,139 --> 00:46:45,199
posicionando para que se vaya

1053
00:46:45,199 --> 00:46:46,119
escribiendo, no, no

1054
00:46:46,119 --> 00:46:48,159
él lleva avanzando, vale

1055
00:46:48,159 --> 00:46:52,099
entonces, vamos a probar

1056
00:46:52,099 --> 00:46:54,219
antes de descansar este

1057
00:46:54,219 --> 00:46:57,239
este método

1058
00:46:57,239 --> 00:46:59,219
entonces

1059
00:46:59,219 --> 00:47:00,980
vamos a terminar el método

1060
00:47:00,980 --> 00:47:02,980
una vez que

1061
00:47:02,980 --> 00:47:04,760
hemos terminado de escribir

1062
00:47:04,760 --> 00:47:06,420
que este objeto ha terminado

1063
00:47:06,420 --> 00:47:08,619
conviene cerrarlo

1064
00:47:08,619 --> 00:47:16,829
efectivamente

1065
00:47:16,829 --> 00:47:20,869
entonces una vez que hemos terminado

1066
00:47:20,869 --> 00:47:21,989
y ya no vamos a usar más

1067
00:47:21,989 --> 00:47:23,030
ya no vamos a escribir más

1068
00:47:23,030 --> 00:47:25,010
el recurso de este FileWriter

1069
00:47:25,010 --> 00:47:26,550
se debería cerrar

1070
00:47:26,550 --> 00:47:29,329
luego, esto es el equivalente a abrir

1071
00:47:29,329 --> 00:47:31,070
entre comillas, instanciar

1072
00:47:31,070 --> 00:47:33,730
este asociado a un fichero, el equivalente a abrir

1073
00:47:33,730 --> 00:47:35,329
con este escribimos

1074
00:47:35,329 --> 00:47:36,349
todo lo que haya que escribir

1075
00:47:36,349 --> 00:47:39,429
y ahora deberíamos cerrarlo

1076
00:47:39,429 --> 00:47:41,289
entonces, ¿cómo se cierra un recurso?

1077
00:47:41,630 --> 00:47:43,230
pues así, con close

1078
00:47:43,230 --> 00:47:44,389
ya está cerrado

1079
00:47:44,389 --> 00:47:47,670
y ahora tenemos que devolver

1080
00:47:47,670 --> 00:47:49,170
con orden retorno el file

1081
00:47:49,170 --> 00:47:50,769
del fichero que hemos creado

1082
00:47:50,769 --> 00:47:53,110
bueno, pues no pasa nada

1083
00:47:53,110 --> 00:47:54,510
ahora ya devolvemos

1084
00:47:54,510 --> 00:47:56,750
return

1085
00:47:56,750 --> 00:47:59,469
que ya lo hemos oído

1086
00:47:59,469 --> 00:48:05,800
nom fichero

1087
00:48:05,800 --> 00:48:07,639
vale

1088
00:48:07,639 --> 00:48:09,559
ya nos devuelve el file

1089
00:48:09,559 --> 00:48:12,360
asociado a ese fichero que acabamos de

1090
00:48:12,360 --> 00:48:14,280
escribir, este de aquí

1091
00:48:14,280 --> 00:48:16,829
vale

1092
00:48:16,829 --> 00:48:19,630
a ver, como yo no le he asociado

1093
00:48:19,630 --> 00:48:21,630
a ninguna ruta antes, no le he puesto ninguna ruta

1094
00:48:21,630 --> 00:48:23,630
antes, lo va a meter en la misma

1095
00:48:23,630 --> 00:48:24,650
raíz del proyecto

1096
00:48:24,650 --> 00:48:27,650
en la misma raíz del proyecto, porque yo estoy pasando el nombre del fichero

1097
00:48:27,650 --> 00:48:28,610
sin más, la misma raíz

1098
00:48:28,610 --> 00:48:31,750
Bueno, a menos que cuando meta aquí el nombre

1099
00:48:31,750 --> 00:48:33,369
Lo meta con otra ruta, claro

1100
00:48:33,369 --> 00:48:35,329
Entonces vamos a probarlo

1101
00:48:35,329 --> 00:48:36,469
Llamándolo desde este main

1102
00:48:36,469 --> 00:48:39,989
En este caso sí que vamos a ponerle ya un static

1103
00:48:39,989 --> 00:48:41,829
Para no andar ahí

1104
00:48:41,829 --> 00:48:43,929
A ver

1105
00:48:43,929 --> 00:48:47,349
Escribir

1106
00:48:47,349 --> 00:48:49,750
Fichero

1107
00:48:49,750 --> 00:48:52,730
Me devuelve el file

1108
00:48:52,730 --> 00:48:54,809
En realidad no hace falta

1109
00:48:54,809 --> 00:48:57,610
Porque yo veré en la carpeta que el fichero se ha creado

1110
00:48:57,610 --> 00:49:00,809
Pero bueno, vamos a comprobarlo así

1111
00:49:00,809 --> 00:49:05,050
Si escribir fichero es diferente de null

1112
00:49:05,050 --> 00:49:09,489
Esto será que ha creado el objeto file correctamente

1113
00:49:09,489 --> 00:49:10,489
Que hace este

1114
00:49:10,489 --> 00:49:14,630
Vamos a probarlo así

1115
00:49:14,630 --> 00:49:18,090
Pues entonces haríamos

1116
00:49:18,090 --> 00:49:23,909
Se ha creado archivo de nombre

1117
00:49:23,909 --> 00:49:26,610
¿Y el nombre cuál va a ser?

1118
00:49:26,610 --> 00:49:27,929
pues el nombre de

1119
00:49:27,929 --> 00:49:30,409
de este file

1120
00:49:30,409 --> 00:49:31,590
que no lo guardo en ningún sitio

1121
00:49:31,590 --> 00:49:39,670
file f

1122
00:49:39,670 --> 00:49:42,710
siendo f igual a escribir

1123
00:49:42,710 --> 00:49:43,269
fichero

1124
00:49:43,269 --> 00:49:49,340
es diferente de null

1125
00:49:49,340 --> 00:49:51,260
entonces se ha creado el archivo de nombre

1126
00:49:51,260 --> 00:49:55,260
f.getName

1127
00:49:56,000 --> 00:50:02,360
vale

1128
00:50:02,360 --> 00:50:04,059
es decir, llamo al método

1129
00:50:04,059 --> 00:50:06,820
que escribirá, guardo el file

1130
00:50:06,820 --> 00:50:08,860
de vuelta, ya de paso que lo llamo lo guardo

1131
00:50:08,860 --> 00:50:10,619
ahora todo ese file

1132
00:50:10,619 --> 00:50:12,699
que me ha devuelto si es diferente de null

1133
00:50:12,699 --> 00:50:14,739
Dime, has creado el archivo

1134
00:50:14,739 --> 00:50:16,500
De nombre, vamos a ver que nombre es

1135
00:50:16,500 --> 00:50:18,519
¿Por qué me aparece en rojo?

1136
00:50:22,150 --> 00:50:22,329
¿Eh?

1137
00:50:23,750 --> 00:50:25,269
Claro, porque escribir fichero

1138
00:50:25,269 --> 00:50:26,750
Hace un throws como una casa

1139
00:50:26,750 --> 00:50:28,530
Entonces este lo captura, lo propaga

1140
00:50:28,530 --> 00:50:31,489
Vamos a propagarlo para que el código sea más cortito

1141
00:50:31,489 --> 00:50:32,570
Y me lo manda al main ya

1142
00:50:32,570 --> 00:50:35,809
Venga, pues vamos a ejecutar esto

1143
00:50:35,809 --> 00:50:39,159
Nombre del fichero

1144
00:50:39,159 --> 00:50:39,880
Que vamos a crear

1145
00:50:39,880 --> 00:50:42,539
Pues venga, se va a llamar líneas

1146
00:50:42,539 --> 00:50:44,460
Introduzca texto

1147
00:50:44,460 --> 00:50:47,199
Pues hola Dios

1148
00:50:47,199 --> 00:50:51,300
Y fin

1149
00:50:51,300 --> 00:50:53,139
Terminó

1150
00:50:53,139 --> 00:50:55,260
Se ha creado un archivo de nombre líneas

1151
00:50:55,260 --> 00:50:58,860
Vamos a ver si se ha creado un archivo de nombre líneas

1152
00:50:58,860 --> 00:51:00,880
Tiene que estar en la raíz del proyecto

1153
00:51:00,880 --> 00:51:03,400
Nos vamos al proyecto

1154
00:51:03,400 --> 00:51:04,860
Vamos a darle un refresh

1155
00:51:04,860 --> 00:51:10,050
Botón derecho refresh para que se refresque

1156
00:51:10,050 --> 00:51:11,050
Y efectivamente

1157
00:51:11,050 --> 00:51:12,969
Nos ha aparecido

1158
00:51:12,969 --> 00:51:17,309
Nos ha aparecido aquí abajo un ficherito

1159
00:51:17,309 --> 00:51:21,360
Si lo abrimos

1160
00:51:21,360 --> 00:51:23,239
Tiene las líneas

1161
00:51:23,239 --> 00:51:25,260
Todas seguidas porque es que no he insertado

1162
00:51:25,260 --> 00:51:26,639
Saltos de línea barra n

1163
00:51:26,639 --> 00:51:28,719
Hubiera sido más bonito

1164
00:51:28,719 --> 00:51:31,059
Si hubiéramos hecho este

1165
00:51:31,059 --> 00:51:32,320
Código

1166
00:51:32,320 --> 00:51:37,440
Si hubiéramos hecho este código con

1167
00:51:37,440 --> 00:51:42,150
Cada vez que metíamos

1168
00:51:42,150 --> 00:51:43,710
Un string de estos

1169
00:51:43,710 --> 00:51:46,449
F write línea

1170
00:51:46,449 --> 00:51:48,389
Hubiéramos concatenado la línea

1171
00:51:48,389 --> 00:51:50,010
Con barra n

1172
00:51:50,010 --> 00:51:53,719
Entonces se hubiera escrito mejor

1173
00:51:53,719 --> 00:51:54,360
En el fichero

1174
00:51:54,360 --> 00:51:58,159
¿Verdad? Si lo volvemos a ejecutar

1175
00:51:58,159 --> 00:52:00,400
Introduzca nombre del fichero

1176
00:52:00,400 --> 00:52:01,440
Líneas

1177
00:52:01,440 --> 00:52:05,760
Fin

1178
00:52:05,760 --> 00:52:09,280
Se ha creado el archivo

1179
00:52:09,280 --> 00:52:10,380
Vamos a mirarlo

1180
00:52:10,380 --> 00:52:12,360
Este ya sí

1181
00:52:12,360 --> 00:52:13,920
Ya se ha creado más bonito

1182
00:52:13,920 --> 00:52:17,280
Venga, pues ahora sí que vamos a parar aquí un momentito