1
00:00:02,220 --> 00:00:06,200
Bueno, pues vamos a ver qué nos decía la otra pestañita.

2
00:00:08,080 --> 00:00:09,240
Le damos un nombre.

3
00:00:11,099 --> 00:00:25,980
Al pulsar el botón de unir, se solicitará el nombre del fichero de destino y ahora buscará ficheros que se llamen así, seguido de un número y con extensión PTR, ordenados a partir de 1.

4
00:00:26,059 --> 00:00:27,839
Bueno, nosotros lo hemos hecho antes con 0, pero da igual.

5
00:00:28,339 --> 00:00:31,019
Sería empezar la I en lugar de 0 en 1, pero da lo mismo.

6
00:00:31,019 --> 00:00:33,579
y a partir de ahí

7
00:00:33,579 --> 00:00:35,759
leemos los ficheros

8
00:00:35,759 --> 00:00:40,579
los guardamos

9
00:00:40,579 --> 00:00:42,679
en una estructura de datos dinámica

10
00:00:42,679 --> 00:00:44,820
que contenga file

11
00:00:44,820 --> 00:00:48,679
y ahora

12
00:00:48,679 --> 00:00:50,979
tendremos que leer

13
00:00:50,979 --> 00:00:53,079
de todos esos y llevarlos a un fichero

14
00:00:53,079 --> 00:00:53,920
con el nombre indicado

15
00:00:53,920 --> 00:00:57,609
bueno, más o menos entendemos lo que hay que hacer

16
00:00:57,609 --> 00:01:00,250
nos van a dar un nombre, una raíz común

17
00:01:00,250 --> 00:01:02,009
habrá que buscar

18
00:01:02,009 --> 00:01:05,030
todos los ficheros

19
00:01:05,030 --> 00:01:05,969
que se llamen así

20
00:01:05,969 --> 00:01:08,689
no especifica en qué ruta

21
00:01:08,689 --> 00:01:10,390
vamos a poner que en la ruta por defecto

22
00:01:10,390 --> 00:01:11,969
del proyecto

23
00:01:11,969 --> 00:01:14,849
todos los ficheros que se llamen así

24
00:01:14,849 --> 00:01:16,390
seguidos de un numerito

25
00:01:16,390 --> 00:01:17,670
y una extensión ptr

26
00:01:17,670 --> 00:01:20,689
y luego tendrá que ir leyendo

27
00:01:20,689 --> 00:01:22,650
de ellos e ir escribiéndolo

28
00:01:22,650 --> 00:01:24,709
todo sucesivamente en otro fichero final

29
00:01:24,709 --> 00:01:26,609
pues venga va a tener

30
00:01:26,609 --> 00:01:28,390
solamente un botón

31
00:01:28,390 --> 00:01:30,230
merge

32
00:01:30,230 --> 00:01:32,829
y el nombre

33
00:01:32,829 --> 00:01:37,629
en un text field

34
00:01:37,629 --> 00:01:38,989
con el nombre de la raíz.

35
00:01:39,390 --> 00:01:39,609
Vale.

36
00:01:44,239 --> 00:01:45,239
Ah, no, en este text field

37
00:01:45,239 --> 00:01:46,420
el fichero destino.

38
00:01:47,939 --> 00:01:51,430
Y los...

39
00:01:51,430 --> 00:01:53,230
Ah, vale, el merge solicita...

40
00:01:54,530 --> 00:01:55,530
Venga, pues a ver.

41
00:01:55,670 --> 00:01:56,230
Vamos a ver.

42
00:01:59,319 --> 00:02:00,359
Emerge, entonces.

43
00:02:02,900 --> 00:02:04,799
Primero, un text field

44
00:02:06,060 --> 00:02:08,280
A ver, primero, antes que nada

45
00:02:08,280 --> 00:02:09,719
Poner el

46
00:02:09,719 --> 00:02:19,139
Antes que nada

47
00:02:19,139 --> 00:02:19,800
Poner

48
00:02:19,800 --> 00:02:24,360
Venga, continuamos

49
00:02:24,360 --> 00:02:25,520
Vamos a acabar

50
00:02:25,520 --> 00:02:26,080
¿Qué?

51
00:02:27,879 --> 00:02:29,139
¿Vas a seguir un rato a dar una vuelta?

52
00:02:29,819 --> 00:02:31,740
¡Hala! Panel de Merge

53
00:02:31,740 --> 00:02:33,620
Absolute Layout

54
00:02:33,620 --> 00:02:35,139
Ahora hemos dicho

55
00:02:35,139 --> 00:02:35,960
Un Text Fill

56
00:02:35,960 --> 00:02:37,659
Para poner

57
00:02:37,659 --> 00:02:40,680
La raíz

58
00:02:40,680 --> 00:02:42,879
De los ficheros que se van a unir

59
00:02:42,879 --> 00:02:45,699
Vale

60
00:02:45,699 --> 00:02:49,259
Texto raíz le voy a llamar

61
00:02:49,259 --> 00:02:52,800
Texto raíz

62
00:02:52,800 --> 00:02:53,400
Vale

63
00:02:53,400 --> 00:02:55,520
Vamos a poner una etiqueta

64
00:02:55,520 --> 00:02:57,800
Para indicar al usuario lo que tiene que poner ahí

65
00:02:57,800 --> 00:03:01,240
Y ahí en esa etiqueta

66
00:03:01,240 --> 00:03:02,759
Pues tiene que haber

67
00:03:02,759 --> 00:03:06,120
Raíz

68
00:03:06,120 --> 00:03:09,759
De los ficheros

69
00:03:09,759 --> 00:03:11,439
A unir

70
00:03:11,439 --> 00:03:17,479
raíz de los ficheros

71
00:03:17,479 --> 00:03:25,000
a unir, vale, ya está

72
00:03:25,000 --> 00:03:29,120
ahora, botón de merge, pues venga

73
00:03:29,120 --> 00:03:32,219
botón, se va a ir aquí

74
00:03:32,219 --> 00:03:43,300
y este botón va a tener como texto, pues eso

75
00:03:43,300 --> 00:03:44,280
merge

76
00:03:44,280 --> 00:03:48,780
y ya está

77
00:03:48,780 --> 00:03:50,819
no hay más controles que poner

78
00:03:50,819 --> 00:03:53,199
ahí se pone la raíz y cuando se dé al botón

79
00:03:53,199 --> 00:03:55,759
él te pide en un jOptionPane el nombre del fichero destino

80
00:03:55,759 --> 00:03:57,580
y te hace todo eso

81
00:03:57,580 --> 00:03:58,419
que dice que hay que hacer

82
00:03:58,419 --> 00:04:01,539
pues venga, solo hay un evento entonces

83
00:04:01,539 --> 00:04:03,800
el del botón, pues vamos a hacer el evento

84
00:04:03,800 --> 00:04:14,729
venga, evento del botón

85
00:04:14,729 --> 00:04:16,230
primero

86
00:04:16,230 --> 00:04:18,149
nos va a abrir

87
00:04:18,149 --> 00:04:20,009
un jOptionPane

88
00:04:20,009 --> 00:04:22,069
para pedirnos el nombre del fichero

89
00:04:22,069 --> 00:04:25,870
destino. Pues un jOptionPane

90
00:04:25,870 --> 00:04:29,290
como el que hemos abierto antes para

91
00:04:29,290 --> 00:04:33,230
poner el fichero de destino

92
00:04:33,230 --> 00:04:38,269
sobre el que vamos a escribir. El fichero

93
00:04:38,269 --> 00:04:40,970
de destino va a ser

94
00:04:40,970 --> 00:04:44,930
la vuelta que nos da un jOptionPane

95
00:04:44,930 --> 00:04:52,660
con el showInputDialog que le ponemos

