1
00:00:00,000 --> 00:00:02,459
Venga, vamos allá.

2
00:00:03,600 --> 00:00:11,119
Vale, vamos a hacer una pequeña introducción al acceso a ficheros.

3
00:00:14,300 --> 00:00:19,179
Sí, bueno, entrar dentro de nuestros contenidos, pero vamos a hacerlo a modo de pequeña introducción.

4
00:00:19,179 --> 00:00:30,519
yo estoy

5
00:00:30,519 --> 00:00:32,119
contenta

6
00:00:32,119 --> 00:00:34,979
en general estoy contenta

7
00:00:34,979 --> 00:00:38,820
sí, estoy contenta en general

8
00:00:38,820 --> 00:00:42,539
y todavía queda un mes y pico de curso

9
00:00:42,539 --> 00:00:46,299
para llevarse más alegrías

10
00:00:46,299 --> 00:00:48,179
entonces bueno

11
00:00:48,179 --> 00:00:49,899
¿Estás feliz con este curso?

12
00:00:50,740 --> 00:00:51,700
Yo sí

13
00:00:51,700 --> 00:00:52,880
¿Y tú? ¿Tú cómo estás?

14
00:00:54,979 --> 00:00:56,259
¿Y tú cómo estás?

15
00:00:58,179 --> 00:00:59,320
Vale, pues entonces

16
00:00:59,320 --> 00:01:01,299
como ahora ya que hemos confirmado que estamos

17
00:01:01,299 --> 00:01:03,380
todos contentos, vamos con

18
00:01:03,380 --> 00:01:05,480
la introducción, una pequeña introducción

19
00:01:05,480 --> 00:01:06,480
a César Ficheros, ¿vale?

20
00:01:07,920 --> 00:01:09,900
Sí, eso no demuestra

21
00:01:09,900 --> 00:01:11,019
nada, que yo esté contenta

22
00:01:11,019 --> 00:01:13,340
no significa estar contentísima con todo su peso

23
00:01:13,340 --> 00:01:16,319
Bueno

24
00:01:16,319 --> 00:01:27,840
Bueno, nuestra aplicación de Java

25
00:01:27,840 --> 00:01:30,260
Estábamos en Java, ¿verdad?

26
00:01:30,939 --> 00:01:32,120
Sí, pues en realidad

27
00:01:32,120 --> 00:01:33,280
Da un poco igual en lo que estemos

28
00:01:33,280 --> 00:01:36,000
Pero Java es más completo

29
00:01:36,000 --> 00:01:36,819
Lo tiene todo

30
00:01:36,819 --> 00:01:38,260
Entonces si uno programa en Java

31
00:01:38,260 --> 00:01:39,859
Programa en casi cualquier otra cosa

32
00:01:39,859 --> 00:01:41,840
Bueno, pues nuestra aplicación

33
00:01:41,840 --> 00:01:44,000
Eso

34
00:01:44,000 --> 00:01:58,400
Pues nuestra aplicación Java, ya sabéis que como cualquier aplicación en cualquier otro programa, solamente puede trabajar silencio con datos que estén en su memoria RAM, ¿vale?

35
00:01:58,920 --> 00:02:05,359
Las variables que tenemos aquí, ya sabemos que estas variables están alojadas en la memoria RAM y ahí están los datos.

36
00:02:05,700 --> 00:02:13,719
Nosotros las declaramos, les damos un nombre y operamos con ellas, las mostramos por consola y poco más, ¿vale?

37
00:02:14,000 --> 00:02:34,520
Entonces, ¿de dónde proceden los datos de esas variables? Pues de donde los requisitos de la aplicación te digan. Hasta ahora para nosotros los datos de la aplicación siempre procedían de aplicación que solicita por consola bla bla bla y con esos datos hace bla bla bla.

38
00:02:34,520 --> 00:02:37,319
entonces nuestras aplicaciones hasta ahora

39
00:02:37,319 --> 00:02:38,500
tenían una limitación

40
00:02:38,500 --> 00:02:40,219
lógicamente enorme

41
00:02:40,219 --> 00:02:43,539
de que en tiempo real cuando la aplicación había arrancado

42
00:02:43,539 --> 00:02:45,340
tenía que estar alguien

43
00:02:45,340 --> 00:02:46,659
ahí enfrente sentado

44
00:02:46,659 --> 00:02:49,319
pidiendo los datos que se iban solicitando

45
00:02:49,319 --> 00:02:50,819
bien por consola

46
00:02:50,819 --> 00:02:52,340
si la aplicación era por consola

47
00:02:52,340 --> 00:02:55,139
o bien colocándolo en las áreas de texto

48
00:02:55,139 --> 00:02:57,240
o si era por interfaz gráfica

49
00:02:57,240 --> 00:02:58,520
entonces esa es una

50
00:02:58,520 --> 00:03:01,419
la limitación que hemos tenido hasta ahora con nuestras aplicaciones

51
00:03:01,419 --> 00:03:03,259
que en el tiempo real, en tiempo de ejecución

52
00:03:03,259 --> 00:03:04,219
alguien tiene que estar ahí

53
00:03:04,219 --> 00:03:06,800
dando respuesta a las peticiones

54
00:03:06,800 --> 00:03:07,379
de los datos

55
00:03:07,379 --> 00:03:10,919
primera pega

56
00:03:10,919 --> 00:03:12,180
segunda pega

57
00:03:12,180 --> 00:03:14,620
que ya como ya sabéis cuando el programa

58
00:03:14,620 --> 00:03:16,800
termina toda la memoria

59
00:03:16,800 --> 00:03:18,020
RAM se libera

60
00:03:18,020 --> 00:03:20,539
entonces todos los datos con los que la aplicación

61
00:03:20,539 --> 00:03:22,419
ha trabajado pues se han liberado

62
00:03:22,419 --> 00:03:23,219
y se han ido a la basura

63
00:03:23,219 --> 00:03:26,360
si alguien ha estado delante

64
00:03:26,360 --> 00:03:28,419
mirándolos en consola

65
00:03:28,419 --> 00:03:30,199
y le ha dado tiempo a tomar nota

66
00:03:30,199 --> 00:03:32,419
pues estupendo, pero si no ha habido nadie

67
00:03:32,419 --> 00:03:34,639
delante para mirarlos y tomar nota

68
00:03:34,639 --> 00:03:35,979
pues esos datos se han perdido

69
00:03:35,979 --> 00:03:38,139
¿vale? bueno

70
00:03:38,139 --> 00:03:40,439
obviamente en una aplicación real este no es

71
00:03:40,439 --> 00:03:42,539
el proceder, está claro, en una aplicación

72
00:03:42,539 --> 00:03:44,479
real ya sabemos

73
00:03:44,479 --> 00:03:46,159
que los datos

74
00:03:46,159 --> 00:03:48,560
estarán en una base de datos y así

75
00:03:48,560 --> 00:03:50,539
no se van a perder y aparte

76
00:03:50,539 --> 00:03:51,939
podrá haber muchísimos

77
00:03:51,939 --> 00:03:54,039
porque una base de datos permite un

78
00:03:54,039 --> 00:03:56,319
volumen de datos enorme, podrá haber muchísimos

79
00:03:56,319 --> 00:03:58,919
y además podrán estar estructurados

80
00:03:58,919 --> 00:04:00,419
porque los datos no son una caja

81
00:04:00,419 --> 00:04:02,520
con todo así a mogollón, los datos

82
00:04:02,520 --> 00:04:03,759
si no tienen una estructura

83
00:04:03,759 --> 00:04:06,280
es muy complicado de manejar

84
00:04:06,280 --> 00:04:07,319
entonces como

85
00:04:07,319 --> 00:04:08,740
esto es nuestro

86
00:04:08,740 --> 00:04:12,139
uy Cristian, fuera de ahí

87
00:04:12,139 --> 00:04:13,039
ay Cristian

88
00:04:13,039 --> 00:04:16,779
bienvenido a tu compañero

89
00:04:16,779 --> 00:04:17,639
bienvenido

90
00:04:17,639 --> 00:04:21,300
bueno

91
00:04:21,300 --> 00:04:24,360
entonces los datos no son

92
00:04:24,360 --> 00:04:26,740
solo, ala, una cosa ahí a mogollón

93
00:04:26,740 --> 00:04:28,279
que la aplicación

94
00:04:28,279 --> 00:04:30,379
haga con ellos lo que buenamente

95
00:04:30,379 --> 00:04:32,459
pueda. Si fuera así, las aplicaciones

96
00:04:32,459 --> 00:04:34,560
se complicarían muchísimo. Los datos

97
00:04:34,560 --> 00:04:36,279
están en una base de datos

98
00:04:36,279 --> 00:04:38,480
que además, como habéis estudiado

99
00:04:38,480 --> 00:04:40,519
a lo largo de todo el curso en bases de datos,

100
00:04:41,199 --> 00:04:42,319
tenemos la suerte de que

101
00:04:42,319 --> 00:04:43,779
están estructurados.

102
00:04:45,300 --> 00:04:46,399
Entonces, unos datos

103
00:04:46,399 --> 00:04:48,560
que no están estructurados son inmanejables.

104
00:04:48,699 --> 00:04:50,540
Luego, la base de datos siempre es la mejor opción.

105
00:04:51,560 --> 00:04:52,339
Bases de datos,

106
00:04:52,600 --> 00:04:54,560
pues tenemos las bases

107
00:04:54,560 --> 00:04:56,620
de datos SQL,

108
00:04:56,959 --> 00:04:58,279
las que llamamos relacionales,

109
00:04:58,680 --> 00:05:00,339
que se organizan en tablas, que son

110
00:05:00,339 --> 00:05:02,079
las únicas que habéis estudiado

111
00:05:02,079 --> 00:05:04,120
y que además de

112
00:05:04,120 --> 00:05:05,420
organizarse en tablas

113
00:05:05,420 --> 00:05:08,160
nos ofrecen un lenguaje

114
00:05:08,160 --> 00:05:10,160
de consulta y de

115
00:05:10,160 --> 00:05:12,220
modificación de los datos, el SQL.

116
00:05:12,959 --> 00:05:13,959
Y luego están

117
00:05:13,959 --> 00:05:15,680
las bases de datos

118
00:05:15,680 --> 00:05:18,139
no SQL.

119
00:05:19,759 --> 00:05:21,899
No SQL viene de

120
00:05:21,899 --> 00:05:24,120
not only SQL.

121
00:05:25,959 --> 00:05:27,959
Las bases de datos no SQL

122
00:05:27,959 --> 00:05:29,899
no guardan los datos en tablas

123
00:05:29,899 --> 00:05:32,139
sino que los guardan

124
00:05:32,139 --> 00:05:34,100
en lo que se llama documentos

125
00:05:34,100 --> 00:05:34,639
en general

126
00:05:34,639 --> 00:05:37,959
el acrónimo no es not only

127
00:05:37,959 --> 00:05:39,259
si es confuso verdad

128
00:05:39,259 --> 00:05:41,100
es lo peor que he visto nunca

129
00:05:41,100 --> 00:05:42,959
not only SQL

130
00:05:42,959 --> 00:05:45,100
no SQL pero la vez de eficaz

131
00:05:45,100 --> 00:05:46,319
no solo SQL

132
00:05:46,319 --> 00:05:49,180
pues si o estoy mal informada

133
00:05:49,180 --> 00:05:50,180
o recuerdo mal

134
00:05:50,180 --> 00:05:52,360
o eso es de not only

135
00:05:52,360 --> 00:05:54,339
me parece el peor acrónimo de mi vida

136
00:05:54,339 --> 00:05:55,600
otra cosa es que

137
00:05:55,600 --> 00:05:57,060
IFEMA es peor

138
00:05:57,060 --> 00:05:58,980
y FEMA no, y FEMA está bien

139
00:05:58,980 --> 00:06:01,259
pero los nombres que te van a poner en FEMA Feria de Madrid

140
00:06:01,259 --> 00:06:02,220
al lado

141
00:06:02,220 --> 00:06:05,680
y FEMA ya son por si las siglas

142
00:06:05,680 --> 00:06:07,439
de Feria de Madrid

143
00:06:07,439 --> 00:06:09,459
sí, pero y, la y de que viene

144
00:06:09,459 --> 00:06:10,720
no me acuerdo, pero como era

145
00:06:10,720 --> 00:06:13,120
era como súper redundante

146
00:06:13,120 --> 00:06:15,079
sí, y FEMA

147
00:06:15,079 --> 00:06:17,399
te aclaran, Feria de Madrid por si no te has enterado

148
00:06:17,399 --> 00:06:18,720
doble vez de Feria de Madrid

149
00:06:18,720 --> 00:06:21,680
bueno, pues estas son malas

150
00:06:21,680 --> 00:06:23,600
no, hoy es el jueves

151
00:06:23,600 --> 00:06:25,899
que guardan los datos en documentos

152
00:06:25,899 --> 00:06:28,160
documentos que también tienen que tener

153
00:06:28,160 --> 00:06:30,199
una estructura, los datos tienen que tener una estructura

154
00:06:30,199 --> 00:06:31,600
es que no nos vale... Ana

155
00:06:31,600 --> 00:06:36,060
entonces los documentos

156
00:06:36,060 --> 00:06:38,319
también tienen que tener una estructura, no nos vale

157
00:06:38,319 --> 00:06:40,220
ala, todos hay documentos

158
00:06:40,220 --> 00:06:42,019
de cualquier manera, entonces como

159
00:06:42,019 --> 00:06:44,420
los documentos tienen que tener una estructura

160
00:06:44,420 --> 00:06:44,939
también

161
00:06:44,939 --> 00:06:47,899
pues esos documentos

162
00:06:47,899 --> 00:06:50,120
o tienen la estructura de XML

163
00:06:50,120 --> 00:06:51,560
que también conocéis

164
00:06:51,560 --> 00:06:55,420
bueno, pues los ficheros XML

165
00:06:55,420 --> 00:06:57,459
aparte de la información en sí

166
00:06:57,459 --> 00:06:58,399
que está en los nodos

167
00:06:58,399 --> 00:07:01,079
tiene la jerarquía que te permite

168
00:07:01,079 --> 00:07:03,139
entender de qué va eso

169
00:07:03,139 --> 00:07:05,339
el hecho de que un nodo cuelgue de otro

170
00:07:05,339 --> 00:07:06,899
ya te da información

171
00:07:06,899 --> 00:07:08,680
bueno, pues el fichero XML

172
00:07:08,680 --> 00:07:11,379
te da algo de estructura

173
00:07:11,379 --> 00:07:13,860
que son horribles

174
00:07:13,860 --> 00:07:14,339
los XML

175
00:07:14,339 --> 00:07:17,879
pero a ti te parecen horribles muchas cosas

176
00:07:17,879 --> 00:07:19,699
la interfaz gráfica

177
00:07:19,699 --> 00:07:20,839
todo te parece horrible

178
00:07:20,839 --> 00:07:22,620
eres muy negativa

179
00:07:22,620 --> 00:07:36,839
Bueno, pues XML y otra forma de estructurar un documento es esta.

180
00:07:39,540 --> 00:07:41,920
Bueno, esto es lo que a bases de datos se refiere.