96
00:04:52,660 --> 00:04:55,160
introduzca

97
00:04:55,160 --> 00:04:57,220
nombre

98
00:04:57,220 --> 00:04:59,740
fichero, destino

99
00:04:59,740 --> 00:05:11,220
bueno, pues sobre este fichero

100
00:05:11,220 --> 00:05:12,180
vamos a escribir

101
00:05:12,180 --> 00:05:14,639
vale, pero ahora

102
00:05:14,639 --> 00:05:17,480
sobre todo

103
00:05:17,480 --> 00:05:19,240
lo que nos importa es

104
00:05:19,240 --> 00:05:21,240
crear una estructura

105
00:05:21,240 --> 00:05:23,139
dinámica, una estructura de este tipo

106
00:05:23,139 --> 00:05:33,060
por ejemplo

107
00:05:33,060 --> 00:05:34,879
una release, esta misma

108
00:05:34,879 --> 00:05:38,060
una estructura dinámica

109
00:05:38,060 --> 00:05:41,860
con todos los objetos file que se van a unir.

110
00:05:43,560 --> 00:05:45,779
Porque una vez que tengamos una estructura dinámica

111
00:05:45,779 --> 00:05:48,139
con todos los objetos file que se van a unir,

112
00:05:49,860 --> 00:05:53,579
se tratará de recorrerla y abrimos para leer

113
00:05:53,579 --> 00:05:55,139
y escribimos en el otro.

114
00:05:55,620 --> 00:05:56,819
Y este primero lo cerramos.

115
00:05:57,360 --> 00:05:59,560
En la siguiente iteración sobre el list,

116
00:05:59,800 --> 00:06:02,660
abrimos el siguiente y seguimos escribiendo en el otro

117
00:06:02,660 --> 00:06:04,699
que se abrió para escribir al principio de todo.

118
00:06:05,939 --> 00:06:07,459
Luego, una vez que tengamos esta estructura

119
00:06:07,459 --> 00:06:10,060
con los ficheros a unir es un bucle que itere por el file

120
00:06:10,060 --> 00:06:13,220
y lea cada uno de ellos y escriba el otro

121
00:06:13,220 --> 00:06:16,259
y ya está, pero claro, tenemos que conseguir

122
00:06:16,259 --> 00:06:18,399
todos esos files, bueno

123
00:06:18,399 --> 00:06:21,540
pues no es tan difícil porque tendremos que

124
00:06:21,540 --> 00:06:24,379
listar todos los ficheros que estén

125
00:06:24,379 --> 00:06:27,939
en el directorio en el que se supone que estamos trabajando

126
00:06:27,939 --> 00:06:30,519
no nos lo especifica, nos supone que estamos trabajando en la raíz del proyecto

127
00:06:30,519 --> 00:06:33,920
para que no sea, de todos esos ficheros

128
00:06:33,920 --> 00:06:37,319
ir cogiendo aquellos cuyo nombre

129
00:06:37,319 --> 00:06:38,439
siga este patrón

130
00:06:38,439 --> 00:06:41,839
empieza con lo que hay en área de texto

131
00:06:41,839 --> 00:06:43,579
continúa con

132
00:06:43,579 --> 00:06:45,779
un numerito y tiene como extensión

133
00:06:45,779 --> 00:06:46,240
ptr

134
00:06:46,240 --> 00:06:48,560
pues venga, vamos a hacerlo primero esto

135
00:06:48,560 --> 00:06:53,319
vamos a listar

136
00:06:53,319 --> 00:06:55,319
todos los

137
00:06:55,319 --> 00:06:56,439
ficheros que están

138
00:06:56,439 --> 00:07:04,910
en el directorio de trabajo

139
00:07:04,910 --> 00:07:11,720
ala, esto mismo que he hecho

140
00:07:11,720 --> 00:07:13,779
esta línea que he hecho, lo he hecho sobre una línea

141
00:07:13,779 --> 00:07:15,899
no os agobia, o sea, new file

142
00:07:15,899 --> 00:07:18,199
recordad que el punto

143
00:07:18,199 --> 00:07:21,439
es el directorio actual de trabajo

144
00:07:21,439 --> 00:07:23,920
el punto siempre significa el directorio actual de trabajo

145
00:07:23,920 --> 00:07:25,939
que en nuestro caso es la raíz del proyecto

146
00:07:25,939 --> 00:07:27,139
vale

147
00:07:27,139 --> 00:07:28,300
entonces

148
00:07:28,300 --> 00:07:31,779
a la vez que instancio ese objeto file

149
00:07:31,779 --> 00:07:33,759
en lugar de guardar una referencia aparte

150
00:07:33,759 --> 00:07:34,920
y luego esa referencia

151
00:07:34,920 --> 00:07:37,959
hacer ya list files para que me dé todos los ficheros que tiene

152
00:07:37,959 --> 00:07:40,160
pues no lo guardo en una referencia aparte

153
00:07:40,160 --> 00:07:41,860
ya directamente le hago list files

154
00:07:41,860 --> 00:07:43,680
y ya recordad que este método

155
00:07:43,680 --> 00:07:44,759
que lo hemos usado alguna vez

156
00:07:44,759 --> 00:07:47,959
nos da un array con todos los objetos file

157
00:07:47,959 --> 00:07:49,000
que está en esa ubicación

158
00:07:49,000 --> 00:07:52,160
vale, pues ahora habrá que ir

159
00:07:52,160 --> 00:07:54,180
uno por uno y todos aquellos

160
00:07:54,180 --> 00:07:55,600
que sean ficheros

161
00:07:55,600 --> 00:07:56,839
y cuyo nombre

162
00:07:56,839 --> 00:07:59,579
empiece con la raíz común

163
00:07:59,579 --> 00:08:03,519
continúe con un número y tenga extensión

164
00:08:03,519 --> 00:08:05,639
ptr, pues todos esos se van a la estructura

165
00:08:05,639 --> 00:08:05,959
file

166
00:08:05,959 --> 00:08:11,740
bueno, no, estos son todos los que hay en la carpeta

167
00:08:12,379 --> 00:08:13,579
todos

168
00:08:13,579 --> 00:08:15,800
pero tengo que

169
00:08:15,800 --> 00:08:17,740
meter en el list de arriba los que me interesan

170
00:08:18,259 --> 00:08:19,720
vale, pues

171
00:08:19,720 --> 00:08:21,639
entonces, esto ahora ya

172
00:08:21,639 --> 00:08:23,279
podemos hacer, vamos a ir uno por uno

173
00:08:23,279 --> 00:08:31,899
para cada objeto file

174
00:08:31,899 --> 00:08:35,980
en este listado de

175
00:08:35,980 --> 00:08:37,620
ficheros, para cada objeto file

176
00:08:37,620 --> 00:08:40,100
¿qué tenemos que hacer?

177
00:08:40,559 --> 00:08:42,240
si cumple la condición

178
00:08:42,240 --> 00:08:44,080
que

179
00:08:44,080 --> 00:08:46,120
necesitamos y es que su nombre responde

180
00:08:46,120 --> 00:08:47,259
al patrón correspondiente

181
00:08:47,259 --> 00:08:50,100
si la cumple se va al listado de arriba

182
00:08:50,100 --> 00:08:51,919
entonces

183
00:08:51,919 --> 00:08:53,779
esto si que vamos a sacarlo, método aparte

184
00:08:53,779 --> 00:08:55,419
por comodidad, entonces podemos hacer

185
00:08:55,419 --> 00:09:03,929
validar nombre

186
00:09:03,929 --> 00:09:04,450
de f

187
00:09:04,450 --> 00:09:07,049
pues si validara el nombre

188
00:09:07,049 --> 00:09:09,850
entonces es uno de los ficheros a unir

189
00:09:09,850 --> 00:09:11,429
ficheros unir

190
00:09:11,429 --> 00:09:12,769
punto ad f

191
00:09:12,769 --> 00:09:18,879
bueno vamos a ponerle antes y si es fichero

192
00:09:18,879 --> 00:09:20,679
porque puede ser directorio porque list file

193
00:09:20,679 --> 00:09:22,559
me saca todo lo que hay dentro de

194
00:09:22,559 --> 00:09:24,960
esto sean directorios

195
00:09:24,960 --> 00:09:26,539
sean ficheros entonces puedo ser primero

196
00:09:26,539 --> 00:09:28,340
si

197
00:09:28,340 --> 00:09:30,419
f

198
00:09:30,419 --> 00:09:33,120
punto isFile

199
00:09:33,120 --> 00:09:37,169
y además

200
00:09:37,169 --> 00:09:38,649
de ser fichero

201
00:09:38,649 --> 00:09:59,509
vale, pues este bucle está claro

202
00:09:59,509 --> 00:10:00,750
lo que hace, se va

203
00:10:00,750 --> 00:10:03,750
a todos y cada uno de los ficheros

204
00:10:03,750 --> 00:10:05,549
que están contenidos en el

205
00:10:05,549 --> 00:10:07,070
directorio de trabajo

206
00:10:07,070 --> 00:10:09,850
si son ficheros

207
00:10:09,850 --> 00:10:11,649
y además su nombre

208
00:10:11,649 --> 00:10:13,610
valida, que todavía no hemos hecho el método de validar

209
00:10:13,610 --> 00:10:15,669
añádelo como fichero a unir

210
00:10:15,669 --> 00:10:17,769
a la estructura de fichero a unir

211
00:10:17,769 --> 00:10:22,019
que está arriba, entonces este método

212
00:10:22,019 --> 00:10:23,539
validar, vamos a tener que hacerlo

213
00:10:23,539 --> 00:10:26,340
vamos a tener que hacerlo

214
00:10:26,340 --> 00:10:27,860
pues por ejemplo vamos a hacerlo

215
00:10:27,860 --> 00:10:32,190
aquí

216
00:10:32,190 --> 00:10:42,360
static boolean

217
00:10:42,360 --> 00:10:45,279
validar

218
00:10:45,279 --> 00:10:50,000
está sin hacer, con lo cual

219
00:10:50,000 --> 00:10:52,120
un retunfalse, porque ahora mismo está sin hacer

220
00:10:52,120 --> 00:10:53,940
ahora mismo subimos que no valida ninguno

221
00:10:53,940 --> 00:10:55,299
vale

222
00:10:55,299 --> 00:10:58,399
tendremos que meter ahora aquí el código

223
00:10:58,399 --> 00:11:00,139
para ver si este fichero

224
00:11:00,139 --> 00:11:02,059
su nombre cumple la condición que queremos

225
00:11:02,059 --> 00:11:04,039
venga

226
00:11:04,039 --> 00:11:10,889
validar

227
00:11:10,889 --> 00:11:11,350
vale

228
00:11:11,350 --> 00:11:13,029
y estamos

229
00:11:13,029 --> 00:11:16,309
en este evento

230
00:11:16,309 --> 00:11:18,509
en cual estamos aquí

231
00:11:18,509 --> 00:11:23,360
vale, pues entonces seguimos

232
00:11:23,360 --> 00:11:25,200
nos falta reinar este huequito

233
00:11:25,200 --> 00:11:26,840
claro, como validar el nombre de ese fichero

234
00:11:26,840 --> 00:11:28,759
una vez que se fuera terminado

235
00:11:28,759 --> 00:11:31,279
ya tenemos en esta

236
00:11:31,279 --> 00:11:32,240
estructura de arriba

237
00:11:32,240 --> 00:11:34,980
todos los ficheros a unir, pues ahora lleven

238
00:11:34,980 --> 00:11:36,860
la parte fácil, que es recorrerlos

239
00:11:36,860 --> 00:11:39,200
abrirlos para leer y escribir en el

240
00:11:39,200 --> 00:11:41,059
de destino. El de destino

241
00:11:41,059 --> 00:11:42,559
su nombre, ¿dónde está? Aquí.

242
00:11:43,559 --> 00:11:45,000
Pues este vamos a abrirlo para escribir.

243
00:11:46,059 --> 00:11:46,820
Pues entonces

244
00:11:46,820 --> 00:11:48,679
nos abrimos

245
00:11:48,679 --> 00:11:51,259
este.

246
00:12:00,240 --> 00:12:01,659
Fichero destino.

247
00:12:06,580 --> 00:12:07,799
Y un try-cash

248
00:12:07,799 --> 00:12:09,700
dentro del cual metemos

249
00:12:09,700 --> 00:12:17,450
todo lo demás. Vale, ahora

250
00:12:17,450 --> 00:12:19,250
ya sí que hay que hacer un bucle que vaya recorriendo

251
00:12:19,250 --> 00:12:20,190
los ficheros a unir.

252
00:12:21,450 --> 00:12:23,029
Pues para cada fichero

253
00:12:23,029 --> 00:12:25,470
F dentro de

254
00:12:25,470 --> 00:12:32,740
ficheros a unir, ¿qué hay que hacer?

255
00:12:33,559 --> 00:12:37,840
lo abrimos como lectura, hacemos un bucle que lo lea hasta el final

256
00:12:37,840 --> 00:12:40,779
y cada carácter leído se envía aquí

257
00:12:40,779 --> 00:12:55,590
pues venga, lo abrimos como lectura, nos metemos en el bucle

258
00:12:55,590 --> 00:12:59,070
de lectura de toda la vida, para leer el fichero enterito

259
00:12:59,070 --> 00:13:05,580
while n, siendo n que

260
00:13:05,580 --> 00:13:10,879
pues siendo n el resultado de haber leído de este

261
00:13:10,879 --> 00:13:15,399
sea diferente de menos uno

262
00:13:15,399 --> 00:13:19,059
pues ¿qué tenemos que hacer mientras sea diferente de menos uno?

263
00:13:19,419 --> 00:13:20,360
escribirlo en el otro

264
00:13:20,360 --> 00:13:29,220
ya está, cuando este while ha terminado

265
00:13:29,220 --> 00:13:32,559
ya hemos leído ese fichero que lo cerramos

266
00:13:32,559 --> 00:13:44,100
entonces este for va fichero por fichero

267
00:13:44,100 --> 00:13:47,960
lo abre para leer, lo lee entero y lo manda al de destino

268
00:13:47,960 --> 00:13:50,419
y así todos uno tras otro

269
00:13:50,419 --> 00:13:52,759
cuando el bucle for ha terminado

270
00:13:52,759 --> 00:13:55,059
ya hemos escrito todos, con lo cual

271
00:13:55,059 --> 00:13:57,620
este último ya lo podemos cerrar

272
00:13:57,620 --> 00:14:00,850
cuando el bucle fuera terminado

273
00:14:00,850 --> 00:14:03,009
ya hemos leído todos los que había que unir

274
00:14:03,009 --> 00:14:04,750
los hemos mandado al de destino

275
00:14:04,750 --> 00:14:06,070
pues ya cerramos el de destino

276
00:14:06,070 --> 00:14:12,269
ya están todos unidos en el de destino

277
00:14:12,269 --> 00:14:17,529
lo único que nos falta ahora es

278
00:14:17,529 --> 00:14:18,990
este método

279
00:14:18,990 --> 00:14:21,210
que seleccione solamente

280
00:14:21,210 --> 00:14:23,210
los ficheros cuyo nombre responde al patrón