181
00:07:43,079 --> 00:07:51,399
Esta es la foto o el panorama de las bases de datos con las que nosotros trabajaremos el año que viene para acceder a nuestros datos, etc.

182
00:07:52,620 --> 00:07:55,699
esta de aquí

183
00:07:55,699 --> 00:07:59,699
esta de aquí

184
00:07:59,699 --> 00:08:01,500
es la opción de Google

185
00:08:01,500 --> 00:08:02,899
por ejemplo, ¿vale?

186
00:08:02,980 --> 00:08:04,620
la opción de Google es esta de aquí

187
00:08:04,620 --> 00:08:07,379
entonces algo cómodo y algo bueno tendrá

188
00:08:07,379 --> 00:08:08,180
ya veremos

189
00:08:08,180 --> 00:08:11,339
bueno, pues a veces

190
00:08:11,339 --> 00:08:13,660
no es necesario fletar toda una base

191
00:08:13,660 --> 00:08:15,480
de datos gigante con toda

192
00:08:15,480 --> 00:08:17,579
la complicación que

193
00:08:17,579 --> 00:08:19,540
implica el hacer el diseño de las

194
00:08:19,540 --> 00:08:21,480
tablas de las relaciones, a veces no hace falta

195
00:08:21,480 --> 00:08:22,899
fletar una base de datos entera

196
00:08:22,899 --> 00:08:25,660
no nos gusta fletar bases de datos

197
00:08:25,660 --> 00:08:27,899
¿qué es fletar?

198
00:08:28,980 --> 00:08:29,420
perdón

199
00:08:29,420 --> 00:08:32,000
bueno, a ver, fletar de toda la vida

200
00:08:32,000 --> 00:08:33,580
es poner a disposición

201
00:08:33,580 --> 00:08:34,759
una cantidad de recursos

202
00:08:34,759 --> 00:08:36,220
cuando tú fletas una flota

203
00:08:36,220 --> 00:08:37,940
¿no puedes fletar una flota?

204
00:08:38,299 --> 00:08:39,419
suena raro, pero sí

205
00:08:39,419 --> 00:08:41,419
bueno, da igual

206
00:08:41,419 --> 00:08:44,299
a veces no hace falta poner en marcha

207
00:08:44,299 --> 00:08:46,340
toda una base de datos con todo lo que implica

208
00:08:46,340 --> 00:08:47,620
que eso sí que lo habéis vivido

209
00:08:47,620 --> 00:08:50,120
de hacer un diseño entidad-relación

210
00:08:50,120 --> 00:08:52,840
Pasarlo al modelo relacional, normalizarlo, etc

211
00:08:52,840 --> 00:08:54,960
A veces no merece la pena

212
00:08:54,960 --> 00:08:56,019
Sino que tenemos

213
00:08:56,019 --> 00:08:57,740
Una opción B

214
00:08:57,740 --> 00:09:00,340
Para guardar nuestros datos

215
00:09:00,340 --> 00:09:01,639
De forma permanente

216
00:09:01,639 --> 00:09:03,639
De tal manera que

217
00:09:03,639 --> 00:09:06,519
Cuando la aplicación se cierra

218
00:09:06,519 --> 00:09:07,539
No se pierda sin más

219
00:09:07,539 --> 00:09:09,480
Que son los ficheros

220
00:09:09,480 --> 00:09:13,879
Bueno, pues los ficheros

221
00:09:13,879 --> 00:09:15,100
Es que los tenemos ahí

222
00:09:15,100 --> 00:09:17,779
En cualquier sistema operativo tenemos los ficheros

223
00:09:17,779 --> 00:09:20,059
Pues ya está, entonces en una aplicación más

224
00:09:20,059 --> 00:09:22,139
a lo mejor de un ámbito más reducido

225
00:09:22,139 --> 00:09:24,139
o privada nuestra

226
00:09:24,139 --> 00:09:25,679
pues para qué montar este rollo

227
00:09:25,679 --> 00:09:28,240
podemos organizar la información

228
00:09:28,240 --> 00:09:29,539
en ficheros y ya está

229
00:09:29,539 --> 00:09:32,139
y aquí pues entonces

230
00:09:32,139 --> 00:09:33,559
ya Java nos ofrece

231
00:09:33,559 --> 00:09:36,059
Java nos ofrece

232
00:09:36,059 --> 00:09:38,220
unas herramientas para acceder

233
00:09:38,220 --> 00:09:40,600
de forma sencilla a ficheros

234
00:09:40,600 --> 00:09:41,419
calla

235
00:09:41,419 --> 00:09:43,980
pero aquí es donde, calla el que sea

236
00:09:43,980 --> 00:09:45,100
calla en general

237
00:09:45,100 --> 00:09:47,539
aquí es donde

238
00:09:47,539 --> 00:09:50,200
vosotros haríais la pregunta

239
00:09:50,200 --> 00:09:52,419
o más que la pregunta, el comentario

240
00:09:52,419 --> 00:09:54,500
pero ficheros, hay un montón

241
00:09:54,500 --> 00:09:56,120
de tipos de ficheros distintos

242
00:09:56,120 --> 00:09:58,559
entonces, no es lo mismo

243
00:09:58,559 --> 00:10:00,279
acceder a un fichero de texto

244
00:10:00,279 --> 00:10:02,659
que como bien sabéis, es una secuencia de bits

245
00:10:02,659 --> 00:10:04,679
donde cada pack de 8

246
00:10:04,679 --> 00:10:06,440
se interpreta como una

247
00:10:06,440 --> 00:10:08,360
correspondencia en la tabla ASCII con un carácter

248
00:10:08,360 --> 00:10:10,419
correspondiente, como un fichero

249
00:10:10,419 --> 00:10:12,340
binario de

250
00:10:12,340 --> 00:10:14,259
Word, que lo que tiene ahí no tiene que ver

251
00:10:14,259 --> 00:10:16,539
con la tabla ASCII, o como un fichero

252
00:10:16,539 --> 00:10:17,539
o de un ejecutable.

253
00:10:18,340 --> 00:10:19,980
Hay de muchos tipos.

254
00:10:20,659 --> 00:10:21,860
Si es cierto, hay de muchos tipos.

255
00:10:22,340 --> 00:10:24,340
Pero esencialmente, Java

256
00:10:24,340 --> 00:10:26,340
los distingue en dos

257
00:10:26,340 --> 00:10:28,100
clases grandotas.

258
00:10:28,799 --> 00:10:29,799
Los ficheros

259
00:10:29,799 --> 00:10:32,419
que se asume que tienen

260
00:10:32,419 --> 00:10:32,879
texto

261
00:10:32,879 --> 00:10:35,559
y los ficheros

262
00:10:35,559 --> 00:10:37,440
mal llamados

263
00:10:37,440 --> 00:10:40,519
binarios. Digo mal llamados

264
00:10:40,519 --> 00:10:41,879
porque es que todos son binarios.

265
00:10:42,759 --> 00:10:44,620
A día de hoy, todos los ficheros

266
00:10:44,620 --> 00:10:45,659
de nuestras maquinitas

267
00:10:45,659 --> 00:10:48,220
Pues están compuestos por ceros y unos

268
00:10:48,220 --> 00:10:49,240
Ya está

269
00:10:49,240 --> 00:10:51,940
De hecho, me cabe la duda de si ahora mismo

270
00:10:51,940 --> 00:10:54,139
Ahí existieran

271
00:10:54,139 --> 00:10:56,120
Existen sistemas de almacenamiento

272
00:10:56,120 --> 00:10:56,659
Donde puedes

273
00:10:56,659 --> 00:10:59,139
En más de dos bits

274
00:10:59,139 --> 00:11:00,399
Cero, uno y cero, cincuenta

275
00:11:00,399 --> 00:11:03,820
La computación cuántica que está en cero, uno y todos los estados intermedios

276
00:11:03,820 --> 00:11:05,240
Esa era mi duda, ahora mismo

277
00:11:05,240 --> 00:11:08,220
Entonces ahí tienes muchísima más capacidad

278
00:11:08,220 --> 00:11:08,940
De almacenamiento

279
00:11:08,940 --> 00:11:11,759
Porque en cada biestable o cada condensador

280
00:11:11,759 --> 00:11:12,440
O cada cosa

281
00:11:12,440 --> 00:11:15,200
Que en ese caso no serán condensados, ya lo que sea

282
00:11:15,200 --> 00:11:16,519
claro, no

283
00:11:16,519 --> 00:11:19,220
tiene solamente la posibilidad de guardar dos datos

284
00:11:19,220 --> 00:11:21,100
0, 1, sino una cantidad de datos

285
00:11:21,100 --> 00:11:23,639
pero bueno, no estamos con ordenadores de computación

286
00:11:23,639 --> 00:11:24,700
cuántica y nada de eso

287
00:11:24,700 --> 00:11:27,039
con lo cual hasta donde nosotros sabemos ya está

288
00:11:27,039 --> 00:11:29,039
donde vais a llegar a trabajar seguramente

289
00:11:29,039 --> 00:11:30,240
muchísimo tiempo más

290
00:11:30,240 --> 00:11:35,120
No, no me refiero porque

291
00:11:35,120 --> 00:11:36,860
esa tecnología no creo que llegue

292
00:11:36,860 --> 00:11:41,360
a las máquinas de uso

293
00:11:41,360 --> 00:11:43,019
generalizado en mucho tiempo

294
00:11:43,019 --> 00:11:48,580
Y ya Google permite acceder a sus ordenadores cuánticos antes de que hagan pruebas y todo.

295
00:11:48,840 --> 00:11:51,220
¿Y es por qué se ha colado en las encuestas cuánticas?

296
00:11:51,340 --> 00:11:52,919
Pues bueno, no corren.

297
00:11:53,460 --> 00:11:56,320
Hay que pedir plaza, hay que pedir que no se cuelguen.

298
00:11:56,600 --> 00:11:56,960
Un chip.

299
00:11:57,480 --> 00:11:58,039
¿Cuánto corren?

300
00:11:58,980 --> 00:12:00,039
No corren un chip.

301
00:12:00,100 --> 00:12:03,740
Bueno, pero ¿qué hacemos? ¿Ignoramos los ficheros cuánticos?

302
00:12:04,639 --> 00:12:09,000
Sí, más que nada, porque no sé si Java te deja acceder a ficheros cuánticos.

303
00:12:09,179 --> 00:12:09,559
No creo.

304
00:12:09,559 --> 00:12:12,360
Pero a ver, si Google tiene una API

305
00:12:12,360 --> 00:12:13,399
Pues desde Java

306
00:12:13,399 --> 00:12:16,299
Lo que se puede hacer es consumir cualquier API

307
00:12:16,299 --> 00:12:17,419
Javi la

308
00:12:17,419 --> 00:12:18,779
Javi no, Java

309
00:12:18,779 --> 00:12:21,799
Consumiría ese API y ya está

310
00:12:21,799 --> 00:12:22,779
¿Vale?

311
00:12:23,460 --> 00:12:26,000
Entonces, Google como cualquier otra

312
00:12:26,000 --> 00:12:27,860
Plataforma que ofrece herramientas para

313
00:12:27,860 --> 00:12:28,740
Desarrolladores

314
00:12:28,740 --> 00:12:31,659
Que Google es una de ellas, pues Microsoft es otra

315
00:12:31,659 --> 00:12:33,799
Todas las plataformas que ofrecen herramientas

316
00:12:33,799 --> 00:12:34,639
Para desarrolladores

317
00:12:34,639 --> 00:12:37,879
Las ofrecen articuladas en torno

318
00:12:37,879 --> 00:12:38,399
A APIs

319
00:12:38,399 --> 00:12:41,220
y APIs son métodos

320
00:12:41,220 --> 00:12:42,740
que te dan y te dicen

321
00:12:42,740 --> 00:12:44,820
tú desde tu aplicación, me da igual que sea Java

322
00:12:44,820 --> 00:12:46,519
que sea Python, desde tu aplicación

323
00:12:46,519 --> 00:12:47,500
llama a esta función

324
00:12:47,500 --> 00:12:50,559
y yo ya me encargo en mis ordenadores cuánticos

325
00:12:50,559 --> 00:12:52,419
donde sea, hacer lo que sea y te devuelvo el resultado

326
00:12:52,419 --> 00:12:53,960
¿vale?

327
00:12:54,740 --> 00:12:56,720
entonces muchas veces efectivamente

328
00:12:56,720 --> 00:12:58,620
tiramos de servicios que ya tienen

329
00:12:58,620 --> 00:13:00,940
hecho esas plataformas, pues el de autenticación

330
00:13:00,940 --> 00:13:02,700
que lo tiene Google, todos esos, tiramos

331
00:13:02,700 --> 00:13:04,679
desde nuestros propios códigos

332
00:13:04,679 --> 00:13:07,059
llamamos a esos métodos

333
00:13:07,059 --> 00:13:08,600
que son lo que ellos llaman

334
00:13:08,600 --> 00:13:09,820
APES, ellos y nosotros

335
00:13:09,820 --> 00:13:12,399
esto todo venía a cuento de que

336
00:13:12,399 --> 00:13:13,779
si ellos nos permiten usar

337
00:13:13,779 --> 00:13:15,620
almacenamiento cuántico

338
00:13:15,620 --> 00:13:18,559
en sus ordenadores, pues desde nuestra aplicación

339
00:13:18,559 --> 00:13:20,179
Java podríamos llamarlo de esa función

340
00:13:20,179 --> 00:13:21,740
vale, pero esa es una situación

341
00:13:21,740 --> 00:13:23,659
muy concreta en la que no estamos

342
00:13:23,659 --> 00:13:26,500
veníamos a cuento de que

343
00:13:26,500 --> 00:13:28,720
Java distingue

344
00:13:28,720 --> 00:13:30,120
de texto y binarios

345
00:13:30,120 --> 00:13:32,419
entre comillas, aunque esta es una traducción

346
00:13:32,419 --> 00:13:34,399
repito, poco afortunada porque todos

347
00:13:34,399 --> 00:13:35,000
son binarios

348
00:13:35,000 --> 00:13:40,259
¿Y por qué hace esta división tan grosera?

349
00:13:40,379 --> 00:13:42,620
Porque es que es imposible hacer una división más afinada

350
00:13:42,620 --> 00:13:44,820
Porque es que ficheros hay de muchísimos tipos

351
00:13:44,820 --> 00:13:46,980
Tantos como aplicaciones distintas tengamos

352
00:13:46,980 --> 00:13:53,120
Entonces Java te puede ofrecer métodos para algunos de los más conocidos

353
00:13:53,120 --> 00:13:57,740
Te puede ofrecer métodos para acceder de forma fácil a XML

354
00:13:57,740 --> 00:14:00,500
Por ejemplo, o para acceder de forma fácil a JSON

355
00:14:00,500 --> 00:14:02,940
pero no te puede ofrecer métodos para acceder

356
00:14:02,940 --> 00:14:05,000
de forma fácil a todas las

357
00:14:05,000 --> 00:14:07,000
extensiones y formatos

358
00:14:07,000 --> 00:14:09,019
de archivo que hay, entonces los mete todos

359
00:14:09,019 --> 00:14:10,919
en el pack de binarios

360
00:14:10,919 --> 00:14:12,960
que son, yo te ofrezco leer