281
00:14:23,210 --> 00:14:25,230
correspondiente, ya está

282
00:14:25,230 --> 00:14:49,720
bueno, lo que hemos hecho está claro

283
00:14:49,720 --> 00:14:53,000
para poder probarlo vamos a

284
00:14:53,000 --> 00:14:54,899
completar validar, porque ahora

285
00:14:54,899 --> 00:14:56,980
si lo probamos no va a seleccionar ningún fichero

286
00:14:56,980 --> 00:14:58,960
porque todo sale en falso, así que

287
00:14:58,960 --> 00:15:01,179
vamos a hacer

288
00:15:01,179 --> 00:15:02,120
el método validar

289
00:15:02,120 --> 00:15:06,679
el método validar tiene que quedarse

290
00:15:06,679 --> 00:15:08,440
con el nombre del fichero y ver

291
00:15:08,440 --> 00:15:09,120
si valida

292
00:15:09,120 --> 00:15:12,200
string

293
00:15:12,200 --> 00:15:13,080
nombre

294
00:15:13,080 --> 00:15:16,820
igual a f.getName

295
00:15:16,820 --> 00:15:18,659
este es el nombre

296
00:15:18,659 --> 00:15:21,990
entonces hay que ver

297
00:15:21,990 --> 00:15:26,750
si la primera parte del fichero es igual

298
00:15:26,750 --> 00:15:30,669
a la raíz que me han dado, entonces la raíz que me han dado estaba

299
00:15:30,669 --> 00:15:34,009
a ver si no nos perdemos con validar

300
00:15:34,009 --> 00:15:36,830
se supone que estaba en este, que es texto raíz

301
00:15:36,830 --> 00:15:40,830
en texto raíz, aquí está

302
00:15:40,830 --> 00:15:48,740
pues entonces en validar

303
00:15:48,740 --> 00:15:53,370
string la raíz

304
00:15:53,370 --> 00:15:54,750
Está en

305
00:15:54,750 --> 00:15:57,690
Texto raíz

306
00:15:57,690 --> 00:15:59,450
Punto get

307
00:15:59,450 --> 00:16:03,419
Text

308
00:16:03,419 --> 00:16:06,840
Y texto raíz

309
00:16:06,840 --> 00:16:12,559
Ah, vale, sí

310
00:16:12,559 --> 00:16:14,299
No me lo coge

311
00:16:14,299 --> 00:16:16,480
Porque claro, no está declarada

312
00:16:16,480 --> 00:16:18,259
Como estática

313
00:16:18,259 --> 00:16:30,399
Vale, vamos a pasarle

314
00:16:30,399 --> 00:16:32,100
Al botón validar

315
00:16:32,100 --> 00:16:34,460
El fichero y el

316
00:16:34,460 --> 00:16:36,779
Y la raíz

317
00:16:36,779 --> 00:16:38,240
La vamos a pasar

318
00:16:38,240 --> 00:16:39,519
Así no la tenemos que coger aquí

319
00:16:39,519 --> 00:16:43,200
entonces la raíz se la vamos a pasar

320
00:16:43,200 --> 00:16:49,659
sí, pero porque

321
00:16:49,659 --> 00:16:51,580
lo tendrás de cara a otro sitio, lo habrás puesto

322
00:16:51,580 --> 00:16:52,879
como estática, pero yo no quiero

323
00:16:52,879 --> 00:16:55,700
o el método, porque el método

324
00:16:55,700 --> 00:16:57,600
lo has puesto, igual no lo has sacado

325
00:16:57,600 --> 00:16:59,480
de la clase, sino que lo has hecho en la clase interna

326
00:16:59,480 --> 00:17:00,639
depende de donde lo hayas colocado

327
00:17:00,639 --> 00:17:03,019
claro, pero es que yo lo he sacado fuera

328
00:17:03,019 --> 00:17:04,779
pero bueno

329
00:17:04,779 --> 00:17:07,359
déjalo como lo tienes si quieres, entonces

330
00:17:07,359 --> 00:17:09,079
mi validar

331
00:17:09,079 --> 00:17:10,519
que está aquí

332
00:17:10,519 --> 00:17:13,519
a mi validar le voy a pasar

333
00:17:13,519 --> 00:17:16,220
la raíz, que es texto

334
00:17:16,220 --> 00:17:18,440
raíz punto

335
00:17:18,440 --> 00:17:20,220
de text

336
00:17:20,220 --> 00:17:21,359
vale

337
00:17:21,359 --> 00:17:26,660
a validar le paso

338
00:17:26,660 --> 00:17:28,480
el fichero y la raíz

339
00:17:28,480 --> 00:17:30,019
común para que se ponga a validar

340
00:17:30,019 --> 00:17:30,680
pues venga

341
00:17:30,680 --> 00:17:33,519
ahora ya me voy otra vez aquí

342
00:17:33,519 --> 00:17:39,180
vale, pues entonces tenemos que ver

343
00:17:39,180 --> 00:17:47,269
aquí donde

344
00:17:47,269 --> 00:17:47,670
ahí

345
00:17:47,670 --> 00:17:51,130
al método validar lo he cambiado para que reciba

346
00:17:51,130 --> 00:17:53,789
dos parámetros, el fichero del cual tiene que validar nombre

347
00:17:53,789 --> 00:17:57,329
y la raíz que tiene que comprobar

348
00:17:57,329 --> 00:18:00,470
que está en el nombre y eso está en el text field

349
00:18:00,470 --> 00:18:02,269
del área de texto, por eso lo he puesto ahí

350
00:18:02,269 --> 00:18:07,930
vale, pues nos vamos aquí abajo

351
00:18:07,930 --> 00:18:10,410
y ahora ya

352
00:18:10,410 --> 00:18:13,869
ahora ya esto lo podemos validar, pues bueno, vamos a ver

353
00:18:13,869 --> 00:18:17,109
por ejemplo, el nombre

354
00:18:17,109 --> 00:18:20,210
es un string y la clase string tiene un montón

355
00:18:20,210 --> 00:18:22,789
de métodos útiles que hemos mirado en su momento

356
00:18:22,789 --> 00:18:24,769
por ejemplo, tiene el método

357
00:18:24,769 --> 00:18:25,630
substring

358
00:18:25,630 --> 00:18:30,230
o incluso

359
00:18:30,230 --> 00:18:31,950
este nos es más útil, el startsWith

360
00:18:31,950 --> 00:18:34,450
este solo por el nombre nos viene muy bien

361
00:18:34,450 --> 00:18:36,150
que es, si empieza

362
00:18:36,150 --> 00:18:38,390
con, entonces este

363
00:18:38,390 --> 00:18:40,690
te dice

364
00:18:40,690 --> 00:18:41,869
si el string

365
00:18:41,869 --> 00:18:44,289
este empieza con lo que tú le des

366
00:18:44,289 --> 00:18:46,309
vale, pues entonces

367
00:18:46,309 --> 00:18:51,569
si empieza con

368
00:18:51,569 --> 00:18:52,950
raíz

369
00:18:52,950 --> 00:18:55,170
esta ya

370
00:18:55,170 --> 00:18:56,910
tiene la primera validación hecha

371
00:18:56,910 --> 00:19:01,039
¿verdad? por ejemplo

372
00:19:01,039 --> 00:19:07,460
validación una

373
00:19:07,460 --> 00:19:09,779
que empiece

374
00:19:09,779 --> 00:19:11,599
con el texto de la raíz

375
00:19:11,599 --> 00:19:13,420
entonces

376
00:19:13,420 --> 00:19:15,619
igual que tiene un startsWith es probable que tenga

377
00:19:15,619 --> 00:19:17,539
un end, porque si tuviera