361
00:14:12,960 --> 00:14:14,980
la secuencia de bits y luego tú haces la interpretación

362
00:14:14,980 --> 00:14:16,659
que sea, bueno

363
00:14:16,659 --> 00:14:18,419
y luego tenemos

364
00:14:18,419 --> 00:14:19,860
este otro grupo

365
00:14:19,860 --> 00:14:22,919
que este es el que, para el que realmente

366
00:14:22,919 --> 00:14:25,120
es interesante los métodos

367
00:14:25,120 --> 00:14:26,899
que te ofrece Java, porque cuando

368
00:14:26,899 --> 00:14:28,639
uno tiene que leer archivos

369
00:14:28,639 --> 00:14:30,559
Word, archivo, lo que sea, pues no lo va a hacer

370
00:14:30,559 --> 00:14:31,919
Desde Java, obviamente

371
00:14:31,919 --> 00:14:34,580
Archivos XML y JSON sí

372
00:14:34,580 --> 00:14:36,759
Pero cuando uno va

373
00:14:36,759 --> 00:14:38,440
A trabajar con archivos

374
00:14:38,440 --> 00:14:40,659
De tipos tan genéricos, es que no lo va a hacer desde Java

375
00:14:40,659 --> 00:14:42,240
Entonces lo que realmente

376
00:14:42,240 --> 00:14:44,059
Nos interesa

377
00:14:44,059 --> 00:14:46,960
Porque sí, que puede tener cierto uso

378
00:14:46,960 --> 00:14:48,559
Aprender a hacer desde Java

379
00:14:48,559 --> 00:14:50,720
Es acceso a ficheros de texto

380
00:14:50,720 --> 00:14:52,559
Porque en un fichero de texto es facilísimo

381
00:14:52,559 --> 00:14:53,419
Guardar la información

382
00:14:53,419 --> 00:14:55,419
Acceso a ficheros de texto

383
00:14:55,419 --> 00:14:58,620
Y luego ver en general como movilizar

384
00:14:58,620 --> 00:15:00,700
de un lado a otro para copiar

385
00:15:00,700 --> 00:15:02,580
para hacer cosas, ficheros

386
00:15:02,580 --> 00:15:03,840
ya genéricos, binarios

387
00:15:03,840 --> 00:15:06,220
entonces vamos a empezar con

388
00:15:06,220 --> 00:15:08,440
qué posibilidades nos ofrece Java

389
00:15:08,440 --> 00:15:09,960
para trabajar con un fichero de todos

390
00:15:09,960 --> 00:15:25,149
bueno pues

391
00:15:25,149 --> 00:15:27,649
las clases que vamos a mencionar

392
00:15:27,649 --> 00:15:29,470
las poquitas clases que vamos a mencionar

393
00:15:29,470 --> 00:15:31,169
para hacer esta introducción

394
00:15:31,169 --> 00:15:32,269
que no vamos a hacer hoy toda

395
00:15:32,269 --> 00:15:34,549
para hacer esta introducción

396
00:15:34,549 --> 00:15:36,809
están en

397
00:15:36,809 --> 00:15:38,370
este paquete

398
00:15:38,370 --> 00:15:40,429
java.io

399
00:15:40,429 --> 00:15:42,190
¿Vale?

400
00:15:44,309 --> 00:15:44,870
Menudo

401
00:15:44,870 --> 00:15:47,070
Vale, pues este tiene prácticamente

402
00:15:47,070 --> 00:15:49,350
Todas las clases que se usan cuando uno tiene que hacer

403
00:15:49,350 --> 00:15:50,450
Un acceso a ficheros

404
00:15:50,450 --> 00:15:53,110
Normalucho y corrientucho

405
00:15:53,110 --> 00:15:55,429
Luego cuando hay, cuando tenemos que hacer

406
00:15:55,429 --> 00:15:57,129
Acceso a ficheros específicos

407
00:15:57,129 --> 00:15:58,450
Como xml, json

408
00:15:58,450 --> 00:16:01,289
Archivos de propiedades, de properties

409
00:16:01,289 --> 00:16:03,350
Archivos de logs, que son archivos específicos

410
00:16:03,909 --> 00:16:05,850
Para esas librerías específicas

411
00:16:05,850 --> 00:16:07,450
Y todo eso pues ya lo veremos

412
00:16:07,450 --> 00:16:07,990
El año que viene

413
00:16:07,990 --> 00:16:10,029
acceso a archivos específicos

414
00:16:10,029 --> 00:16:11,809
de logs, de propiedades, de no sé qué

415
00:16:11,809 --> 00:16:14,429
¿vale? eso tiene sus paquetes específicos

416
00:16:14,429 --> 00:16:16,190
pero los genéricos para acceso

417
00:16:16,190 --> 00:16:17,090
a ficheros

418
00:16:17,090 --> 00:16:20,269
de forma genérica en este paquete

419
00:16:20,269 --> 00:16:23,440
tenemos

420
00:16:23,440 --> 00:16:25,799
también, por si estudiáis

421
00:16:25,799 --> 00:16:27,259
por ahí, lo veis, este de aquí

422
00:16:27,259 --> 00:16:29,519
que se incorporó un poquito

423
00:16:29,519 --> 00:16:31,740
más tarde, que incorpora algunas cositas

424
00:16:31,740 --> 00:16:32,899
útiles a este

425
00:16:32,899 --> 00:16:34,059
¿vale?

426
00:16:35,399 --> 00:16:36,679
bueno, pues entonces

427
00:16:36,679 --> 00:16:40,440
Y vamos a ver un poquito acceso a ficheros de texto

428
00:16:40,440 --> 00:16:43,080
Para poder hacer ya alguna otra aplicación

429
00:16:43,080 --> 00:16:44,360
Con interfaz gráfica

430
00:16:44,360 --> 00:16:47,139
Que haga cosas un poquito más interesantes

431
00:16:47,139 --> 00:16:48,600
Vale

432
00:16:48,600 --> 00:16:53,049
Clases involucradas

433
00:16:53,049 --> 00:16:55,389
Para hacer un archivo a ficheros de texto

434
00:16:55,389 --> 00:17:00,029
Bueno, pues hay dos cosas que se puede hacer con un fichero de texto

435
00:17:00,029 --> 00:17:02,330
Leer de él

436
00:17:02,330 --> 00:17:06,220
Y claro, efectivamente

437
00:17:06,220 --> 00:17:08,920
Y escribir en él

438
00:17:08,920 --> 00:17:13,240
leer del fichero implica

439
00:17:13,240 --> 00:17:14,779
mover

440
00:17:14,779 --> 00:17:17,019
del fichero

441
00:17:17,019 --> 00:17:18,059
el contenido que tiene

442
00:17:18,059 --> 00:17:20,039
moverlo a variables

443
00:17:20,039 --> 00:17:23,720
eso es leer

444
00:17:23,720 --> 00:17:26,500
la información

445
00:17:26,500 --> 00:17:28,720
que tiene el fichero, moverlo a variables

446
00:17:28,720 --> 00:17:29,519
de la aplicación

447
00:17:29,519 --> 00:17:32,500
y luego ya la aplicación con las variables hace lo que quiera

448
00:17:32,500 --> 00:17:34,460
y escribir ¿qué es?

449
00:17:35,420 --> 00:17:36,500
pues escribir es

450
00:17:36,500 --> 00:17:38,559
de variables

451
00:17:38,559 --> 00:17:42,200
que tienen los datos de la aplicación,

452
00:17:42,740 --> 00:17:44,440
de variables que tienen los datos,

453
00:17:45,859 --> 00:17:47,140
moverlo al fichero.

454
00:17:48,660 --> 00:17:51,059
Entonces, estamos hablando ahora mismo solo de texto.

455
00:17:53,380 --> 00:17:53,900
Entonces,

456
00:17:54,339 --> 00:17:57,359
o el fichero se abre para leer

457
00:17:57,359 --> 00:17:58,619
o se abre para escribir,

458
00:17:58,819 --> 00:17:59,940
o una cosa o la otra.

459
00:18:00,099 --> 00:18:02,640
No se puede simultáneamente leer y escribir.

460
00:18:03,640 --> 00:18:04,240
No se puede.

461
00:18:05,240 --> 00:18:06,920
Entonces, si quisiéramos,

462
00:18:06,920 --> 00:18:21,339
Por ejemplo, si tenemos un fichero y quisiéramos modificar algo de lo que tiene, es decir, que implica leer, cuando he llegado a lo que quiero modificar, modificarlo, pues no podemos abrirlo para leer y escribir a la vez, no podemos.

463
00:18:22,480 --> 00:18:24,920
Tendríamos que hacerlo siempre a través de un fichero intermedio.

464
00:18:26,680 --> 00:18:28,680
Luego en el cambio, a ver si me da el otro roto.

465
00:18:29,839 --> 00:18:32,140
Tendríamos que hacerlo a través de un fichero intermedio.

466
00:18:32,140 --> 00:18:34,420
y entonces a través del fichero intermedio

467
00:18:34,420 --> 00:18:36,059
iríamos

468
00:18:36,059 --> 00:18:38,039
leyendo y copiando

469
00:18:38,039 --> 00:18:39,480
lo que yo quiero mantener

470
00:18:39,480 --> 00:18:42,339
cuando leo lo que quiero sobrescribir

471
00:18:42,339 --> 00:18:44,779
lo sobrescribo

472
00:18:44,779 --> 00:18:46,720
y en lugar de copiar lo que he leído

473
00:18:46,720 --> 00:18:48,480
copio la otra cosa

474
00:18:48,480 --> 00:18:50,059
y sigo leyendo

475
00:18:50,059 --> 00:18:51,619
y copiando tal cual

476
00:18:51,619 --> 00:18:54,339
¿vale? entonces si queremos un fichero

477
00:18:54,339 --> 00:18:56,160
que ya tiene algo, modificarlo

478
00:18:56,160 --> 00:18:57,720
y sobrescribir algo sobre él

479
00:18:57,720 --> 00:19:00,440
pues tenemos que hacerlo a través de uno intermedio

480
00:19:00,440 --> 00:19:01,640
¿vale?

481
00:19:02,140 --> 00:19:05,839
Este se abriría para leer y este para escribir.

482
00:19:06,740 --> 00:19:09,279
Iríamos leyendo y copiando, leyendo y copiando.

483
00:19:09,420 --> 00:19:12,380
Cuando encontramos eso que queríamos sobreescribir,

484
00:19:13,480 --> 00:19:16,539
pues en lugar de copiarlo tal cual, escribimos lo nuevo.

485
00:19:17,299 --> 00:19:18,940
Y luego seguiríamos leyendo y copiando.

486
00:19:19,660 --> 00:19:23,420
Como cuando trabajábamos con un array que queríamos modificar una posición,

487
00:19:23,759 --> 00:19:25,200
pues hacíamos a veces lo mismo.

488
00:19:25,740 --> 00:19:26,960
Hacíamos un array auxiliar.

489
00:19:27,660 --> 00:19:30,740
Leíamos y copiábamos lo que no queríamos tocar.

490
00:19:30,740 --> 00:19:32,819
cuando llegábamos a la posición que queríamos

491
00:19:32,819 --> 00:19:35,099
sobreescribir, la escribíamos

492
00:19:35,099 --> 00:19:36,140
modificada en el otro

493
00:19:36,140 --> 00:19:38,779
y luego ya queda lo que hacíamos por último

494
00:19:38,779 --> 00:19:40,700
sustituir uno por otro

495
00:19:40,700 --> 00:19:42,779
pues aquí sustituir implicaría

496
00:19:42,779 --> 00:19:44,799
cambiar el nombre, o sea eliminar

497
00:19:44,799 --> 00:19:46,559
este, este a la basura

498
00:19:46,559 --> 00:19:48,640
y a este darle el nombre

499
00:19:48,640 --> 00:19:49,519
que tenía este

500
00:19:49,519 --> 00:19:56,559
el objeto referencia en la variable

501
00:19:56,559 --> 00:19:58,839
si el fichero

502
00:19:58,839 --> 00:20:00,220
no será el mismo en el disco duro

503
00:20:00,220 --> 00:20:02,440
O sea, este lo has eliminado y tienes otro distinto

504
00:20:02,440 --> 00:20:04,059
Otro fichero

505
00:20:04,059 --> 00:20:06,400
Con el contenido que tú quieres

506
00:20:06,400 --> 00:20:07,799
Y con el mismo nombre que tenía

507
00:20:07,799 --> 00:20:09,599
Pero vamos, que eso nos da igual

508
00:20:09,599 --> 00:20:12,119
En el disco duro, el apaño que haya hecho él

509
00:20:12,119 --> 00:20:14,940
Pero realmente el fichero físicamente es otro

510
00:20:14,940 --> 00:20:16,079
Como tiene el mismo nombre

511
00:20:16,079 --> 00:20:18,180
Y este se ha eliminado, efectos prácticos es lo mismo

512
00:20:18,180 --> 00:20:19,039
¿Vale?

513
00:20:19,880 --> 00:20:22,839
Pues entonces esa es la primera cosa que tiene que quedar clara

514
00:20:22,839 --> 00:20:24,299
Que de un fichero

515
00:20:24,299 --> 00:20:25,819
O bien lo abrimos solamente

516
00:20:25,819 --> 00:20:27,180
Para leer de él

517
00:20:27,180 --> 00:20:30,180
Y coger sus datos e irlos llevando a variables

518
00:20:30,180 --> 00:20:32,140
o bien lo abrimos

519
00:20:32,140 --> 00:20:33,279
para escribir en él

520
00:20:33,279 --> 00:20:36,019
e irle mandando la información que hay en variables

521
00:20:36,019 --> 00:20:37,579
o una cosa o la otra

522
00:20:37,579 --> 00:20:39,240
simultáneamente las dos no

523
00:20:39,240 --> 00:20:41,000
luego

524
00:20:41,000 --> 00:20:43,779
como consecuencia

525
00:20:43,779 --> 00:20:45,779
si quisiéramos hacer algo tipo esto

526
00:20:45,779 --> 00:20:47,640
un archivo, irlo leyendo

527
00:20:47,640 --> 00:20:49,019
para ver la información que tiene

528
00:20:49,019 --> 00:20:50,940
pero en algún momento escribir además

529
00:20:50,940 --> 00:20:52,779
a través de uno intermedio

530
00:20:52,779 --> 00:20:54,779
el que se ha llamado de toda la vida

531
00:20:54,779 --> 00:20:57,680
en la teoría antigua de la informática

532
00:20:57,680 --> 00:20:58,680
el fichero de maniobra

533
00:20:58,680 --> 00:21:06,440
Pero ahora ya como no se estudian ficheros en informática, bueno, igual sí que se estudian, pues ya ese término se queda muy antiguo, el fichero de maniobras, ¿vale?

534
00:21:07,980 --> 00:21:11,359
Bueno, pues entonces nos ofrece leer o escribir, ¿vale?

535
00:21:11,359 --> 00:21:23,579
Para leer nos ofrece esta clase, FileReader, y para escribir nos ofrece esta otra, FileWriter.

536
00:21:27,170 --> 00:21:34,230
Estas clases tienen métodos que son los que nos permiten hacer esta operación.

537
00:21:36,940 --> 00:21:43,700
Entonces, clase que necesitamos instanciar cuando queremos leer de un archivo para pasarla a variables

538
00:21:43,700 --> 00:21:51,980
y clase que necesitamos instanciar cuando queremos escribir en un archivo la información que esté en las variables.

539
00:21:51,980 --> 00:21:57,559
ahora ya lo haremos en un ejemplo

540
00:21:57,559 --> 00:21:59,200
pero para que nos vaya sonando

541
00:21:59,200 --> 00:22:01,740
bueno pues que métodos son los que nos ofrece

542
00:22:01,740 --> 00:22:03,099
el objeto que instanciemos

543
00:22:03,099 --> 00:22:05,039
bueno pues

544
00:22:05,039 --> 00:22:07,640
como no podía ser

545
00:22:07,640 --> 00:22:08,259
de otra manera

546
00:22:08,259 --> 00:22:11,920
el método que nos permite leer

547
00:22:11,920 --> 00:22:13,759
se llama

548
00:22:13,759 --> 00:22:14,400
así

549
00:22:14,400 --> 00:22:17,279
no esa es la clase

550
00:22:17,279 --> 00:22:19,480
la clase te ofrece métodos

551
00:22:19,480 --> 00:22:22,640
Pues este método

552
00:22:22,640 --> 00:22:26,599
Este método

553
00:22:26,599 --> 00:22:27,380
Que ahora lo usaremos

554
00:22:27,380 --> 00:22:28,240
¿Qué es lo que hace?

555
00:22:29,059 --> 00:22:30,039
Pues este método

556
00:22:30,039 --> 00:22:34,420
Te coge un carácter

557
00:22:34,420 --> 00:22:36,839
Un carácter del archivo

558
00:22:36,839 --> 00:22:38,880
Y te lo lleva la variable

559
00:22:38,880 --> 00:22:39,819
Que tú le digas

560
00:22:39,819 --> 00:22:44,740
Son clases

561
00:22:44,740 --> 00:22:46,400
Son clases que tú

562
00:22:46,400 --> 00:22:47,940
Las clases no son estáticas

563
00:22:47,940 --> 00:22:51,440
A ver, son clases que tú tienes que asociar

564
00:22:51,440 --> 00:22:53,940
al archivo en particular

565
00:22:53,940 --> 00:22:56,000
con lo cual no son

566
00:22:56,000 --> 00:22:57,000
objetos estáticos

567
00:22:57,000 --> 00:22:59,579
tu pregunta era

568
00:22:59,579 --> 00:23:01,900
si estos métodos se usan de forma

569
00:23:01,900 --> 00:23:03,079
estática en estas clases

570
00:23:03,079 --> 00:23:05,259
en realidad no, porque

571
00:23:05,259 --> 00:23:07,619
cuando tú instancies un file reader

572
00:23:07,619 --> 00:23:09,700
lo tendrás que instanciar asociado

573
00:23:09,700 --> 00:23:10,900
a un archivo en concreto

574
00:23:10,900 --> 00:23:13,200
con lo cual no puede ser estático

575
00:23:13,200 --> 00:23:16,039
porque depende del archivo en concreto al que esté asociado

576
00:23:16,039 --> 00:23:17,759
si tú quieres leer de tres archivos

577
00:23:17,759 --> 00:23:19,680
cada file reader

578
00:23:19,680 --> 00:23:21,539
estará asociado a un archivo distinto

579
00:23:21,539 --> 00:23:23,279
luego los métodos no son estáticos

580
00:23:23,279 --> 00:23:26,160
los métodos se asocian

581
00:23:26,160 --> 00:23:27,880
a un objeto file reader que a su vez

582
00:23:27,880 --> 00:23:29,079
está asociado a un archivo

583
00:23:29,079 --> 00:23:31,119
con lo cual cuando se llame a read

584
00:23:31,119 --> 00:23:34,059
se hará la lectura del archivo

585
00:23:34,059 --> 00:23:35,500
al que está asociado el file reader

586
00:23:35,500 --> 00:23:37,640
esto es un poquito para ver por encima

587
00:23:37,640 --> 00:23:39,440
la filosofía de funcionamiento

588
00:23:39,440 --> 00:23:41,759
pero en un ejemplo pues se ve mejor

589
00:23:41,759 --> 00:23:44,000
uy que ruto

590
00:23:44,000 --> 00:23:45,539
vale

591
00:23:45,539 --> 00:23:47,759
el método mueve

592
00:23:47,759 --> 00:23:55,259
un carácter a una variable y de nuevo me diréis cuál es el carácter porque el fichero tendrá

593
00:23:55,259 --> 00:24:00,259
muchos bueno pues cuando el fichero está recién abierto es decir cuando este objeto está recién

594
00:24:00,259 --> 00:24:06,880
instanciado asociado este archivo hay una especie de puntero interno al que no podemos acceder

595
00:24:08,259 --> 00:24:15,180
que inicialmente está apuntando al primer carácter entonces cada real tele un único carácter

596
00:24:15,180 --> 00:24:17,839
que queda apuntado

597
00:24:17,839 --> 00:24:20,180
bajo ese posicionador, ese puntero

598
00:24:20,180 --> 00:24:22,059
entonces el primer read que hagamos

599
00:24:22,059 --> 00:24:23,319
el primero de todos

600
00:24:23,319 --> 00:24:25,059
nos lee el primer carácter

601
00:24:25,059 --> 00:24:27,599
que luego hacemos otro read después

602
00:24:27,599 --> 00:24:29,799
pues ese otro read nos leerá el segundo

603
00:24:29,799 --> 00:24:31,619
que luego hacemos otro read

604
00:24:31,619 --> 00:24:33,900
pues ese otro read nos leerá el tercero

605
00:24:33,900 --> 00:24:35,660
que queremos

606
00:24:35,660 --> 00:24:37,819
leer todo el contenido del archivo

607
00:24:37,819 --> 00:24:39,640
pues tendremos que hacer un bucle

608
00:24:39,640 --> 00:24:42,180
de muchos read e ir concatenando

609
00:24:42,180 --> 00:24:44,180
todos esos caracteres

610
00:24:44,180 --> 00:24:46,160
que nos va dando

611
00:24:46,160 --> 00:24:48,579
vale, entonces diréis

612
00:24:48,579 --> 00:24:50,900
ya y como sé yo que he terminado

613
00:24:50,900 --> 00:24:52,319
porque cuando yo abro un archivo

614
00:24:52,319 --> 00:24:54,859
instancio un archivo, no tengo por qué saber ese archivo

615
00:24:54,859 --> 00:24:56,799
cuántos bytes tiene

616
00:24:56,799 --> 00:24:58,700
como sé yo cuántos read tengo que hacer

617
00:24:58,700 --> 00:25:00,000
si es que quiero leerlos todos

618
00:25:00,000 --> 00:25:01,980
bueno, pues afortunadamente

619
00:25:01,980 --> 00:25:04,380
read tiene

620
00:25:04,380 --> 00:25:05,900
una forma de avisarte

621
00:25:05,900 --> 00:25:08,220
de que ha terminado el archivo

622
00:25:08,220 --> 00:25:10,180
una forma sencilla que es

623
00:25:10,180 --> 00:25:11,859
devolviéndote

624
00:25:11,859 --> 00:25:14,160
el numerito menos uno

625
00:25:14,160 --> 00:25:16,759
es decir, read

626
00:25:16,759 --> 00:25:18,319
está pensado en realidad

627
00:25:18,319 --> 00:25:20,619
aunque te lee un único carácter

628
00:25:20,619 --> 00:25:23,680
lo que te devuelve no es una variable char

629
00:25:23,680 --> 00:25:25,420
read lo que te devuelve

630
00:25:25,420 --> 00:25:27,279
es una variable entera

631
00:25:27,279 --> 00:25:30,220
una variable entera

632
00:25:30,220 --> 00:25:33,640
esto ya no vale para nada

633
00:25:33,640 --> 00:25:35,759
y te guarda el char que ha leído

634
00:25:35,759 --> 00:25:38,119
el char que ha leído te lo guarda

635
00:25:38,119 --> 00:25:39,960
en el byte

636
00:25:39,960 --> 00:25:42,119
menos significativo del entero

637
00:25:42,119 --> 00:25:43,480
es lo que hace read

638
00:25:43,480 --> 00:25:46,640
te coge un carácter, el que toque en ese momento

639
00:25:46,640 --> 00:25:49,000
recordad que van en secuencia

640
00:25:49,000 --> 00:25:50,700
te lee un carácter

641
00:25:50,700 --> 00:25:51,980
el que toque en ese momento

642
00:25:51,980 --> 00:25:54,579
y te lo guarda en el byte menos significativo

643
00:25:54,579 --> 00:25:56,000
de una variable entera

644
00:25:56,000 --> 00:25:58,440
que es la que te devuelve como valor de retorno

645
00:25:58,440 --> 00:26:00,140
y con el resto que hace

646
00:26:00,140 --> 00:26:01,559
con el resto te lo devuelve

647
00:26:01,559 --> 00:26:03,980
todo así con un montón de ceros

648
00:26:03,980 --> 00:26:06,740
con 24 ceros

649
00:26:06,740 --> 00:26:09,180
y diríais

650
00:26:09,180 --> 00:26:11,240
¿qué necesidad tiene

651
00:26:11,240 --> 00:26:13,819
de ese carácter que ha leído

652
00:26:13,819 --> 00:26:16,299
devolvértelo guardado en una variable entera

653
00:26:16,299 --> 00:26:17,480
n que le sobra espacio

654
00:26:17,480 --> 00:26:20,640
que te lo devuelva en una variable char

655
00:26:20,640 --> 00:26:21,740
o en una variable char cabe

656
00:26:21,740 --> 00:26:24,359
bueno pues precisamente el sentido que tiene esto

657
00:26:24,359 --> 00:26:26,079
es habilitarse

658
00:26:26,079 --> 00:26:27,960
la opción de avisarte

659
00:26:27,960 --> 00:26:29,019
de que ha llegado al final

660
00:26:29,019 --> 00:26:30,839
porque

661
00:26:30,839 --> 00:26:34,180
sea cual sea el char que lea

662
00:26:34,180 --> 00:26:35,180
sea cual sea

663
00:26:35,180 --> 00:26:37,700
si esto lo interpretáramos

664
00:26:37,700 --> 00:26:38,859
como número entero

665
00:26:38,859 --> 00:26:40,700
siempre sería positivo

666
00:26:40,700 --> 00:26:42,720
porque el bit de signo es positivo

667
00:26:42,720 --> 00:26:45,039
luego si hiciéramos

668
00:26:45,039 --> 00:26:47,519
si no hiciéramos el casting a char de esto

669
00:26:47,519 --> 00:26:49,539
porque al hacer el casting a char de esto

670
00:26:49,539 --> 00:26:51,819
cuando uno hace el casting a char

671
00:26:51,819 --> 00:26:53,240
ya se queda con esta parte

672
00:26:53,240 --> 00:26:53,980
que es la que queremos

673
00:26:53,980 --> 00:26:56,119
pues si no hiciéramos el casting a char

674
00:26:56,119 --> 00:26:59,119
e interpretáramos directamente el número como entero

675
00:26:59,119 --> 00:27:00,799
siempre sería positivo

676
00:27:00,799 --> 00:27:03,039
sería el que fuera pero sería positivo

677
00:27:03,039 --> 00:27:04,299
porque el bit de signo es cero

678
00:27:04,299 --> 00:27:07,420
bueno pues si cuando read

679
00:27:07,420 --> 00:27:08,900
te devuelve algo

680
00:27:08,900 --> 00:27:10,740
que he interpretado como un numerito

681
00:27:10,740 --> 00:27:12,319
entero n sin hacer el char

682
00:27:12,319 --> 00:27:13,319
es menos 1

683
00:27:13,319 --> 00:27:16,500
entonces es la forma de avisarte de que

684
00:27:16,500 --> 00:27:18,900
no, perdona, es que estás intentando ya leer

685
00:27:18,900 --> 00:27:20,119
en el final

686
00:27:20,119 --> 00:27:22,339
después de haberte pasado el último

687
00:27:22,339 --> 00:27:24,799
es su forma de avisarte, es que ya no hay más que leer

688
00:27:24,799 --> 00:27:26,000
es que ya se ha acabado, ya no hay más

689
00:27:26,000 --> 00:27:29,140
y no hay ninguna confusión posible

690
00:27:29,140 --> 00:27:30,680
porque si te devuelve menos 1

691
00:27:30,680 --> 00:27:33,079
es porque aquí el bit de signo es 1

692
00:27:33,079 --> 00:27:37,259
con lo cual no ha hecho la lectura

693
00:27:37,259 --> 00:27:37,819
correctamente

694
00:27:37,819 --> 00:27:41,480
a ver si tú lo casteas a chat

695
00:27:41,480 --> 00:27:42,200
te saldrá lo que sea

696
00:27:42,200 --> 00:27:43,859
pero que necesidad tienes de castearlo

697
00:27:43,859 --> 00:27:45,180
porque ya sabes que eso no

698
00:27:45,180 --> 00:27:48,799
si hubiera leído algún carácter

699
00:27:48,799 --> 00:27:51,220
Pablo, si hubiera leído algún carácter

700
00:27:51,220 --> 00:27:52,980
que no fuera el fin de archivo

701
00:27:52,980 --> 00:27:54,980
te lo habría rellenado todo a ceros

702
00:27:54,980 --> 00:27:56,740
entonces no habría sido menos uno

703
00:27:56,740 --> 00:27:59,339
pero si has leído el carácter del fin de archivo

704
00:27:59,339 --> 00:28:00,480
te devuelve el menos uno

705
00:28:00,480 --> 00:28:01,359
que es esto a uno

706
00:28:01,359 --> 00:28:03,079
y lo demás pues no sé si te da uno

707
00:28:03,079 --> 00:28:04,000
o como sea da igual

708
00:28:04,000 --> 00:28:06,420
entonces pues

709
00:28:06,420 --> 00:28:08,539
pues por ejemplo

710
00:28:08,539 --> 00:28:10,480
vamos a leer un archivo cualquiera de texto

711
00:28:10,480 --> 00:28:11,599
con esto

712
00:28:11,599 --> 00:28:17,019
para que veáis

713
00:28:17,019 --> 00:28:18,000
que fácil es

714
00:28:18,000 --> 00:28:21,140
y en realidad

715
00:28:21,140 --> 00:28:23,119
bastante útil porque hay muchos archivos

716
00:28:23,119 --> 00:28:24,799
de texto a veces que necesitamos

717
00:28:24,799 --> 00:28:26,500
dígame

718
00:28:26,500 --> 00:28:28,880
uff

719
00:28:28,880 --> 00:28:29,279
hay

720
00:28:29,279 --> 00:28:32,000
como a ver

721
00:28:32,000 --> 00:28:33,880
hay acceso a bases de datos

722
00:28:33,880 --> 00:28:35,140
pero no nos va a dar tiempo a dar

723
00:28:35,140 --> 00:28:36,500
os recuerdo

724
00:28:36,500 --> 00:28:37,920
que

725
00:28:37,920 --> 00:28:39,579
en