378
00:19:17,539 --> 00:19:19,339
un método endsWith

379
00:19:19,339 --> 00:19:20,339
pues estupendo

380
00:19:20,339 --> 00:19:23,420
termina con .ptr

381
00:19:23,420 --> 00:19:29,569
pues si termina con .ptr

382
00:19:29,569 --> 00:19:31,269
ya tenemos la otra validación

383
00:19:31,269 --> 00:19:37,839
vale

384
00:19:37,839 --> 00:19:41,119
si las dos

385
00:19:41,119 --> 00:19:41,900
son válidas

386
00:19:41,900 --> 00:19:44,359
está empezando con la raíz que está ahí

387
00:19:44,359 --> 00:19:46,359
y además está terminando con PTR

388
00:19:46,359 --> 00:19:48,059
entonces

389
00:19:48,059 --> 00:19:50,279
ahora la otra validación es más rara

390
00:19:50,279 --> 00:19:52,259
porque hay que ver que entre la raíz

391
00:19:52,259 --> 00:19:54,380
y PTR todo lo que hay son cifras

392
00:19:54,380 --> 00:19:56,160
decimales, numeritos

393
00:19:56,160 --> 00:19:57,759
todo lo que hay son cifras decimales

394
00:19:57,759 --> 00:19:58,779
entonces aquí

395
00:19:58,779 --> 00:20:01,640
nos tendríamos que quedar

396
00:20:01,640 --> 00:20:03,960
con la subcadena

397
00:20:03,960 --> 00:20:06,299
comprendida entre raíz y PTR

398
00:20:06,299 --> 00:20:08,240
ir carácter por carácter

399
00:20:08,240 --> 00:20:10,160
viendo si esos caracteres están todos comprendidos

400
00:20:10,160 --> 00:20:11,859
en la tabla ASCII entre el 0 y el 9

401
00:20:11,859 --> 00:20:14,740
vale, venga, vamos a ver, es un poco retorcido

402
00:20:14,740 --> 00:20:16,079
yo creo que Estefano tenía en mente

403
00:20:16,079 --> 00:20:18,819
validar números de diferentes

404
00:20:18,819 --> 00:20:20,700
cifras, solo de una, pero vamos a hacerlo

405
00:20:20,700 --> 00:20:22,880
vale, pues ahora ya sí que nos podemos

406
00:20:22,880 --> 00:20:23,960
quedar con

407
00:20:23,960 --> 00:20:26,299
hay un método

408
00:20:26,299 --> 00:20:28,240
substring para extraer subcadenas

409
00:20:28,240 --> 00:20:30,640
si uno cotilla aquí los

410
00:20:30,640 --> 00:20:32,339
métodos, pues tenemos

411
00:20:32,339 --> 00:20:33,619
el método substring

412
00:20:33,619 --> 00:20:36,140
que le dices

413
00:20:36,140 --> 00:20:38,920
una posición inicial

414
00:20:38,920 --> 00:20:40,640
y una posición final

415
00:20:40,640 --> 00:20:43,079
y te da la subcadena comprendida en esas posiciones

416
00:20:43,079 --> 00:20:44,700
entonces

417
00:20:44,700 --> 00:20:46,619
aquí lo único que hay que fijar

418
00:20:46,619 --> 00:20:48,059
la posición que hay que darle

419
00:20:48,059 --> 00:20:50,759
porque

420
00:20:50,759 --> 00:20:53,019
de substring empieza

421
00:20:53,019 --> 00:20:54,140
a donde le digamos

422
00:20:54,140 --> 00:20:55,619
begin index

423
00:20:55,619 --> 00:20:59,000
entonces hay que darle el tamaño de raíz

424
00:20:59,000 --> 00:21:01,019
y termina

425
00:21:01,019 --> 00:21:02,400
hasta end index

426
00:21:02,400 --> 00:21:03,259
menos uno

427
00:21:03,259 --> 00:21:06,819
que será la longitud de la cadena

428
00:21:06,819 --> 00:21:09,160
menos los cuatro caracteres

429
00:21:09,160 --> 00:21:09,720
de ptr

430
00:21:09,720 --> 00:21:11,819
O sea, yo creo

431
00:21:11,819 --> 00:21:13,539
Así a voz de pronto

432
00:21:13,539 --> 00:21:14,759
Pero bueno, habría que probarlo

433
00:21:14,759 --> 00:21:17,259
Esto sería

434
00:21:17,259 --> 00:21:21,519
Raíz punto length

435
00:21:21,519 --> 00:21:23,900
Y luego sería

436
00:21:23,900 --> 00:21:28,809
Nombre punto length

437
00:21:28,809 --> 00:21:30,289
Menos 4

438
00:21:30,289 --> 00:21:31,970
Quitándole las posiciones

439
00:21:31,970 --> 00:21:33,450
De punto ptr que son 4

440
00:21:33,450 --> 00:21:39,309
Pero vamos a hacer la prueba

441
00:21:39,309 --> 00:21:42,940
Que no la vas a hacer

442
00:21:42,940 --> 00:21:45,500
No la vas a hacer por hacer cosas raras, ¿verdad?

443
00:21:45,500 --> 00:21:51,690
y ahora

444
00:21:51,690 --> 00:22:06,500
vamos ahora simplemente

445
00:22:06,500 --> 00:22:07,220
que muestre

446
00:22:07,220 --> 00:22:10,079
la subcadena

447
00:22:10,079 --> 00:22:20,200
y ahora vamos

448
00:22:20,200 --> 00:22:21,819
a rápidamente

449
00:22:21,819 --> 00:22:24,339
hacer un

450
00:22:24,339 --> 00:22:25,940
main de prueba, muy rápido

451
00:22:25,940 --> 00:22:42,200
prueba, vale

452
00:22:42,200 --> 00:22:44,279
entonces voy a copiar

453
00:22:44,279 --> 00:22:46,160
este de validar aquí para hacer

454
00:22:46,160 --> 00:23:04,319
así la prueba. Y ahora voy a llamar a este método de validar, pasándole un objeto file

455
00:23:04,319 --> 00:23:24,299
con un nombrecito datos98.ptr y pasándole como raíz datos. Y ahora vamos a ver si este

456
00:23:24,299 --> 00:23:26,319
System.out me muestra 98

457
00:23:26,319 --> 00:23:28,220
Porque si no me muestra

458
00:23:28,220 --> 00:23:30,039
98, tengo que mover

459
00:23:30,039 --> 00:23:32,480
Hacia más 1

460
00:23:32,480 --> 00:23:33,779
O menos 1, alguno de estos

461
00:23:33,779 --> 00:23:36,359
Vamos simplemente a ejecutar este

462
00:23:36,359 --> 00:23:38,319
Main, a ver, que me muestra

463
00:23:38,319 --> 00:23:44,339
98, bueno, le hemos clavado

464
00:23:44,339 --> 00:23:46,079
A la primera, vale

465
00:23:46,079 --> 00:23:50,339
Vale, el substring, entonces

466
00:23:50,339 --> 00:23:52,079
Empieza aquí y acaba aquí

467
00:23:52,079 --> 00:23:54,500
Entonces, si le paso 986

468
00:23:54,500 --> 00:23:55,900
A ver

469
00:23:55,900 --> 00:23:58,640
clavado, bueno, bueno

470
00:23:58,640 --> 00:24:00,480
somos muy listos, venga

471
00:24:00,480 --> 00:24:02,400
ya está, pues entonces

472
00:24:02,400 --> 00:24:03,380
nos vamos aquí

473
00:24:03,380 --> 00:24:06,559
ahora ya efectivamente esta es

474
00:24:06,559 --> 00:24:08,519
la subcadena que tiene lo que está entre la

475
00:24:08,519 --> 00:24:10,460
raíz y el ptr, pues vamos a ver

476
00:24:10,460 --> 00:24:12,099
si todas las cifras que tiene son

477
00:24:12,099 --> 00:24:13,900
caracteres decimales

478
00:24:13,900 --> 00:24:15,819
pues ahora ya

479
00:24:15,819 --> 00:24:19,150
boolean

480
00:24:19,150 --> 00:24:21,329
valid 3

481
00:24:21,329 --> 00:24:24,150
igual a true

482
00:24:24,150 --> 00:24:26,470
lo más complicado es la validación

483
00:24:26,470 --> 00:24:28,730
Esto es una locura que no podríamos

484
00:24:28,730 --> 00:24:29,369
En un examen

485
00:24:29,369 --> 00:24:32,230
Y ahora ya sí que vamos a recorrer

486
00:24:32,230 --> 00:24:35,369
Para cada int

487
00:24:35,369 --> 00:24:36,670
Y igual a cero

488
00:24:36,670 --> 00:24:38,269
Mientras y sea menor que

489
00:24:38,269 --> 00:24:42,650
Subcadena.length

490
00:24:42,650 --> 00:24:44,789
Incrementando

491
00:24:44,789 --> 00:24:45,230
Y

492
00:24:45,230 --> 00:24:59,380
3

493
00:24:59,380 --> 00:25:00,579
Igual a

494
00:25:00,579 --> 00:25:02,220
Valir 3

495
00:25:02,220 --> 00:25:03,359
And

496
00:25:03,359 --> 00:25:16,529
Subcadena.length

497
00:25:16,630 --> 00:25:18,990
char add i

498
00:25:18,990 --> 00:25:21,650
para ver si esto es

499
00:25:21,650 --> 00:25:23,710
dígito, vamos a ver la tabla

500
00:25:23,710 --> 00:25:24,309
ASCII

501
00:25:24,309 --> 00:25:27,829
ahora cuando esté todo escrito lo vais a

502
00:25:27,829 --> 00:25:28,190
entender

503
00:25:28,190 --> 00:25:30,230
bien

504
00:25:30,230 --> 00:25:33,670
en la tabla ASCII

505
00:25:33,670 --> 00:25:35,589
ASCII

506
00:25:35,589 --> 00:25:43,769
vale, los números están

507
00:25:43,769 --> 00:25:45,329
entre el

508
00:25:45,329 --> 00:25:47,650
48 y el

509
00:25:47,650 --> 00:25:48,930
57, luego

510
00:25:48,930 --> 00:25:50,730
48 y 57

511
00:25:50,730 --> 00:25:53,049
luego esto entonces

512
00:25:53,049 --> 00:25:54,730
char add i

513
00:25:54,730 --> 00:25:57,630
mayor o igual que 48

514
00:25:57,630 --> 00:26:00,109
y

515
00:26:00,109 --> 00:26:02,990
subcadena

516
00:26:02,990 --> 00:26:05,190
punto

517
00:26:05,190 --> 00:26:07,849
char add i

518
00:26:07,849 --> 00:26:09,849
53 hemos dicho

519
00:26:09,849 --> 00:26:12,190
57

520
00:26:12,190 --> 00:26:15,470
menor o igual que 57

521
00:26:15,470 --> 00:26:22,319
pues esta es la validación 3

522
00:26:22,319 --> 00:26:23,880
que es liosa de entender

523
00:26:23,880 --> 00:26:26,339
porque vamos, sobre un true inicial

524
00:26:26,339 --> 00:26:28,140
vamos concatenando los and

525
00:26:28,140 --> 00:26:30,119
de que cada char

526
00:26:30,119 --> 00:26:32,619
sea un dígito

527
00:26:32,619 --> 00:26:34,259
¿veis? los vamos

528
00:26:34,259 --> 00:26:36,220
haciendo una concatenación acumulativa

529
00:26:36,220 --> 00:26:37,960
de ands, entonces cuando

530
00:26:37,960 --> 00:26:39,319
alguno ya no sea dígito

531
00:26:39,319 --> 00:26:42,420
este and ya me va a dar

532
00:26:42,420 --> 00:26:44,200
falso, pero si todos fueran

533
00:26:44,200 --> 00:26:45,839
dígitos, todos fueran dígitos

534
00:26:45,839 --> 00:26:47,480
yo a este valid3 inicial true

535
00:26:47,480 --> 00:26:49,440
le estoy concatenando todo el tanto and true

536
00:26:49,440 --> 00:26:51,619
entonces al final sería true

537
00:26:51,619 --> 00:26:54,339
en cuanto uno de estos no sea dígito

538
00:26:54,339 --> 00:26:56,180
este and

539
00:26:56,180 --> 00:26:58,339
concatenado, acumulado, ya va a dar

540
00:26:58,339 --> 00:27:00,220
falso, entonces cuando este for

541
00:27:00,220 --> 00:27:02,019
ha terminado, que este for termina aquí

542
00:27:02,019 --> 00:27:04,079
tengo dos opciones, que valid 3

543
00:27:04,079 --> 00:27:06,140
siga siendo true, porque todo lo que he concatenado

544
00:27:06,140 --> 00:27:07,519
sobre él es true, true, true, true

545
00:27:07,519 --> 00:27:10,200
o que sea falso, porque alguno de los que he concatenado

546
00:27:10,200 --> 00:27:11,900
no fue dígito, entonces

547
00:27:11,900 --> 00:27:14,079
esta ya es la validación 3, luego si pasa

548
00:27:14,079 --> 00:27:15,680
la 1, que es que empiece con raíz

549
00:27:15,680 --> 00:27:17,799
pasa la 2, que acabe con ptr

550
00:27:17,799 --> 00:27:19,980
y pasa la 3, que es que todo lo que

551
00:27:19,980 --> 00:27:21,700
esté entre raíz y ptr sean dígitos

552
00:27:21,700 --> 00:27:23,619
pues entonces ha pasado la total

553
00:27:23,619 --> 00:27:25,779
pues entonces ahora ya le tenemos que devolver

554
00:27:25,779 --> 00:27:27,940
return valid1

555
00:27:27,940 --> 00:27:30,000
and

556
00:27:30,000 --> 00:27:31,000
uy

557
00:27:31,000 --> 00:27:37,519
valid2 and

558
00:27:37,519 --> 00:27:40,160
valid3

559
00:27:40,160 --> 00:27:41,480
este es el método

560
00:27:41,480 --> 00:27:45,619
validar, vale pues

561
00:27:45,619 --> 00:27:47,380
esto es programar en realidad

562
00:27:47,380 --> 00:27:53,170
esto, hacer estas cositas

563
00:27:53,170 --> 00:27:59,910
bueno pues ya

564
00:27:59,910 --> 00:28:01,869
aparentemente tenemos este método de validar

565
00:28:01,869 --> 00:28:02,690
correcto

566
00:28:02,690 --> 00:28:05,329
si el fichero

567
00:28:05,329 --> 00:28:08,089
ahora ya nos podemos ir a nuestro

568
00:28:08,089 --> 00:28:09,150
evento otra vez

569
00:28:09,150 --> 00:28:13,700
que era listamos todos los

570
00:28:13,700 --> 00:28:14,500
ficheros

571
00:28:14,500 --> 00:28:17,460
si son ficheros y validan

572
00:28:17,460 --> 00:28:19,799
los añadimos a la estructura

573
00:28:19,799 --> 00:28:21,980
y ahora ya recorremos la estructura

574
00:28:21,980 --> 00:28:23,599
para irlos leyendo y escribiendo

575
00:28:23,599 --> 00:28:25,880
vamos a probarlo

576
00:28:25,880 --> 00:28:27,859
así de buenas a primeras es un poco