726
00:28:39,579 --> 00:28:42,960
esta semana o la siguiente

727
00:28:42,960 --> 00:28:44,200
teníamos el examen.

728
00:28:45,460 --> 00:28:46,140
Y bueno, y tenemos.

729
00:28:47,099 --> 00:28:47,519
Tenemos.

730
00:28:50,220 --> 00:28:50,579
A ver,

731
00:28:51,000 --> 00:28:52,440
era...

732
00:28:52,440 --> 00:28:54,480
¿Qué día lo habíamos puesto? Que me acuerde yo.

733
00:28:58,480 --> 00:28:59,420
El 7.

734
00:29:00,759 --> 00:29:02,359
Seguro, pero...

735
00:29:02,359 --> 00:29:04,180
¿Al final habíamos decidido que dejábamos a Rosa?

736
00:29:05,480 --> 00:29:06,119
Tranquila.

737
00:29:06,500 --> 00:29:09,440
el 7 de abril, lo habíamos puesto el 7 de abril seguro

738
00:29:09,440 --> 00:29:11,400
el lunes 7 de abril

739
00:29:11,400 --> 00:29:12,839
después de todas las idas y venidas

740
00:29:12,839 --> 00:29:14,000
con Estefano

741
00:29:14,000 --> 00:29:25,400
vale, bueno

742
00:29:25,400 --> 00:29:26,779
pues os recuerdo eso

743
00:29:26,779 --> 00:29:29,880
que en nada tenemos un examen

744
00:29:29,880 --> 00:29:30,680
vacaciones

745
00:29:30,680 --> 00:29:33,099
no, es que tenía yo

746
00:29:33,099 --> 00:29:35,480
la cabeza me puse fatal, tenía yo el recuerdo

747
00:29:35,480 --> 00:29:37,619
de que íbamos a hacer

748
00:29:37,619 --> 00:29:39,119
un change con Rosa

749
00:29:39,119 --> 00:29:40,660
bueno

750
00:29:40,660 --> 00:29:44,640
nada, olvidadlo

751
00:29:44,640 --> 00:29:47,480
lo último que os dije

752
00:29:47,480 --> 00:29:48,519
a vosotros es el 7

753
00:29:48,519 --> 00:29:51,319
pues sería que yo me he quedado

754
00:29:51,319 --> 00:29:53,259
en una fase anterior, mi cerebro

755
00:29:53,259 --> 00:29:54,700
desconectó a partir de ahí

756
00:29:54,700 --> 00:29:57,839
pues

757
00:29:57,839 --> 00:30:00,599
no

758
00:30:00,599 --> 00:30:02,960
claro, no, porque

759
00:30:02,960 --> 00:30:05,359
un jueves para dejarle a

760
00:30:05,359 --> 00:30:08,299
el jueves 27 lo descartamos

761
00:30:08,299 --> 00:30:10,839
era una propuesta que habíamos hecho

762
00:30:10,839 --> 00:30:11,599
y lo descartamos

763
00:30:11,599 --> 00:30:14,200
perdón, el 3

764
00:30:14,200 --> 00:30:16,960
el 3 hicimos esa propuesta

765
00:30:16,960 --> 00:30:17,900
y luego la descartamos

766
00:30:17,900 --> 00:30:20,259
y después de esa

767
00:30:20,259 --> 00:30:21,420
que es en la que yo me quedé

768
00:30:21,420 --> 00:30:23,259
lo habíamos quedado en el 7

769
00:30:23,259 --> 00:30:27,559
y luego

770
00:30:27,559 --> 00:30:29,619
os recuerdo que

771
00:30:29,619 --> 00:30:32,380
a la vuelta de Semana Santa

772
00:30:32,380 --> 00:30:34,420
venimos, nos vamos de Puente de Mayo

773
00:30:34,420 --> 00:30:36,240
y venimos a examinarnos.

774
00:30:38,259 --> 00:30:39,240
No, yo no.

775
00:30:40,259 --> 00:30:41,599
El calendario escolar.

776
00:30:43,599 --> 00:30:44,400
A ver.

777
00:30:45,420 --> 00:30:45,980
Silencio.

778
00:30:48,799 --> 00:30:51,779
Uy, eso es una buena...

779
00:30:51,779 --> 00:30:54,059
Vale, pues venga.

780
00:30:54,180 --> 00:30:55,799
Lo primero vamos a hacernos el fichero

781
00:30:55,799 --> 00:30:57,160
que queremos leer.

782
00:30:57,960 --> 00:31:00,359
Vale, por ahora para no complicarnos la vida

783
00:31:00,359 --> 00:31:03,079
porque recordad que un fichero

784
00:31:03,079 --> 00:31:06,500
está ubicado dentro del sistema de ficheros

785
00:31:06,500 --> 00:31:07,460
del sistema operativo

786
00:31:07,460 --> 00:31:11,079
y el sistema de ficheros del sistema operativo no es plano

787
00:31:11,079 --> 00:31:13,880
no están todos los ficheros puestos ahí a mogollón

788
00:31:13,880 --> 00:31:19,519
el sistema de ficheros de cualquier sistema operativo

789
00:31:19,519 --> 00:31:21,019
al menos hasta donde yo creo

790
00:31:21,019 --> 00:31:24,400
suele estar organizado de forma jerárquica

791
00:31:24,400 --> 00:31:26,599
para facilitarnos la búsqueda de los archivos

792
00:31:26,599 --> 00:31:29,759
entonces cuidado porque un archivo

793
00:31:29,759 --> 00:31:32,380
se caracteriza no solo por su nombre

794
00:31:32,380 --> 00:31:36,019
sino también por la ubicación

795
00:31:36,019 --> 00:31:38,279
donde está dentro del sistema de archivos

796
00:31:38,279 --> 00:31:41,680
entonces cuando nosotros le indiquemos un archivo a Java

797
00:31:41,680 --> 00:31:44,839
aparte del nombre tendremos que indicarle la ubicación

798
00:31:44,839 --> 00:31:48,019
donde está, efectivamente la ruta absoluta

799
00:31:48,019 --> 00:31:50,240
o relativa respecto a algún punto

800
00:31:50,240 --> 00:31:54,079
bueno, pues ahora mismo en este primer ejemplo

801
00:31:54,079 --> 00:31:57,180
para no complicarnos la vida con la información

802
00:31:57,180 --> 00:31:59,819
de la ruta, vamos a colocar

803
00:31:59,819 --> 00:32:00,619
el fichero

804
00:32:00,619 --> 00:32:02,880
donde para Java

805
00:32:02,880 --> 00:32:05,359
es la ruta por defecto

806
00:32:05,359 --> 00:32:07,720
que es la raíz del proyecto

807
00:32:07,720 --> 00:32:09,420
entonces

808
00:32:09,420 --> 00:32:11,740
la raíz del proyecto es su ruta por defecto

809
00:32:11,740 --> 00:32:13,859
si nosotros le damos una ruta

810
00:32:13,859 --> 00:32:16,140
relativa, él va a entender

811
00:32:16,140 --> 00:32:18,180
que es a partir de la raíz

812
00:32:18,180 --> 00:32:20,339
del proyecto y si le damos una absoluta

813
00:32:20,339 --> 00:32:21,599
pues es la absoluta y ya está

814
00:32:21,599 --> 00:32:23,940
bueno, pues entonces vamos a crearnos un fichero

815
00:32:23,940 --> 00:32:24,480
de texto

816
00:32:24,480 --> 00:32:27,279
a Ana

817
00:32:27,279 --> 00:32:29,039
en la propia raíz del proyecto

818
00:32:29,039 --> 00:32:31,440
pues pincháis

819
00:32:31,440 --> 00:32:35,279
y os creáis un nuevo

820
00:32:35,279 --> 00:32:36,619
file, venga

821
00:32:36,619 --> 00:32:39,220
en el propio raíz un nuevo

822
00:32:39,220 --> 00:32:41,099
file y así no nos complicamos la vida

823
00:32:41,099 --> 00:32:43,779
como queráis

824
00:32:43,779 --> 00:32:45,039
por ejemplo

825
00:32:45,039 --> 00:32:47,299
un archivo de nombres

826
00:32:47,299 --> 00:32:48,019
venga

827
00:32:48,019 --> 00:32:50,599
nombres.txt

828
00:32:50,599 --> 00:32:53,140
a ver, la extensión en realidad me da igual

829
00:32:53,140 --> 00:32:55,559
ya sabéis que lo de las extensiones es informativo

830
00:32:55,559 --> 00:32:57,200
para el que lo está mirando

831
00:32:57,200 --> 00:32:59,099
Y algunas aplicaciones

832
00:32:59,099 --> 00:33:01,160
Pues a lo mejor usan la extensión para hacer cosas

833
00:33:01,160 --> 00:33:03,559
Pero no hay ninguna obligación

834
00:33:03,559 --> 00:33:05,180
El fichero puede ser de texto aunque no tenga

835
00:33:05,180 --> 00:33:06,940
Extensión .txt, lógicamente

836
00:33:06,940 --> 00:33:09,160
Bueno, vamos a poner nombres

837
00:33:09,160 --> 00:33:14,680
Siempre

838
00:33:14,680 --> 00:33:16,859
En Venezuela

839
00:33:16,859 --> 00:33:19,019
Tenéis que poner fulanito, menganito

840
00:33:19,019 --> 00:33:19,680
¿Qué elegís?

841
00:33:20,240 --> 00:33:22,180
O sea, Pepito, Juanito, ¿qué elegís?

842
00:33:23,579 --> 00:33:24,640
Porque yo los pongo

843
00:33:24,640 --> 00:33:26,700
Pero es que aquí es Pepito, Juanito, siempre

844
00:33:26,700 --> 00:33:33,140
Bueno

845
00:33:33,140 --> 00:33:37,819
No, porque me gusta a mí

846
00:33:37,819 --> 00:33:40,160
Vale, entonces lo pongo así

847
00:33:40,160 --> 00:33:44,039
Venga, Pepito, Juanito y Luis

848
00:33:44,039 --> 00:33:44,920
¿John no ha venido?

849
00:33:48,519 --> 00:33:50,200
Vale, este es nuestro archivo

850
00:33:50,200 --> 00:33:52,339
Que está en la ruta por defecto

851
00:33:52,339 --> 00:33:54,799
Del sistema de la máquina virtual

852
00:33:54,799 --> 00:33:55,940
Con lo cual nos ahorra la vida

853
00:33:55,940 --> 00:33:58,940
Ahora vamos a hacer nuestra aplicación

854
00:33:58,940 --> 00:34:02,000
Hacemos un paquete

855
00:34:02,000 --> 00:34:02,480
Pues para

856
00:34:02,480 --> 00:34:05,619
Claro, lo he hecho

857
00:34:05,619 --> 00:34:07,160
New file y luego ya lo he abierto

858
00:34:07,160 --> 00:34:08,599
Y cuando yo lo abro

859
00:34:08,599 --> 00:34:11,880
Él me lo abre en un editor

860
00:34:11,880 --> 00:34:12,579
De texto

861
00:34:12,579 --> 00:34:15,900
¿Vale? Entonces, esto de aquí es un editor

862
00:34:15,900 --> 00:34:16,420
De texto

863
00:34:16,420 --> 00:34:19,059
Entonces, si yo abriera

864
00:34:19,059 --> 00:34:21,860
Aquí un archivo cualquiera

865
00:34:21,860 --> 00:34:23,440
El sistema operativo que no fuera texto

866
00:34:23,440 --> 00:34:25,780
Él al abrírmelo con un editor de texto

867
00:34:25,780 --> 00:34:27,159
me mostraría ahí fantasmitas

868
00:34:27,159 --> 00:34:30,860
claro, me mostraría

869
00:34:30,860 --> 00:34:34,059
los fantasmas que ha sacado

870
00:34:34,059 --> 00:34:35,639
de interpretar cada pack de 8

871
00:34:35,639 --> 00:34:36,559
con el código ASCII

872
00:34:36,559 --> 00:34:38,400
vale, es decir

873
00:34:38,400 --> 00:34:40,980
Ana y demás, tallaos

874
00:34:40,980 --> 00:34:43,440
sí, hombre Ana, estabas hablando

875
00:34:43,440 --> 00:34:44,000
o no

876
00:34:44,000 --> 00:34:46,480
ya

877
00:34:46,480 --> 00:34:49,000
sí, eso decía Hitler

878
00:34:49,000 --> 00:34:51,480
es que le estaba

879
00:34:51,480 --> 00:34:53,280
explicando que no podía hacer eso y de repente

880
00:34:53,280 --> 00:34:55,480
mira, lo pasé, pues esto es lo mismo

881
00:34:55,480 --> 00:34:59,780
Venga

882
00:34:59,780 --> 00:35:04,219
¿Habéis hecho el paquete main?

883
00:35:05,380 --> 00:35:06,019
Vale

884
00:35:06,019 --> 00:35:15,880
Hacemos nuestra clase

885
00:35:15,880 --> 00:35:17,159
Vale

886
00:35:17,159 --> 00:35:20,619
Vale

887
00:35:20,619 --> 00:35:24,360
¿Qué Mayan?

888
00:35:25,480 --> 00:35:30,599
Bueno, si me gusta a mí Mayan

889
00:35:30,599 --> 00:35:34,199
Bueno, la mía se llama Mayan

890
00:35:34,199 --> 00:35:35,559
A vosotros como queráis

891
00:35:35,559 --> 00:35:38,019
Silencio, vale, pues ahora

892
00:35:38,019 --> 00:35:40,400
Vamos a hacer un método

893
00:35:40,400 --> 00:35:42,679
De verdad, os estáis riendo

894
00:35:42,679 --> 00:35:44,780
Tanto como voy a reír yo corrigiendo vuestros exámenes

895
00:35:44,780 --> 00:35:45,320
Vamos

896
00:35:45,320 --> 00:35:48,780
Lo que me voy a reír

897
00:35:48,780 --> 00:35:54,239
Es que estáis arriesgando mucho

898
00:35:54,239 --> 00:35:56,280
vuestras vidas, la verdad, no haciéndome

899
00:35:56,280 --> 00:35:58,340
ni caso, pero allá vosotros. ¿Es lo único que me escucha,

900
00:35:58,400 --> 00:35:58,579
Juan?

901
00:35:59,900 --> 00:36:00,300
Bueno.

902
00:36:03,679 --> 00:36:04,579
Leer fichero.

903
00:36:05,139 --> 00:36:05,380
Vale.

904
00:36:06,239 --> 00:36:07,239
Vamos a hacer un método.

905
00:36:07,840 --> 00:36:08,019
Sí.

906
00:36:10,900 --> 00:36:12,420
Sí, Josi, el que faltaba.

907
00:36:12,579 --> 00:36:13,260
Venga, anda, pasa.

908
00:36:18,539 --> 00:36:18,940
Venga.

909
00:36:22,940 --> 00:36:23,340
Nombre

910
00:36:23,340 --> 00:36:24,699
fichero

911
00:36:24,699 --> 00:36:27,139
vamos a hacer un método

912
00:36:27,139 --> 00:36:29,460
al que le pasamos el nombre de un fichero

913
00:36:29,460 --> 00:36:31,039
y nos va a devolver

914
00:36:31,039 --> 00:36:33,519
una cadena con su contenido

915
00:36:33,519 --> 00:36:38,139
si fuera muy largo pues una cadena muy larga

916
00:36:38,139 --> 00:36:38,960
vale

917
00:36:38,960 --> 00:36:41,199
entonces cuando tengamos este método

918
00:36:41,199 --> 00:36:43,260
pues ahora ya

919
00:36:43,260 --> 00:36:46,119
vamos a suponer que este es el resultado

920
00:36:54,340 --> 00:36:56,019
este va a ser nuestro método

921
00:36:56,019 --> 00:36:57,039
que tengamos que hacer

922
00:36:57,039 --> 00:37:21,449
Y cuando lo tengamos hecho, pues simplemente podremos hacer esto, leer fichero y le pasaremos el nombre del fichero que nos dé la gana, ¿vale? Pues, por ejemplo, nombre de XT en nuestro caso, ¿vale? Este será el uso que hagamos de ese método.

923
00:37:21,449 --> 00:37:23,869
Le pasaremos el nombre de un fichero

924
00:37:23,869 --> 00:37:25,889
Y este método lo construiremos

925
00:37:25,889 --> 00:37:27,050
Para que nos devuelva su contenido

926
00:37:27,050 --> 00:37:28,670
Vale

927
00:37:28,670 --> 00:37:31,730
Como está estratégicamente colocado

928
00:37:31,730 --> 00:37:33,070
En la raíz del proyecto

929
00:37:33,070 --> 00:37:35,329
Que es la ruta por defecto

930
00:37:35,329 --> 00:37:37,489
Aquí no he tenido yo que acompañarlo

931
00:37:37,489 --> 00:37:38,230
De ninguna ruta

932
00:37:38,230 --> 00:37:41,949
Bueno, pues venga

933
00:37:41,949 --> 00:37:45,650
¿Qué tenemos que hacer con ese fichero?

934
00:37:46,329 --> 00:37:46,650
Leer

935
00:37:46,650 --> 00:37:48,530
Es decir, coger lo que tiene dentro

936
00:37:48,530 --> 00:37:50,309
Y pasarlo a variables de alguna manera

937
00:37:50,309 --> 00:37:52,130
Pues File Reader

938
00:37:52,130 --> 00:38:22,059
Muy bien, vale, pues este objeto tendremos que instanciarlo, este objeto lo tendremos que instanciar, efectivamente no lo reconoce si no lo importamos de la librería o si no le ponemos su nombre completito, vale, no se os olvidan estas cosas, verdad, que me da igual hacer el import que poner el nombre completo.

939
00:38:22,059 --> 00:38:27,019
Vale, pues

940
00:38:27,019 --> 00:38:29,579
No lo olvidéis porque hay veces

941
00:38:29,579 --> 00:38:32,019
Que es recomendable

942
00:38:32,019 --> 00:38:34,099
No hacer el import porque puede crear confusiones

943
00:38:34,099 --> 00:38:36,219
Y muchas veces los plugins que te generan

944
00:38:36,219 --> 00:38:37,119
Código automático

945
00:38:37,119 --> 00:38:39,219
No te hacen los import

946
00:38:39,219 --> 00:38:41,119
Te ponen directamente, de hecho el builder

947
00:38:41,119 --> 00:38:42,820
No sé si, bueno

948
00:38:42,820 --> 00:38:45,320
Si que te lo hace como importación

949
00:38:45,320 --> 00:38:47,260
Vale

950
00:38:47,260 --> 00:38:52,019
A ver, hay muchas clases

951
00:38:52,059 --> 00:38:54,380
es que se llaman igual en diferentes librerías

952
00:38:54,380 --> 00:38:55,980
entonces tú

953
00:38:55,980 --> 00:38:57,860
has hecho el import y el import está

954
00:38:57,860 --> 00:38:59,860
200 millas más arriba y te crees que

955
00:38:59,860 --> 00:39:01,840
estás usando la de un paquete y estás usando

956
00:39:01,840 --> 00:39:04,000
la de otro, sin embargo si lo hubieras puesto

957
00:39:04,000 --> 00:39:06,000
con su nombrecito no habría ninguna confusión

958
00:39:06,000 --> 00:39:08,000
entonces se pasa, se pierden

959
00:39:08,000 --> 00:39:08,820
muchas horas

960
00:39:08,820 --> 00:39:12,039
porque algo no te está funcionando

961
00:39:12,039 --> 00:39:13,840
no porque no compile, porque si no compila

962
00:39:13,840 --> 00:39:15,800
es fácil llegar al problema

963
00:39:15,800 --> 00:39:17,940
sino porque algo

964
00:39:17,940 --> 00:39:20,159
no te está funcionando, te está haciendo algo que no es

965
00:39:20,159 --> 00:39:21,219
y no entiendes por qué

966
00:39:21,219 --> 00:39:22,900
no entiendes por qué. Y el error no está ahí.

967
00:39:23,139 --> 00:39:25,179
El error está 200 millas más arriba en el

968
00:39:25,179 --> 00:39:27,260
import. Y entonces, tú solo

969
00:39:27,260 --> 00:39:29,000
preguntas a HGPT por todos lados.

970
00:39:29,679 --> 00:39:31,039
Prueba esto, prueba lo otro.

971
00:39:31,199 --> 00:39:33,340
Ay, pues sí, ay, pues no. Ay, pues no sé cuántos.

972
00:39:33,400 --> 00:39:35,340
Ay, pues no sé qué. A él no se

973
00:39:35,340 --> 00:39:37,219
le ocurre decirte, ¿tú estás seguro de que esta

974
00:39:37,219 --> 00:39:38,980
clase es la que quieres usar?

975
00:39:40,000 --> 00:39:40,239
Bueno,

976
00:39:41,460 --> 00:39:43,139
pues dicho este inciso, a Rodrigo

977
00:39:43,139 --> 00:39:44,300
le ha pasado eso. ¿Ves?

978
00:39:45,559 --> 00:39:47,179
Esto es como las canciones de los hombres

979
00:39:47,179 --> 00:39:49,139
que todo te ha pasado a ti. Pues igual.

980
00:39:49,880 --> 00:39:51,119
Entonces, para no arrastrarnos otros

981
00:39:51,119 --> 00:39:52,199
con eso vamos a hacer el import

982
00:39:52,199 --> 00:39:54,400
ahí

983
00:39:54,400 --> 00:39:56,920
vale, pues el file reader

984
00:39:56,920 --> 00:39:57,960
hay que instanciarlo

985
00:39:57,960 --> 00:40:01,219
y tendrá, seguramente

986
00:40:01,219 --> 00:40:03,300
tenga constructores sobrecargados

987
00:40:03,300 --> 00:40:04,880
el constructor sin parámetros

988
00:40:04,880 --> 00:40:07,119
pues no le gusta, al menos

989
00:40:07,119 --> 00:40:09,179
habrá que darle el fichero

990
00:40:09,179 --> 00:40:10,760
al que asociarlo, el file reader

991
00:40:10,760 --> 00:40:11,900
se asocia a un fichero

992
00:40:11,900 --> 00:40:15,079
hay varias formas de asociar un objeto

993
00:40:15,079 --> 00:40:17,139
claro, al instanciarlo

994
00:40:17,139 --> 00:40:18,179
lo tienes que asociar a un fichero

995
00:40:18,179 --> 00:40:20,679
vale, bueno

996
00:40:20,679 --> 00:40:21,440
Tanto como guay

997
00:40:21,440 --> 00:40:23,780
Entonces hay muchas

998
00:40:23,780 --> 00:40:25,420
Variantes del constructor

999
00:40:25,420 --> 00:40:27,519
Una de ellas, la más sencilla

1000
00:40:27,519 --> 00:40:29,480
Es que tú le pases directamente

1001
00:40:29,480 --> 00:40:32,199
El string

1002
00:40:32,199 --> 00:40:33,360
¿Vale?

1003
00:40:33,400 --> 00:40:34,500
Con el nombre del fichero

1004
00:40:34,500 --> 00:40:38,860
Esta es la más sencilla

1005
00:40:38,860 --> 00:40:41,860
Se le puede pasar el fichero de otra manera

1006
00:40:41,860 --> 00:40:44,199
Sí, no le gusta

1007
00:40:44,199 --> 00:40:45,400
Ya, pero no pasa nada

1008
00:40:45,400 --> 00:40:47,260
Ahora le satisfacemos al completo

1009
00:40:47,260 --> 00:40:48,139
No pasa nada

1010
00:40:48,139 --> 00:40:50,320
Entonces, ¿por qué no le gusta?

1011
00:40:51,860 --> 00:40:52,340
Eso

1012
00:40:52,340 --> 00:41:14,300
Primero, porque automáticamente esto que hemos creado es una cosa que se llama flujo, que es un objeto que está asociado a un recurso ajeno al, bueno, no ajeno, un objeto que es una puerta a un recurso, ¿vale?

1013
00:41:14,300 --> 00:41:30,380
Es decir, esto es un ejemplo de algo que en Java y en programación en general se llama flujo, que es un objeto de mi programa que es una puerta a un recurso, es una puertita a un recurso.

1014
00:41:30,380 --> 00:41:32,420
un flujo es en general

1015
00:41:32,420 --> 00:41:33,460
una puertecita

1016
00:41:33,460 --> 00:41:35,780
a un recurso

1017
00:41:35,780 --> 00:41:37,960
entonces, esto es un flujo

1018
00:41:37,960 --> 00:41:40,659
porque es una puerta de entrada a un fichero

1019
00:41:40,659 --> 00:41:42,579
el escáner

1020
00:41:42,579 --> 00:41:44,300
famoso, el objeto que

1021
00:41:44,300 --> 00:41:46,519
es un flujo, porque es la puerta

1022
00:41:46,519 --> 00:41:48,000
de acceso a la consola

1023
00:41:48,000 --> 00:41:50,500
también podemos crear

1024
00:41:50,500 --> 00:41:52,179
flujos asociados

1025
00:41:52,179 --> 00:41:54,460
a colecciones de datos, a Arrays

1026
00:41:54,460 --> 00:41:56,420
porque sería una puerta de entrada

1027
00:41:56,420 --> 00:41:57,420
a esa colección de datos

1028
00:41:57,420 --> 00:41:59,800
no estamos usando porque nosotros ya podemos

1029
00:41:59,800 --> 00:42:02,059
entrar directamente en la colección para iterar en ella

1030
00:42:02,059 --> 00:42:03,820
pero hay flujos que se pueden asociar

1031
00:42:03,820 --> 00:42:05,840
a colecciones o a stream o a lo que sea

1032
00:42:05,840 --> 00:42:08,179
hay flujos que se pueden

1033
00:42:08,179 --> 00:42:10,119
asociar a una

1034
00:42:10,119 --> 00:42:11,840
conexión de red

1035
00:42:11,840 --> 00:42:13,980
que son los sockets

1036
00:42:13,980 --> 00:42:16,059
etcétera, bueno pues es un ejemplo de flujo

1037
00:42:16,059 --> 00:42:17,980
vale, pues el primer aviso que te

1038
00:42:17,980 --> 00:42:19,960
dice es, que peligro abrir

1039
00:42:19,960 --> 00:42:21,320
una puerta que no cierras

1040
00:42:21,320 --> 00:42:23,940
es lo primero que te dice, porque cuando tú abres

1041
00:42:23,940 --> 00:42:26,039
una puerta, a ese recurso

1042
00:42:26,039 --> 00:42:28,559
al que lo has asociado lo dejas bloqueado.

1043
00:42:29,340 --> 00:42:30,679
Entonces, si no la cierras

1044
00:42:30,679 --> 00:42:32,599
todo el tiempo que estés sin cerrar,

1045
00:42:33,300 --> 00:42:35,840
ese recurso no está disponible para otros.

1046
00:42:36,480 --> 00:42:38,619
Entonces, cuando se abre un flujo por sistema,

1047
00:42:38,800 --> 00:42:40,460
cuando has terminado de usarlo, hay que cerrarlo.

1048
00:42:41,579 --> 00:42:43,360
Claro, entonces, es el primer aviso que te dice.

1049
00:42:43,920 --> 00:42:45,460
Cuidado que el flujo está sin cerrar.

1050
00:42:45,539 --> 00:42:47,000
Hombre, claro, es que si lo cierro,

1051
00:42:47,539 --> 00:42:50,599
espérate que opere y trabaje y ya lo cerraré después.

1052
00:42:54,119 --> 00:42:55,079
También te avisa.

1053
00:42:56,039 --> 00:42:58,820
Bueno, y aquí también te ha quedado

1054
00:42:58,820 --> 00:43:00,400
Ah, bueno, es que aquí te quedarían

1055
00:43:00,400 --> 00:43:02,039
Aquí te quedarían amarillo también

1056
00:43:02,039 --> 00:43:03,840
El rojo viene por la de la excepción

1057
00:43:03,840 --> 00:43:06,380
Ahora cuando pongamos la excepción se quedarán amarillo

1058
00:43:06,380 --> 00:43:08,619
Vale, entonces lo primero de lo que te avisa

1059
00:43:08,619 --> 00:43:10,739
Es de que cuidado que el flujo no está cerrado

1060
00:43:10,739 --> 00:43:12,179
Sí, vale, ya está, ya lo cerraré

1061
00:43:12,179 --> 00:43:14,599
Ahora mismo no puedo porque entonces me quedo sin

1062
00:43:14,599 --> 00:43:16,420
Opciones de atacar

1063
00:43:16,420 --> 00:43:18,659
Y lo siguiente que te avisa, ya lo sabemos de memoria

1064
00:43:18,659 --> 00:43:20,539
Cuidado que esto

1065
00:43:20,539 --> 00:43:22,599
Te puede sacar una excepción

1066
00:43:22,599 --> 00:43:24,139
De tipo no encuentro ese fichero

1067
00:43:24,139 --> 00:43:27,219
y esa excepción no es de tipo

1068
00:43:27,219 --> 00:43:28,159
runtime exception

1069
00:43:28,159 --> 00:43:30,239
es de tipo exception

1070
00:43:30,239 --> 00:43:33,300
te obliga a que tú digas

1071
00:43:33,300 --> 00:43:33,880
¿qué hago?

1072
00:43:34,340 --> 00:43:36,280
si no existe el archivo, ¿qué hago?

1073
00:43:37,920 --> 00:43:39,000
o somos vagos

1074
00:43:39,000 --> 00:43:40,199
horriblemente vagos

1075
00:43:40,199 --> 00:43:41,880
y hacemos esto

1076
00:43:41,880 --> 00:43:46,260
o hacemos el try catch

1077
00:43:46,260 --> 00:43:48,820
pero aquí

1078
00:43:48,820 --> 00:43:50,559
hacer el throw no es tan mala opción

1079
00:43:50,559 --> 00:43:53,039
claro, justo

1080
00:43:53,039 --> 00:43:55,139
el throw cuando es

1081
00:43:55,139 --> 00:43:55,980
una opción terrible

1082
00:43:55,980 --> 00:43:58,440
es en el main, porque

1083
00:43:58,440 --> 00:44:00,619
cuando al main le llega una excepción

1084
00:44:00,619 --> 00:44:02,780
él, que ya es el último