577
00:28:27,859 --> 00:28:29,720
complicado, ahora yo voy a intentar unir

578
00:28:29,720 --> 00:28:31,160
todos esos que hice

579
00:28:31,160 --> 00:28:33,200
Que empezaban con datos

580
00:28:33,200 --> 00:28:34,559
Que empezaban con datos

581
00:28:34,559 --> 00:28:38,200
Pues voy a intentar unir todos estos

582
00:28:38,200 --> 00:28:39,920
A ver si hay suerte

583
00:28:39,920 --> 00:28:41,319
Y no salen errores

584
00:28:41,319 --> 00:28:43,200
Pero bueno, es raro

585
00:28:43,200 --> 00:28:47,299
Que no la hayamos liado en alguna cosa

586
00:28:47,299 --> 00:28:50,519
Venga

587
00:28:50,519 --> 00:28:52,900
Merge, raíz de los ficheros a unir

588
00:28:52,900 --> 00:28:55,480
Datos, ¿no? Se llamaban los míos

589
00:28:55,480 --> 00:28:56,740
Creo, con minúscula

590
00:28:56,740 --> 00:28:57,940
Sí, datos

591
00:28:57,940 --> 00:29:05,960
Datos

592
00:29:05,960 --> 00:29:06,779
Y este

593
00:29:06,779 --> 00:29:12,420
¿Qué te está pasando?

594
00:29:16,980 --> 00:29:17,619
A ver

595
00:29:17,619 --> 00:29:20,779
A ver, vamos a probar esto

596
00:29:20,779 --> 00:29:22,220
Y si eso, me subes tú este

597
00:29:22,220 --> 00:29:23,420
Y lo miro aquí

598
00:29:23,420 --> 00:29:25,980
Venga, datos, los que empiezan por datos

599
00:29:25,980 --> 00:29:28,200
Merge

600
00:29:28,200 --> 00:29:30,480
Nombre de fichero destino

601
00:29:30,480 --> 00:29:32,579
Pues todos

602
00:29:32,579 --> 00:29:33,900
Se va a llamar todos

603
00:29:33,900 --> 00:29:35,960
Y ahora al darle a aceptar

604
00:29:35,960 --> 00:29:37,960
a saber que sale aquí, que pasa aquí

605
00:29:37,960 --> 00:29:40,140
esto ya era mucho

606
00:29:40,140 --> 00:29:41,859
que a la primera no salir era mucho pedir

607
00:29:41,859 --> 00:29:43,579
entonces

608
00:29:43,579 --> 00:29:48,220
nos hemos pasado

609
00:29:48,220 --> 00:29:50,119
datos 5, 4

610
00:29:50,119 --> 00:29:51,700
para length 8

611
00:29:51,700 --> 00:29:54,039
a ver en algún

612
00:29:54,039 --> 00:29:55,940
momento cuando he hecho un substring o algo

613
00:29:55,940 --> 00:29:56,599
de eso

614
00:29:56,599 --> 00:29:59,140
me he pasado

615
00:29:59,140 --> 00:30:01,940
aquí, vamos a ver

616
00:30:01,940 --> 00:30:05,779
vale, hacer la subcadena

617
00:30:05,779 --> 00:30:06,640
pero

618
00:30:06,640 --> 00:30:09,440
datos

619
00:30:09,440 --> 00:30:13,619
si es fichero

620
00:30:13,619 --> 00:30:15,619
ah claro, a ver, es que esta validación

621
00:30:15,619 --> 00:30:17,799
de aquí, solo tiene sentido

622
00:30:17,799 --> 00:30:19,660
que la haga si ha pasado las anteriores

623
00:30:19,660 --> 00:30:21,319
porque si no ha pasado las anteriores

624
00:30:21,319 --> 00:30:23,420
el fichero a lo mejor se llama O

625
00:30:23,420 --> 00:30:25,259
entonces si se llama O, no puedo hacer yo

626
00:30:25,259 --> 00:30:27,259
hacer un substring con 4

627
00:30:27,259 --> 00:30:29,640
con ptr, entonces esta validación 3

628
00:30:29,640 --> 00:30:31,259
solo tiene sentido hacerla

629
00:30:31,259 --> 00:30:32,720
si ya ha pasado la 1 y la 2

630
00:30:32,720 --> 00:30:34,859
si no tiene sentido hacerla

631
00:30:34,859 --> 00:30:36,039
vale, entonces

632
00:30:36,039 --> 00:30:38,880
si

633
00:30:38,880 --> 00:30:43,400
Si no valida

634
00:30:43,400 --> 00:30:45,660
Si no valida la primera

635
00:30:45,660 --> 00:30:46,220
O

636
00:30:46,220 --> 00:30:49,859
No valida la segunda

637
00:30:49,859 --> 00:30:52,319
Ya está, retum falso

638
00:30:52,319 --> 00:30:55,109
Y se acabó

639
00:30:55,109 --> 00:30:57,710
Porque una de las dos

640
00:30:57,710 --> 00:30:59,769
No la ha validado, o la primera o la segunda

641
00:30:59,769 --> 00:31:02,049
Entonces si valida las dos

642
00:31:02,049 --> 00:31:03,089
Ahora ya ha sido

643
00:31:03,089 --> 00:31:05,529
Vale, pues venga

644
00:31:05,529 --> 00:31:14,519
Siguiente intento

645
00:31:14,519 --> 00:31:16,599
Venga, raíz de los ficheros a unir

646
00:31:16,599 --> 00:31:36,160
datos, merge, todos, aceptar, vamos a ver si me ha hecho un todos por ahí, aquí está

647
00:31:36,160 --> 00:31:49,490
mi todos, entonces vamos a ver qué tamaño tiene, que eso ya nos da una pista, 24.926,

648
00:31:49,490 --> 00:31:56,039
todos

649
00:31:56,039 --> 00:31:57,960
a ver

650
00:31:57,960 --> 00:32:00,559
ha unido estos

651
00:32:00,559 --> 00:32:03,299
a ver si yo pudiera

652
00:32:03,299 --> 00:32:05,319
voy a copiarlo y pegarlo

653
00:32:05,319 --> 00:32:07,359
y abrirlo con Word porque esos venían de partir

654
00:32:07,359 --> 00:32:08,839
un Word, entonces

655
00:32:08,839 --> 00:32:11,819
a ver

656
00:32:11,819 --> 00:32:28,380
donde lo tengo

657
00:32:28,380 --> 00:32:28,940
aquí

658
00:32:28,940 --> 00:32:32,680
cambiar nombre

659
00:32:32,680 --> 00:32:37,700
pero los bytes no me suena que estén bien

660
00:32:37,700 --> 00:32:38,680
entonces

661
00:32:38,680 --> 00:32:44,400
vale

662
00:32:44,400 --> 00:32:47,259
no parece el mismo

663
00:32:47,259 --> 00:32:48,740
fichero del que dividí

664
00:32:48,740 --> 00:32:50,000
entonces

665
00:32:50,000 --> 00:33:01,819
repito, ahora que ya hemos entendido la aplicación

666
00:33:01,819 --> 00:33:02,779
hemos visto como hacerla

667
00:33:02,779 --> 00:33:05,559
vamos simplemente a cambiar la clase

668
00:33:05,559 --> 00:33:07,920
file-reader-file-writer por file-input-stream

669
00:33:07,920 --> 00:33:09,579
file-output-stream para que se quede

670
00:33:09,579 --> 00:33:11,079
como la haríamos en original

671
00:33:11,079 --> 00:33:13,220
con esa clase básica que mueve el byte tal cual

672
00:33:13,220 --> 00:33:15,240
porque el fichero puede tener cualquier cosa