1085
00:44:02,780 --> 00:44:04,860
en la pila

1086
00:44:04,860 --> 00:44:06,440
es el que te para la aplicación

1087
00:44:06,440 --> 00:44:08,679
entonces yo aquí hacer el throw no es tan

1088
00:44:08,679 --> 00:44:10,559
grave, porque aquí estoy avisando al que

1089
00:44:10,559 --> 00:44:12,539
me llama, cuidado que puedo fallar

1090
00:44:12,539 --> 00:44:14,840
por esto, entonces ni siquiera es mala opción

1091
00:44:14,840 --> 00:44:16,519
porque si yo me hago aquí

1092
00:44:16,519 --> 00:44:18,699
un try catch, me lo guiso y me lo como

1093
00:44:18,699 --> 00:44:20,559
y el main, a menos que

1094
00:44:20,559 --> 00:44:22,460
yo le avise con el valor de retorno

1095
00:44:22,460 --> 00:44:24,480
con algo, no se entera

1096
00:44:24,480 --> 00:44:26,460
de lo que ha pasado. Entonces, aquí

1097
00:44:26,460 --> 00:44:28,460
en este método, tampoco es mala opción hacer un

1098
00:44:28,460 --> 00:44:30,420
throws, porque yo estoy avisando

1099
00:44:30,420 --> 00:44:32,039
al de arriba que esto

1100
00:44:32,039 --> 00:44:34,460
no me ha funcionado porque es que me has pasado

1101
00:44:34,460 --> 00:44:35,420
un fichero que no existe.

1102
00:44:36,159 --> 00:44:38,480
Me has pasado un fichero que no existe.

1103
00:44:38,579 --> 00:44:40,719
Entonces, yo te aviso. Entonces, al avisar

1104
00:44:40,719 --> 00:44:42,380
con el throws, ahora

1105
00:44:42,380 --> 00:44:44,380
el problema le ha llegado al main, que es el que nos está

1106
00:44:44,380 --> 00:44:46,340
llamando. Y al

1107
00:44:46,340 --> 00:44:48,440
haberle propagado el problema

1108
00:44:48,440 --> 00:44:50,360
al main, aquí de nuevo tenemos

1109
00:44:50,360 --> 00:44:52,340
que decir, oye, ¿qué

1110
00:44:52,340 --> 00:44:54,639
pasa si leer fichero me saca la excepción

1111
00:44:54,639 --> 00:44:56,380
y aquí sí que hacer el

1112
00:44:56,380 --> 00:44:58,519
vago y hacer el throws

1113
00:44:58,519 --> 00:45:00,139
aquí sí que sería

1114
00:45:00,139 --> 00:45:02,300
muy cómodo a la hora de escribir el código

1115
00:45:02,300 --> 00:45:03,320
porque es comodísimo

1116
00:45:03,320 --> 00:45:06,039
pero muy feo en tiempo de ejecución

1117
00:45:06,039 --> 00:45:08,260
porque si yo he metido aquí un

1118
00:45:08,260 --> 00:45:10,280
fichero que no existe, aquí es que

1119
00:45:10,280 --> 00:45:12,280
lo he metido a capón, pero podría haberlo cogido de una

1120
00:45:12,280 --> 00:45:13,760
interfaz gráfica, de lo que fuera

1121
00:45:13,760 --> 00:45:15,880
si el usuario me ha metido uno que no existe

1122
00:45:15,880 --> 00:45:18,219
en lugar de decirme el fichero no

1123
00:45:18,219 --> 00:45:19,800
existe, mete otro

1124
00:45:19,800 --> 00:45:21,880
pues la aplicación se para radical

1125
00:45:21,880 --> 00:45:24,400
entonces esas no son maneras de proceder

1126
00:45:24,400 --> 00:45:25,019
con la gente

1127
00:45:25,019 --> 00:45:27,340
entonces

1128
00:45:27,340 --> 00:45:30,099
aquí no le vamos a poner throws

1129
00:45:30,099 --> 00:45:31,659
eso es un poco feo

1130
00:45:31,659 --> 00:45:32,280
aquí le

1131
00:45:32,280 --> 00:45:34,920
vamos a

1132
00:45:34,920 --> 00:45:39,000
gracias chicos

1133
00:45:39,000 --> 00:45:39,960
vale

1134
00:45:39,960 --> 00:45:43,559
aquí vamos a ponerle el try catch

1135
00:45:43,559 --> 00:45:47,500
vale y en el try catch

1136
00:45:47,500 --> 00:45:48,900
como estamos en tiempo de desarrollo

1137
00:45:48,900 --> 00:45:51,400
nos viene estupendo dejarlo el print extract

1138
00:45:51,400 --> 00:45:53,639
trace que nos avisa de todo lo que ha ocurrido

1139
00:45:53,639 --> 00:45:55,579
pero si estuviéramos

1140
00:45:55,579 --> 00:45:57,340
ya en tiempo de entregar la aplicación

1141
00:45:57,340 --> 00:45:59,380
pues aquí en lugar de eso le avisaríamos

1142
00:45:59,380 --> 00:46:01,440
con un system out o lo que fuera

1143
00:46:01,440 --> 00:46:03,300
que quisiéramos que el tío viera

1144
00:46:03,300 --> 00:46:03,679
¿vale?

1145
00:46:05,679 --> 00:46:07,239
¿ves? ahora ya se ha quedado amarillo

1146
00:46:07,239 --> 00:46:09,340
porque eso es un aviso

1147
00:46:09,340 --> 00:46:10,239
lo del flujo

1148
00:46:10,239 --> 00:46:13,219
lo mismo que el escáner, vale, pues ahora

1149
00:46:13,219 --> 00:46:14,579
¿qué queremos hacer?

1150
00:46:15,360 --> 00:46:17,440
tenemos que ir leyendo los caracteres

1151
00:46:18,139 --> 00:46:19,500
es decir

1152
00:46:19,500 --> 00:46:20,460
queremos hacer esto

1153
00:46:20,460 --> 00:46:22,159
fr.read

1154
00:46:22,159 --> 00:46:24,820
el int que me devuelve

1155
00:46:24,820 --> 00:46:27,059
hacerle el casting a char

1156
00:46:27,059 --> 00:46:29,119
y concatenarlo

1157
00:46:29,119 --> 00:46:29,920
sobre result

1158
00:46:29,920 --> 00:46:34,659
claro, el asunto es

1159
00:46:34,659 --> 00:46:35,539
yo quiero hacer esto

1160
00:46:35,539 --> 00:46:37,900
quiero hacer esto

1161
00:46:37,900 --> 00:46:40,719
cada fr.read me va a dar un char

1162
00:46:40,719 --> 00:46:42,420
le haré el casting a char

1163
00:46:42,420 --> 00:46:43,820
porque él me lo devuelve en int

1164
00:46:43,820 --> 00:46:45,519
y lo concatenaré a result

1165
00:46:45,519 --> 00:46:48,699
pero claro, quiero hacer esto un montón de veces

1166
00:46:48,699 --> 00:46:50,360
es decir

1167
00:46:50,360 --> 00:46:52,579
esto lo voy a necesitar meter en un while

1168
00:46:52,579 --> 00:46:54,659
claro, para que se haga

1169
00:46:54,659 --> 00:46:55,679
un montón de veces

1170
00:46:55,679 --> 00:47:02,170
y ahora

1171
00:47:02,170 --> 00:47:05,329
¿cuándo acaba el while?

1172
00:47:05,750 --> 00:47:07,269
cuando esto que yo he leído

1173
00:47:07,269 --> 00:47:08,449
sea menos 1

1174
00:47:08,449 --> 00:47:11,809
entonces, como vamos a poner aquí la sentencia

1175
00:47:11,809 --> 00:47:13,929
de evaluación y tengo que haber leído

1176
00:47:13,929 --> 00:47:15,869
ya el carácter, o bien leemos

1177
00:47:15,869 --> 00:47:16,750
el primero fuera

1178
00:47:16,750 --> 00:47:18,610
que queda un poco raro

1179
00:47:18,610 --> 00:47:21,329
sí, o más sencillo

1180
00:47:21,329 --> 00:47:22,869
nosotros sabemos que una condición

1181
00:47:22,869 --> 00:47:25,849
a la vez que evalúa puede ejecutar cosas

1182
00:47:25,849 --> 00:47:27,489
entonces

1183
00:47:27,489 --> 00:47:29,849
en esa condición vamos a aprovechar

1184
00:47:29,849 --> 00:47:32,090
leemos el carácter y lo comparamos

1185
00:47:32,090 --> 00:47:34,110
directamente con el menos 1

1186
00:47:34,110 --> 00:47:35,349
es decir

1187
00:47:35,349 --> 00:47:37,969
esta va a ser la variable en la que vamos

1188
00:47:37,969 --> 00:47:39,449
a guardar

1189
00:47:39,449 --> 00:47:42,250
cada carácter leído

1190
00:47:42,250 --> 00:47:43,869
int

1191
00:47:43,869 --> 00:47:45,769
porque lo guarda en variable entera en realidad

1192
00:47:45,769 --> 00:47:47,670
pues entonces ahora hacemos

1193
00:47:47,670 --> 00:47:49,809
para cada c

1194
00:47:49,809 --> 00:47:52,070
siendo c el resultado

1195
00:47:52,070 --> 00:47:53,929
de hacer esta lectura

1196
00:47:53,929 --> 00:48:00,530
mientras sea

1197
00:48:00,530 --> 00:48:03,130
distinto de menos 1

1198
00:48:03,130 --> 00:48:05,880
¿vale?

1199
00:48:05,980 --> 00:48:07,239
entonces esta es una condición

1200
00:48:07,239 --> 00:48:09,900
porque es comparar si esto es

1201
00:48:09,900 --> 00:48:11,019
diferente de menos 1

1202
00:48:11,019 --> 00:48:13,800
pero aprovechamos porque en una condición

1203
00:48:13,800 --> 00:48:15,780
ya sabemos que podemos a la vez ejecutar

1204
00:48:15,780 --> 00:48:18,300
código ¿vale? pues aprovechamos

1205
00:48:18,300 --> 00:48:19,639
y ya de paso

1206
00:48:19,639 --> 00:48:21,880
que usamos C para compararla con menos 1

1207
00:48:21,880 --> 00:48:23,860
le hacemos una asignación

1208
00:48:23,860 --> 00:48:25,920
¿qué asignación le hacemos?

1209
00:48:26,059 --> 00:48:26,719
la que hemos leído

1210
00:48:26,719 --> 00:48:28,920
vale, pues para cada c

1211
00:48:28,920 --> 00:48:31,280
siendo c el resultado de leer un carácter

1212
00:48:31,280 --> 00:48:32,119
en ese momento

1213
00:48:32,119 --> 00:48:34,760
no, bueno

1214
00:48:34,760 --> 00:48:37,059
lo que no hago dentro de es la

1215
00:48:37,059 --> 00:48:39,260
la lectura, pero lo tengo que

1216
00:48:39,260 --> 00:48:40,320
concatenar result, claro

1217
00:48:40,320 --> 00:48:42,599
pues que hacemos

1218
00:48:42,599 --> 00:48:45,059
result más igual

1219
00:48:45,059 --> 00:48:47,659
esto

1220
00:48:47,659 --> 00:48:50,460
vale

1221
00:48:50,460 --> 00:48:52,900
entonces leemos el carácter

1222
00:48:52,900 --> 00:48:55,300
mientras no sea menos uno, hago con el carácter lo que sea

1223
00:48:55,300 --> 00:49:00,400
sí, de hecho no tendría ni que hacer el casting

1224
00:49:00,400 --> 00:49:01,940
porque la operación de concatenación

1225
00:49:01,940 --> 00:49:03,539
si se encuentra algo que no es un string

1226
00:49:03,539 --> 00:49:04,880
lo pasa a string

1227
00:49:04,880 --> 00:49:06,860
de hecho es que aunque no hiciera el casting

1228
00:49:06,860 --> 00:49:09,880
el paso, como él tiene que forzar

1229
00:49:09,880 --> 00:49:11,900
la conversión para la operación de concatenación

1230
00:49:11,900 --> 00:49:13,320
ya la forzaría correctamente

1231
00:49:13,320 --> 00:49:15,239
es decir, este forzar a char

1232
00:49:15,239 --> 00:49:19,800
vamos a comprobarlo

1233
00:49:19,800 --> 00:49:21,880
porque si nosotros lo eliminamos

1234
00:49:21,880 --> 00:49:23,719
¿qué es lo que va a hacer?

1235
00:49:23,719 --> 00:49:25,739
tiene una operación de concatenación

1236
00:49:25,739 --> 00:49:27,119
que es cadena, que es result

1237
00:49:27,119 --> 00:49:28,380
con un número entero

1238
00:49:28,380 --> 00:49:31,079
entonces fuerza su concatenación a string

1239
00:49:31,079 --> 00:49:33,519
pero fuerza la concatenación a string

1240
00:49:33,519 --> 00:49:35,920
del número entero

1241
00:49:35,920 --> 00:49:37,840
entonces nosotros queremos la conversión

1242
00:49:37,840 --> 00:49:38,260
a char

1243
00:49:38,260 --> 00:49:40,239
¿vale? entonces

1244
00:49:40,239 --> 00:49:43,460
por eso ahí seguramente

1245
00:49:43,460 --> 00:49:44,579
vamos a dejarlo de hecho

1246
00:49:44,579 --> 00:49:47,440
para ver ese

1247
00:49:47,440 --> 00:49:49,139
numerito entero que él ha leído

1248
00:49:49,139 --> 00:49:51,280
que sabemos que en el byte menos significativo

1249
00:49:51,280 --> 00:49:52,300
está el char, eso lo sabemos

1250
00:49:52,300 --> 00:49:53,699
y que en el resto hay todo cero

1251
00:49:53,699 --> 00:49:56,360
vamos a ver cómo fuerza la conversión a string

1252
00:49:56,360 --> 00:49:57,139
para concatenar

1253
00:49:57,139 --> 00:50:00,639
seguramente lo convierta al entero que representa

1254
00:50:00,639 --> 00:50:02,199
no, aunque eso lo haría

1255
00:50:02,199 --> 00:50:04,239
integer parseín, eso lo hacemos con

1256
00:50:04,239 --> 00:50:06,360
integer parseín normalmente, entonces si lo hacemos

1257
00:50:06,360 --> 00:50:07,260
con integer parseín

1258
00:50:07,260 --> 00:50:10,280
ah no, perdón, sí, sí, sí, olvidadlo

1259
00:50:10,280 --> 00:50:11,860
vale, entonces

1260
00:50:11,860 --> 00:50:14,079
él forzará la conversión a string

1261
00:50:14,079 --> 00:50:15,920
porque la necesita de ese numerito

1262
00:50:15,920 --> 00:50:18,280
y la concatenará

1263
00:50:18,860 --> 00:50:19,300
result

1264
00:50:19,300 --> 00:50:22,239
esa conversión, casi seguro que no

1265
00:50:22,239 --> 00:50:24,199
estará bien, con lo cual tendremos que arreglarlo

1266
00:50:24,199 --> 00:50:26,099
haciendo el casting a char

1267
00:50:26,099 --> 00:50:27,880
porque el casting a char ya sí que es

1268
00:50:27,880 --> 00:50:29,440
me quedo con el menos significativo

1269
00:50:29,440 --> 00:50:32,119
el casting a char ya sí que es corto y me quedo

1270
00:50:32,119 --> 00:50:33,019
con el menos significativo

1271
00:50:33,019 --> 00:50:34,179
vale

1272
00:50:34,179 --> 00:50:37,639
me avisa lo de que cuidado

1273
00:50:37,639 --> 00:50:39,760
que esto me puede sacar una excepción y trae salida

1274
00:50:39,760 --> 00:50:42,000
pero a mí no me ha dejado un casting a char

1275
00:50:42,000 --> 00:50:43,719
o un string, lo he tenido que hacer sumarle

1276
00:50:43,719 --> 00:50:44,960
una cadena vacía

1277
00:50:44,960 --> 00:50:50,880
pero no sirve para nada

1278
00:50:50,880 --> 00:50:52,739
para que no dé error

1279
00:50:52,739 --> 00:50:54,780
no sé

1280
00:50:54,780 --> 00:50:56,500
No sé

1281
00:50:56,500 --> 00:51:01,800
Bueno, ahora estamos concatenando un int

1282
00:51:01,800 --> 00:51:03,639
Pero en cualquier caso, un char a un string

1283
00:51:03,639 --> 00:51:04,579
Debería

1284
00:51:04,579 --> 00:51:09,380
Bueno, lo probamos

1285
00:51:09,380 --> 00:51:11,300
Pero debería concatenar

1286
00:51:11,300 --> 00:51:13,980
Pero vamos, debería

1287
00:51:13,980 --> 00:51:16,539
Poder hacer un string más un char

1288
00:51:16,539 --> 00:51:17,960
Debería hacer la conversión

1289
00:51:17,960 --> 00:51:18,980
Y que el resultado fuera un string

1290
00:51:18,980 --> 00:51:22,119
Bueno, habría que ver en qué situaciones

1291
00:51:22,119 --> 00:51:23,940
Vale, entonces, lógicamente nos vuelve a decir

1292
00:51:23,940 --> 00:51:25,679
oye que puede salir una excepción

1293
00:51:25,679 --> 00:51:26,659
no de tipo runtime

1294
00:51:26,659 --> 00:51:30,179
y pues bueno vamos a propagarla

1295
00:51:30,179 --> 00:51:31,440
y que el de arriba decida

1296
00:51:31,440 --> 00:51:33,719
otro throws

1297
00:51:33,719 --> 00:51:35,480
porque ahora hay dos posibles causas de error

1298
00:51:35,480 --> 00:51:37,239
que el fichero no exista

1299
00:51:37,239 --> 00:51:40,219
y que la operación de lectura no haya sido exitosa

1300
00:51:40,219 --> 00:51:41,960
porque el fichero justo se ha roto

1301
00:51:41,960 --> 00:51:43,019
en ese momento el disco duro

1302
00:51:43,019 --> 00:51:45,179
pues si justo en ese momento se ha roto el disco duro

1303
00:51:45,179 --> 00:51:47,019
pues habrá habido un problema

1304
00:51:47,019 --> 00:51:49,719
entonces como ahora este tiene

1305
00:51:49,719 --> 00:51:50,500
dos throws

1306
00:51:50,500 --> 00:51:53,619
no, a ver

1307
00:51:53,619 --> 00:51:55,699
no tiene dos throws, lo ha metido en uno

1308
00:51:55,699 --> 00:51:57,960
porque el file not found exception

1309
00:51:57,960 --> 00:52:00,139
hereda de io exception

1310
00:52:00,139 --> 00:52:01,000
hereda

1311
00:52:01,000 --> 00:52:03,420
entonces gracias a que todas las

1312
00:52:03,420 --> 00:52:05,900
claro, gracias a que todas las

1313
00:52:05,900 --> 00:52:08,019
clases en general de los paquetes que usamos

1314
00:52:08,019 --> 00:52:09,820
están estructuradas

1315
00:52:09,820 --> 00:52:11,519
en una jerarquía de clases con herencia

1316
00:52:11,519 --> 00:52:13,619
eso tiene su lado malo, no puedes decirle

1317
00:52:13,619 --> 00:52:14,320
por qué acepta

1318
00:52:14,320 --> 00:52:17,900
bueno, tú puedes hacerla

1319
00:52:17,900 --> 00:52:20,699
sí, tú hará

1320
00:52:20,699 --> 00:52:23,599
a ver, yo podría hacer esto, lo que pasa es que tengo que

1321
00:52:23,599 --> 00:52:27,039
ya, pero yo puedo hacer un multicatch

1322
00:52:27,039 --> 00:52:34,159
a ver, el multicatch yo lo puedo hacer

1323
00:52:34,159 --> 00:52:35,360
perfectamente

1324
00:52:35,360 --> 00:52:38,079
que es file not found exception, hace esto

1325
00:52:38,079 --> 00:52:40,239
que no es file not found exception

1326
00:52:40,239 --> 00:52:41,800
y es io exception

1327
00:52:41,800 --> 00:52:44,300
pues hace esto otro

1328
00:52:44,300 --> 00:52:46,500
¿vale? lo que no puedo hacer en el multicatch

1329
00:52:46,500 --> 00:52:47,340
es ponerlo al revés

1330
00:52:47,340 --> 00:52:50,239
porque como file not found exception hereda

1331
00:52:50,239 --> 00:52:52,260
de esta, me diría, oye que ya

1332
00:52:52,260 --> 00:52:53,679
me has capturado en la anterior

1333
00:52:53,679 --> 00:52:56,219
vale, pero yo puedo hacer un multicatch así

1334
00:52:56,219 --> 00:52:57,199
y distinguir

1335
00:52:57,199 --> 00:53:12,199
no se encontró el archivo

1336
00:53:22,260 --> 00:53:31,300
A ver, tira

1337
00:53:31,300 --> 00:53:33,559
No, esto está en tiempo de ejecución

1338
00:53:33,559 --> 00:53:35,019
No tira la padre

1339
00:53:35,019 --> 00:53:36,579
Tira la que es

1340
00:53:36,579 --> 00:53:38,260
Tira la que es porque es un objeto

1341
00:53:38,260 --> 00:53:43,840
Lo que pasa es que el compilador

1342
00:53:43,840 --> 00:53:45,000
Te permite poner esta

1343
00:53:45,000 --> 00:53:46,480
Porque en tiempo de compilación

1344
00:53:46,480 --> 00:53:47,460
Casan las dos

1345
00:53:47,460 --> 00:53:50,940
Claro, claro

1346
00:53:50,940 --> 00:53:56,300
pero con un error específico

1347
00:53:56,300 --> 00:53:56,960
¿a qué te refieres?

1348
00:53:57,019 --> 00:53:58,260
un objeto específico

1349
00:53:58,260 --> 00:53:59,980
claro, claro, claro

1350
00:53:59,980 --> 00:54:01,579
file not found exception es una clase

1351
00:54:01,579 --> 00:54:02,820
io exception es otra

1352
00:54:02,820 --> 00:54:05,039
file not found exception hereda de io exception

1353
00:54:05,039 --> 00:54:07,599
claro, entonces si tú aquí

1354
00:54:07,599 --> 00:54:10,300
el error ha venido por aquí

1355
00:54:10,300 --> 00:54:12,280
el throw que se lanza es

1356
00:54:12,280 --> 00:54:13,579
file not found exception

1357
00:54:13,579 --> 00:54:14,420
se lanza esa

1358
00:54:14,420 --> 00:54:16,539
lo que pasa es que el compilador te dice

1359
00:54:16,539 --> 00:54:17,960
aunque sea esa la que lances

1360
00:54:17,960 --> 00:54:20,900
como cae aquí yo te dejo que en tiempo de compilación

1361
00:54:20,900 --> 00:54:23,139
me pongas eso, pero en tiempo de ejecución

1362
00:54:23,139 --> 00:54:24,940
la que se lanza es esa, con lo cual cuando llegue

1363
00:54:24,940 --> 00:54:26,920
aquí arriba, entrará en esta parte

1364
00:54:26,920 --> 00:54:28,599
del catch, entrará en esa de arriba

1365
00:54:28,599 --> 00:54:29,659
¿vale?

1366
00:54:30,659 --> 00:54:31,139
vale

1367
00:54:31,139 --> 00:54:34,800
bueno, pues ahora

1368
00:54:34,800 --> 00:54:36,940
ya está

1369
00:54:36,940 --> 00:54:38,760
ya podemos probar esto

1370
00:54:38,760 --> 00:54:40,400
si le hacemos caso

1371
00:54:40,400 --> 00:54:42,920
como mi aplicación termina, en realidad

1372
00:54:42,920 --> 00:54:44,840
no me haría falta cerrar el flujo porque

1373
00:54:44,840 --> 00:54:46,880
cuando una aplicación termina, cierra todos los

1374
00:54:46,880 --> 00:54:48,880
flujos que lo acompañan, pero

1375
00:54:48,880 --> 00:54:50,460
siempre es muy buena idea

1376
00:54:50,460 --> 00:54:53,340
no olvidarse de cerrar

1377
00:54:53,340 --> 00:54:55,360
vamos a ver

1378
00:54:55,360 --> 00:54:56,760
como nos lee los nombres

1379
00:54:56,760 --> 00:54:58,739
que me ha faltado aquí

1380
00:54:58,739 --> 00:55:00,260
ah, que esta la he llamado ex

1381
00:55:00,260 --> 00:55:02,519
pues ex, vale

1382
00:55:02,519 --> 00:55:05,000
que me ha faltado aquí, por ejemplo

1383
00:55:05,000 --> 00:55:07,579
vamos a ponerle un nombre que no exista

1384
00:55:07,579 --> 00:55:09,260
vale

1385
00:55:09,260 --> 00:55:10,300
entonces aquí

1386
00:55:10,300 --> 00:55:25,639
vale

1387
00:55:25,639 --> 00:55:27,340
no estoy ejecutando

1388
00:55:27,340 --> 00:55:28,659
es

1389
00:55:28,659 --> 00:55:33,639
Vale, estaba ejecutando otra aplicación

1390
00:55:33,639 --> 00:55:35,880
Vale, pues efectivamente

1391
00:55:35,880 --> 00:55:38,019
No se encontró el archivo y la que lanza es esta

1392
00:55:38,019 --> 00:55:39,079
Porque no se encontró

1393
00:55:39,079 --> 00:55:41,480
Forzar la otra no podemos forzarla

1394
00:55:41,480 --> 00:55:43,739
Porque hombre, romper el disco duro en el momento

1395
00:55:43,739 --> 00:55:45,280
En el que está leyendo no lo podemos hacer

1396
00:55:45,280 --> 00:55:47,739
Pero esta la podemos forzar

1397
00:55:47,739 --> 00:55:48,500
Efectivamente

1398
00:55:48,500 --> 00:55:52,019
Bueno, tu poder podrías

1399
00:55:52,019 --> 00:55:53,039
Ya está claro

1400
00:55:53,039 --> 00:55:57,639
Ya, pero bueno, no hay necesidad

1401
00:55:57,639 --> 00:55:59,679
vale, vamos a probar ahora

1402
00:55:59,679 --> 00:56:01,940
pues efectivamente

1403
00:56:01,940 --> 00:56:04,480
fijaos el archivo

1404
00:56:04,480 --> 00:56:06,179
que me ha leído, estos son

1405
00:56:06,179 --> 00:56:08,400
la sucesión de los números enteros

1406
00:56:08,400 --> 00:56:10,199
que son

1407
00:56:10,199 --> 00:56:12,119
los int

1408
00:56:12,119 --> 00:56:13,780
que me ha leído con ese char

1409
00:56:13,780 --> 00:56:16,119
etcétera, vale

1410
00:56:16,119 --> 00:56:17,440
entonces esto no tiene sentido

1411
00:56:17,440 --> 00:56:20,239
claro, porque que nos ha faltado

1412
00:56:20,239 --> 00:56:22,280
esta con este casting

1413
00:56:22,280 --> 00:56:22,639
de aquí

1414
00:56:22,639 --> 00:56:25,420
vale, claro

1415
00:56:25,420 --> 00:56:27,980
ahora ya, C, se queda

1416
00:56:27,980 --> 00:56:29,659
con el byte menos significativo

1417
00:56:29,659 --> 00:56:32,119
y ahora ves, Juanjo

1418
00:56:32,119 --> 00:56:34,159
te deja concatenar

1419
00:56:34,159 --> 00:56:35,639
un string a un char sin problemas

1420
00:56:35,639 --> 00:56:37,579
¿vale? estamos haciendo el casting

1421
00:56:37,579 --> 00:56:39,900
ahora ya sí, está leyendo los

1422
00:56:39,900 --> 00:56:42,119
char y concatenándolos, no convirtiendo

1423
00:56:42,119 --> 00:56:44,019
en el int, ahora ya

1424
00:56:44,019 --> 00:56:45,780
pues sí, ¿vale? nos lee

1425
00:56:45,780 --> 00:56:47,219
el archivo y todo eso

1426
00:56:47,219 --> 00:56:49,480
vale

1427
00:56:49,480 --> 00:56:54,119
entonces, este es el bucle de lectura

1428
00:56:54,119 --> 00:56:56,000
clásico para leer del archivo de texto

1429
00:56:56,000 --> 00:56:59,679
el bucle de lectura

1430
00:56:59,679 --> 00:57:02,260
y dentro del bucle

1431
00:57:02,260 --> 00:57:04,019
de lectura uno hace lo que quiere

1432
00:57:04,019 --> 00:57:04,659
¿vale?

1433
00:57:06,099 --> 00:57:09,570
por ejemplo, si ahora hacemos otro

1434
00:57:09,570 --> 00:57:11,289
método, que sea

1435
00:57:11,289 --> 00:57:39,389
vale, pues ahora vamos a cambiarlo

1436
00:57:39,389 --> 00:57:40,989
a este método

1437
00:57:40,989 --> 00:57:45,659
que sea, ahora en lugar de mostrar

1438
00:57:45,659 --> 00:57:47,280
el fichero tal cual

1439
00:57:47,280 --> 00:57:48,739
el fichero tal cual

1440
00:57:48,739 --> 00:57:51,360
vamos a mostrarlo sin los saltos de línea

1441
00:57:51,360 --> 00:57:53,719
todo seguido, vamos a mostrarlo todo seguido

1442
00:57:53,719 --> 00:57:54,699
sin los saltos de línea

1443
00:57:54,699 --> 00:57:57,980
pues de nuevo será el bucle de lectura

1444
00:57:57,980 --> 00:57:59,280
y habrá que ver que hacemos

1445
00:57:59,280 --> 00:58:01,159
para mostrarlo sin los saltos de línea

1446
00:58:01,159 --> 00:58:03,139
todo seguido, pues venga

1447
00:58:03,139 --> 00:58:04,539
hacer este método

1448
00:58:04,539 --> 00:58:07,199
basado sobre el anterior pero habrá que

1449
00:58:07,199 --> 00:58:09,519
modificar un poquito lo que se hace dentro del bucle

1450
00:58:09,519 --> 00:58:12,219
pues venga