673
00:33:15,240 --> 00:33:17,259
no tengo por qué interpretar yo que sea un char

674
00:33:17,259 --> 00:33:18,940
entonces simplemente

675
00:33:18,940 --> 00:33:20,180
voy a cambiar aquí

676
00:33:20,180 --> 00:33:23,180
cada file reader

677
00:33:23,180 --> 00:33:30,779
y cada file writer

678
00:33:30,779 --> 00:33:32,619
claro

679
00:33:32,619 --> 00:33:34,539
lo voy a cambiar por la clase con la que lo haríamos

680
00:33:34,539 --> 00:33:36,619
pero repito que esto lo subo

681
00:33:36,619 --> 00:33:38,000
luego todo por si alguien

682
00:33:38,000 --> 00:33:40,559
file output stream

683
00:33:40,559 --> 00:33:42,339
queda como mejor

684
00:33:42,339 --> 00:33:44,339
no es que quede mejor es que esta

685
00:33:44,339 --> 00:33:46,480
esta clase te lee el byte directamente

686
00:33:46,480 --> 00:33:48,059
sin darle ninguna interpretación

687
00:33:48,059 --> 00:33:48,960
no es como file reader

688
00:33:48,960 --> 00:33:51,119
que asume que es un char

689
00:33:51,119 --> 00:33:52,779
entonces cuando tú haces el casting a char

690
00:33:52,779 --> 00:33:55,559
te muestra algo con sentido

691
00:33:55,559 --> 00:33:56,740
esta te coge el byte

692
00:33:56,740 --> 00:33:59,059
y te lo lleva a la variable

693
00:33:59,059 --> 00:34:00,799
esta de aquí tal cual

694
00:34:00,799 --> 00:34:01,720
pues

695
00:34:01,720 --> 00:34:05,140
en nuestro caso que estamos moviendo bytes

696
00:34:05,140 --> 00:34:07,019
sin ninguna interpretación es como lo haríamos

697
00:34:07,019 --> 00:34:09,260
vale pues entonces

698
00:34:09,260 --> 00:34:10,900
este

699
00:34:10,900 --> 00:34:13,019
se cambia

700
00:34:13,019 --> 00:34:14,320
por inputStream

701
00:34:14,320 --> 00:34:17,360
pues los métodos son iguales

702
00:34:17,360 --> 00:34:17,960
todo es igual

703
00:34:17,960 --> 00:34:25,110
file input string

704
00:34:25,110 --> 00:34:32,739
ala, file output string

705
00:34:32,739 --> 00:34:34,820
vale, esto ya lo tenemos

706
00:34:34,820 --> 00:34:37,840
y ahora

707
00:34:37,840 --> 00:34:39,940
este método de aquí

708
00:34:39,940 --> 00:34:45,530
pues aquí lo mismo

709
00:34:45,530 --> 00:34:48,170
en lugar de file

710
00:34:48,170 --> 00:34:48,690
readder

711
00:34:48,690 --> 00:34:51,090
file input string

712
00:34:51,090 --> 00:34:54,789
y en lugar de file writer

713
00:34:54,789 --> 00:34:57,909
file output string

714
00:34:57,909 --> 00:34:59,690
y todo lo demás

715
00:34:59,690 --> 00:35:00,289
igual

716
00:35:00,289 --> 00:35:17,230
vale

717
00:35:17,230 --> 00:35:19,889
y voy a probar ahora a dividir un word

718
00:35:19,889 --> 00:35:21,829
a ver si luego al reconstruirlo me sale el word

719
00:35:21,829 --> 00:35:22,670
entero otra vez

720
00:35:22,670 --> 00:35:28,139
venga vamos a dividir

721
00:35:28,139 --> 00:35:29,860
un word

722
00:35:29,860 --> 00:35:30,480
cualquiera

723
00:35:30,480 --> 00:35:42,099
este

724
00:35:42,099 --> 00:35:48,099
lo vamos a dividir en

725
00:35:48,099 --> 00:35:49,219
datos

726
00:35:49,219 --> 00:35:51,280
vale

727
00:35:51,280 --> 00:35:54,360
ahora vamos a ver

728
00:35:54,360 --> 00:35:59,320
aquí están todos los datos

729
00:35:59,320 --> 00:36:01,159
los 15 ficheros

730
00:36:01,159 --> 00:36:02,079
y ahora voy a unirlos

731
00:36:02,079 --> 00:36:03,659
a ver si el que me sale

732
00:36:03,659 --> 00:36:05,820
fuera un

733
00:36:05,820 --> 00:36:08,079
si Word lo interpretara, que debería

734
00:36:08,079 --> 00:36:09,599
porque lo hemos movido sin más

735
00:36:09,599 --> 00:36:11,219
vamos a ver

736
00:36:11,219 --> 00:36:14,380
ejecutamos esto otra vez

737
00:36:14,380 --> 00:36:16,000
y le decimos, vamos a hacer un

738
00:36:16,000 --> 00:36:17,880
merg de todos los que se llaman datos

739
00:36:17,880 --> 00:36:20,260
y donde lo vas

740
00:36:20,260 --> 00:36:24,039
a guardar, en resul.docx

741
00:36:24,039 --> 00:36:24,679
por ejemplo

742
00:36:24,679 --> 00:36:29,880
y ya está

743
00:36:29,880 --> 00:36:31,579
vale, entonces

744
00:36:31,579 --> 00:36:33,480
refresh

745
00:36:33,480 --> 00:36:37,949
vale

746
00:36:37,949 --> 00:36:40,309
result doc x está aquí

747
00:36:40,309 --> 00:36:43,400
este

748
00:36:43,400 --> 00:36:44,900
voy a sacarlo fuera

749
00:36:44,900 --> 00:36:54,619
copiar, pegar

750
00:36:54,619 --> 00:37:01,590
hay, mete algún carácter

751
00:37:01,590 --> 00:37:03,150
en algún momento que hace que luego

752
00:37:03,150 --> 00:37:05,590
algún carácter que hace que ya sea elegible

753
00:37:05,590 --> 00:37:07,789
para el Word, no sé muy bien

754
00:37:07,789 --> 00:37:08,329
que

755
00:37:08,329 --> 00:37:10,369
los permisos

756
00:37:10,369 --> 00:37:13,610
no, no, permisos no son algún carácter

757
00:37:13,610 --> 00:37:14,250
en algún momento

758
00:37:14,250 --> 00:37:18,699
pero no debería porque estamos

759
00:37:18,699 --> 00:37:19,440
cogiendo los

760
00:37:19,440 --> 00:37:23,199
estamos, es que los bytes tal cual

761
00:37:23,199 --> 00:37:25,820
los estamos poniendo en trocitos y luego pegándolos otra vez

762
00:37:25,820 --> 00:37:26,780
no debería perder

763
00:37:26,780 --> 00:37:28,699
no sé por qué no lo

764
00:37:28,699 --> 00:37:30,420
no lo sé, se podría

765
00:37:30,420 --> 00:37:33,599
indagar a ver por qué no reconstruye el Word igual

766
00:37:33,599 --> 00:37:34,960
pero a ver, lo que

767
00:37:34,960 --> 00:37:37,559
me importa ahora, bueno, es que hayáis

768
00:37:37,559 --> 00:37:39,599
entendido la aplicación

769
00:37:39,599 --> 00:38:50,489
a ver, un segundito

770
00:38:50,489 --> 00:38:56,550
esto, vamos aquí

771
00:38:56,550 --> 00:39:15,480
vale, pues aquí en el aula

772
00:39:15,480 --> 00:39:17,320
virtual aquí abajo está

773
00:39:17,320 --> 00:39:45,269
está todo lo que hemos hecho respecto a los enunciados anteriores que hay aquí arriba.