1
00:00:00,690 --> 00:00:16,100
venga pues nada vamos a hacer entonces la interfaz un nuevo frame os voy a que

2
00:00:17,579 --> 00:00:21,679
no lo sé ya lo sabrás el viernes vale

3
00:00:23,640 --> 00:00:35,100
que sí vale pues entonces ya tenemos el frame hemos dicho que dos pestañas un tablet pan y

4
00:00:35,100 --> 00:00:36,700
con dos pestañas, bueno, pues venga

5
00:00:36,700 --> 00:00:40,939
para hacer dos

6
00:00:40,939 --> 00:00:42,840
paneles con pestañas

7
00:00:42,840 --> 00:00:44,820
pues primero colocábamos

8
00:00:44,820 --> 00:00:46,600
el panel tabulado este

9
00:00:46,600 --> 00:00:48,799
bueno

10
00:00:48,799 --> 00:00:50,159
voy a poner el

11
00:00:50,159 --> 00:00:52,479
el absolute layout aquí

12
00:00:52,479 --> 00:00:55,079
ahí

13
00:00:55,079 --> 00:00:56,380
y ahora el panel

14
00:00:56,380 --> 00:00:58,140
este de aquí

15
00:00:58,140 --> 00:01:05,400
vale

16
00:01:05,400 --> 00:01:08,379
y ahora vamos a poner ya

17
00:01:08,379 --> 00:01:09,280
un panel

18
00:01:09,280 --> 00:01:14,230
ahí, con una pestañita

19
00:01:14,230 --> 00:01:35,799
Y esta pestañita va a ser la pestañita de split.

20
00:01:39,670 --> 00:01:42,450
Este va a ser panel split.

21
00:01:44,890 --> 00:02:00,090
Y ahora vamos a hacernos un panel que es el panel de merge.

22
00:02:00,510 --> 00:02:17,250
Y este, vale.

23
00:02:17,250 --> 00:02:19,330
Pues empezamos con el panel de Split.

24
00:02:19,409 --> 00:02:20,129
¿Qué tiene que tener?

25
00:02:20,569 --> 00:02:23,629
Tiene que tener un control para introducir el nombre del

26
00:02:23,629 --> 00:02:24,349
fichero, ¿verdad?

27
00:02:25,590 --> 00:02:28,389
Se selecciona un fichero, al ser posible, con un file chooser.

28
00:02:28,509 --> 00:02:30,310
Vale, pues un botoncito, seleccionar fichero.

29
00:02:31,729 --> 00:02:38,969
Y una vez seleccionado, se hace clic en un botón Split y te

30
00:02:38,969 --> 00:02:43,530
dice, vale, ¿cuál va a ser el nombre del usuario,

31
00:02:43,610 --> 00:02:44,569
el nombre del fichero?

32
00:02:44,629 --> 00:02:46,210
Por ejemplo, data, esto no lo entiendo.

33
00:02:47,430 --> 00:02:48,689
Ah, sí, los nombres de los ficheros.

34
00:02:49,330 --> 00:02:52,150
¿Data 1, data 2 y de nombre datos?

35
00:02:52,310 --> 00:02:54,289
Vale, si datos 1, datos 2 es que vale.

36
00:02:54,830 --> 00:03:01,909
Vale, pues data es la raíz común que tendrán los nombres de los ficheros en los que se va a dividir.

37
00:03:02,009 --> 00:03:05,110
Entonces, si ponemos data, serán data 1, data 2, data 3, data 4.

38
00:03:05,530 --> 00:03:05,729
¿Vale?

39
00:03:06,129 --> 00:03:08,389
Cada uno con 1024 bits más el restante.

40
00:03:09,729 --> 00:03:11,229
Venga, pues entonces.

41
00:03:14,710 --> 00:03:17,270
Necesitamos, por tanto, un botón para que salga el file chooser.

42
00:03:17,270 --> 00:03:19,229
un botón de split

43
00:03:19,229 --> 00:03:21,849
y cuando le damos al botón de split

44
00:03:21,849 --> 00:03:23,389
va a aparecer un jOptionPane

45
00:03:23,389 --> 00:03:24,710
para pedirte el nombre del fichero

46
00:03:24,710 --> 00:03:26,909
y luego ya

47
00:03:26,909 --> 00:03:29,289
cuando le demos a aceptar a ese

48
00:03:29,289 --> 00:03:31,289
jOptionPane pues ya se hace la división

49
00:03:31,289 --> 00:03:33,389
y se acabó, entonces no hacen falta más

50
00:03:33,389 --> 00:03:35,469
controles que esos, pues venga

51
00:03:35,469 --> 00:03:37,669
vamos a poner un botoncito

52
00:03:37,669 --> 00:03:38,849
para seleccionar el fichero

53
00:03:38,849 --> 00:03:46,199
voy a ponerle al

54
00:03:46,199 --> 00:03:47,979
panel este de aquí

55
00:03:47,979 --> 00:03:49,500
panel split

56
00:03:49,500 --> 00:04:08,159
el absolute layer

57
00:04:08,159 --> 00:04:10,199
estaba buscando el gestor de ubicación del panel

58
00:04:10,199 --> 00:04:12,199
vale, en este panel absolute layer

59
00:04:12,199 --> 00:04:13,620
para poner el botón donde queramos

60
00:04:13,620 --> 00:04:16,740
ahora ya sí, un botón que sea

61
00:04:16,740 --> 00:04:20,240
elegir fichero

62
00:04:20,240 --> 00:04:24,959
botón

63
00:04:24,959 --> 00:04:27,540
elegir fichero

64
00:04:27,540 --> 00:04:29,100
vale, y el botón

65
00:04:29,100 --> 00:04:31,120
elegir fichero va a tener un texto arriba

66
00:04:31,120 --> 00:04:35,810
selecciona

67
00:04:35,810 --> 00:04:40,879
fichero, vale

68
00:04:40,879 --> 00:04:42,879
este es nuestro botoncito que abriría

69
00:04:42,879 --> 00:04:43,519
el file chooser

70
00:04:43,519 --> 00:04:46,540
bueno, luego vamos a ponerle otro botón

71
00:04:46,540 --> 00:04:48,980
que es para darle ya la orden de hacer el split

72
00:04:48,980 --> 00:04:51,040
pues ese botón aquí debajo

73
00:04:51,040 --> 00:04:53,639
lo llamamos

74
00:04:53,639 --> 00:04:55,139
botón split, por ejemplo

75
00:04:55,139 --> 00:04:56,259
como nos dé la gana

76
00:04:56,259 --> 00:05:00,750
y le ponemos el texto

77
00:05:00,750 --> 00:05:02,110
split

78
00:05:02,110 --> 00:05:12,290
y ya está, porque cuando le damos a split se hace la división

79
00:05:12,290 --> 00:05:13,930
y se acabó, entonces ya no hay más controles

80
00:05:13,930 --> 00:05:15,689
aquí, venga, pues

81
00:05:15,689 --> 00:05:17,829
evento del primer botón, el más fácil, abrir el file

82
00:05:17,829 --> 00:05:19,610
chooser para seleccionar un nombre de fichero

83
00:05:19,610 --> 00:05:21,769
luego ya el más complicado es el otro, el que tiene

84
00:05:21,769 --> 00:05:23,810
toda la división, claro, pues venga

85
00:05:23,810 --> 00:05:25,350
vámonos al evento de este botoncito

86
00:05:25,350 --> 00:05:30,660
este botoncito va a

87
00:05:30,660 --> 00:05:31,860
seleccionar el fichero

88
00:05:31,860 --> 00:05:34,279
para seleccionar el

89
00:05:34,279 --> 00:05:36,420
nos va a permitir seleccionar el fichero

90
00:05:36,420 --> 00:05:38,959
para eso ya nos lo sabemos de memoria

91
00:05:38,959 --> 00:05:45,110
instanciamos este objeto

92
00:05:45,110 --> 00:05:51,329
y luego abrimos la ventana de

93
00:05:51,329 --> 00:05:59,329
diálogo, vale

94
00:05:59,329 --> 00:06:01,350
vamos a abrir la ventana de diálogo que sabemos

95
00:06:01,350 --> 00:06:02,389
que nos devuelve

96
00:06:02,389 --> 00:06:05,069
un entero con

97
00:06:05,069 --> 00:06:07,269
la respuesta que ha dado

98
00:06:07,269 --> 00:06:09,110
el usuario, si ha dado

99
00:06:09,110 --> 00:06:11,449
save, open, cancel, lo que sea

100
00:06:11,449 --> 00:06:14,970
y ahora ya hacemos aquí

101
00:06:14,970 --> 00:06:17,269
show open

102
00:06:17,269 --> 00:06:17,850
diálogo

103
00:06:17,850 --> 00:06:25,279
y ahora ya

104
00:06:25,279 --> 00:06:27,420
si no le han dado a cancel

105
00:06:27,420 --> 00:06:28,980
porque podrían haberle dado a cancel

106
00:06:28,980 --> 00:06:31,180
porque se han equivocado, si no le han

107
00:06:31,180 --> 00:06:34,980
dado a cancel o lo que es lo mismo. Si la opción

108
00:06:34,980 --> 00:06:39,079
que ha devuelto la ventanita cuando es la opción de

109
00:06:39,079 --> 00:06:45,269
aprobar, entonces

110
00:06:45,269 --> 00:06:48,990
ya vamos a quedarnos con el

111
00:06:48,990 --> 00:06:53,110
fichero que esté seleccionado. Entonces, de nuevo, eso que nos devuelve

112
00:06:53,110 --> 00:06:56,889
el file chooser es un objeto file que tiene que estar accesible

113
00:06:56,889 --> 00:07:00,949
para el resto de la aplicación, en concreto para el botón de split. Pues ese es un dato de la

114
00:07:00,949 --> 00:07:03,310
aplicación. Pues ese dato de la aplicación

115
00:07:03,310 --> 00:07:04,490
para que esté accesible

116
00:07:04,490 --> 00:07:06,769
para el resto de métodos y clases

117
00:07:06,769 --> 00:07:08,850
internas, lo declaramos

118
00:07:08,850 --> 00:07:09,370
aquí fuera.

119
00:07:11,980 --> 00:07:13,720
Pues este es el fichero a dividir.

120
00:07:17,149 --> 00:07:18,769
El fichero que vamos a dividir es

121
00:07:18,769 --> 00:07:19,009
este.

122
00:07:23,329 --> 00:07:25,129
Bueno, pues el fichero que vamos a dividir

123
00:07:25,129 --> 00:07:26,730
es este y le damos ya

124
00:07:26,730 --> 00:07:28,790
valor en este momento.

125
00:07:37,050 --> 00:07:37,810
Ahí ya tiene valor.

126
00:07:40,670 --> 00:07:42,149
Ay, perdón, no lo he puesto aquí.

127
00:07:42,930 --> 00:07:43,410
Fichero

128
00:07:43,410 --> 00:07:45,069
dividir

129
00:07:45,069 --> 00:07:49,170
ahí, vale, pues ya tenemos

130
00:07:49,170 --> 00:07:51,129
el file, ese botón era solamente para el file

131
00:07:51,129 --> 00:07:51,610
dime

132
00:07:51,610 --> 00:07:54,529
eh, sí

133
00:07:54,529 --> 00:07:56,990
sí, sí, vale

134
00:07:56,990 --> 00:07:58,410
ahora ya, pues

135
00:07:58,410 --> 00:08:00,910
podemos poner el

136
00:08:00,910 --> 00:08:03,110
fichero que se ha seleccionado, a lo mejor en el propio

137
00:08:03,110 --> 00:08:04,889
botón o en algún sitio para que se vea

138
00:08:04,889 --> 00:08:06,029
cuál es el que hemos seleccionado

139
00:08:06,029 --> 00:08:10,329
bueno, vamos a hacerlo en una

140
00:08:10,329 --> 00:08:11,790
etiqueta

141
00:08:11,790 --> 00:08:14,930
para no estropear tampoco el botón

142
00:08:14,930 --> 00:08:18,990
entonces vamos a ponernos una etiqueta cualquiera

143
00:08:18,990 --> 00:08:21,889
por aquí

144
00:08:21,889 --> 00:08:27,189
da igual, lo que queramos, con lo que importa es que esté informativo

145
00:08:27,189 --> 00:08:36,159
vale, y esta etiqueta que inicialmente

146
00:08:36,159 --> 00:08:47,179
no tiene texto, en esta etiqueta que se llama nombre fichero

147
00:08:47,179 --> 00:08:48,519
aprovechamos y lo ponemos

148
00:08:48,519 --> 00:08:52,159
ponemos aquí, bueno, vamos a sacarla

149
00:08:52,159 --> 00:08:56,879
a clase, porque si no, no va a ser accesible

150
00:08:56,879 --> 00:09:00,759
desde la clase interna, ya la hemos sacado

151
00:09:00,759 --> 00:09:04,919
nombre fichero, y ahora ya ponemos en

152
00:09:04,919 --> 00:09:10,370
nombre fichero

153
00:09:10,370 --> 00:09:14,330
pues vamos a fijarle ese texto, sectes

154
00:09:14,330 --> 00:09:16,330
pues de nuestro fichero, dividir

155
00:09:16,330 --> 00:09:20,669
dividir

156
00:09:20,669 --> 00:09:21,750
que nos muestre

157
00:09:21,750 --> 00:09:23,509
venga

158
00:09:23,509 --> 00:09:25,929
esto

159
00:09:25,929 --> 00:09:28,210
el fichero con toda su ruta

160
00:09:28,210 --> 00:09:32,519
entonces ya este botón podríamos probarlo

161
00:09:32,519 --> 00:09:33,820
rápidamente a ver si

162
00:09:33,820 --> 00:09:36,340
nos deja seleccionar un fichero correctamente

163
00:09:36,340 --> 00:09:38,360
eh

164
00:09:38,360 --> 00:09:40,820
esto es

165
00:09:40,820 --> 00:09:46,120
un poquito

166
00:09:46,120 --> 00:09:48,379
seleccionamos fichero

167
00:09:48,379 --> 00:09:50,759
venga a suponer que selecciono este

168
00:09:50,759 --> 00:09:52,480
abrir pues ya está

169
00:09:52,480 --> 00:09:54,720
este, seleccionado está y está en file

170
00:09:54,720 --> 00:09:56,500
pero nos falta este botoncito

171
00:09:56,500 --> 00:09:58,159
ahora ya que es el botoncito complicado

172
00:09:58,159 --> 00:10:01,000
vale, ese es el botoncito de pensar

173
00:10:01,000 --> 00:10:04,639
venga

174
00:10:04,639 --> 00:10:06,080
panel de split otra vez

175
00:10:06,080 --> 00:10:13,659
evento, bueno

176
00:10:13,659 --> 00:10:15,779
pues ahora viene la parte importante

177
00:10:15,779 --> 00:10:18,279
la parte importante en programación

178
00:10:18,279 --> 00:10:18,659
es

179
00:10:18,659 --> 00:10:21,940
cómo organizar mis ideas

180
00:10:21,940 --> 00:10:24,240
para elaborar un algoritmo

181
00:10:24,240 --> 00:10:25,559
que haga lo que tiene que hacer

182
00:10:25,559 --> 00:10:28,360
eso es lo que yo haría con un lápiz

183
00:10:28,360 --> 00:10:30,320
y un papel pensando con palabras

184
00:10:30,320 --> 00:10:31,580
del idioma natural.

185
00:10:32,600 --> 00:10:34,720
Eso es lo que importa en programación.

186
00:10:35,279 --> 00:10:36,440
Luego ya escribir el código

187
00:10:36,440 --> 00:10:37,799
y hacer las cosas mecánicas

188
00:10:37,799 --> 00:10:39,360
pues ya es fácil.

189
00:10:40,000 --> 00:10:42,340
Entonces ahora tenemos que pensar ya sin ordenador y sin nada.

190
00:10:42,820 --> 00:10:44,200
¿Cómo podemos resolver este problema?

191
00:10:44,700 --> 00:10:45,480
Me dan un fichero

192
00:10:45,480 --> 00:10:48,039
que tiene los bytes que sean.

193
00:10:48,559 --> 00:10:50,179
Me da igual lo que tengan, dentro de un montón de bytes.

194
00:10:50,879 --> 00:10:52,340
Y ahora, tengo que

195
00:10:52,340 --> 00:10:53,820
crear otros

196
00:10:53,820 --> 00:10:55,740
que cada uno de ellos tenga

197
00:10:55,740 --> 00:10:58,299
1024 bytes del anterior.

198
00:10:58,360 --> 00:11:01,120
entonces

199
00:11:01,120 --> 00:11:03,399
del primer fichero tendré que leer

200
00:11:03,399 --> 00:11:04,059
eso está claro

201
00:11:04,059 --> 00:11:07,000
y los demás serán ficheros

202
00:11:07,000 --> 00:11:09,620
en los que tendré que escribir

203
00:11:09,620 --> 00:11:11,679
y los crearé

204
00:11:11,679 --> 00:11:13,539
de nuevas y ya más o menos

205
00:11:13,539 --> 00:11:15,440
puedo vislumbrar, ah pues yo puedo hacer

206
00:11:15,440 --> 00:11:17,519
una cosa, primero voy a ver

207
00:11:17,519 --> 00:11:18,940
cuántos ficheros voy a necesitar

208
00:11:18,940 --> 00:11:21,220
pues calculamos el tamaño del fichero

209
00:11:21,220 --> 00:11:22,399
y lo dividimos entre 1024

210
00:11:22,399 --> 00:11:24,720
y eso nos dará cuántos ficheros necesitamos

211
00:11:24,720 --> 00:11:27,059
con eso ya tenemos un array

212
00:11:27,059 --> 00:11:28,639
de objetos file

213
00:11:28,639 --> 00:11:30,940
que son los ficheros en los que tengo que escribir

214
00:11:30,940 --> 00:11:33,240
y ahora hay un bucle en el cual

215
00:11:33,240 --> 00:11:35,039
abro

216
00:11:35,039 --> 00:11:36,899
del primero, leo hasta

217
00:11:36,899 --> 00:11:38,419
1024, copio en el otro

218
00:11:38,419 --> 00:11:40,179
y cierro el otro

219
00:11:40,179 --> 00:11:43,000
siguiente iteración del bucle, leer

220
00:11:43,000 --> 00:11:45,259
otros 1024 y copiar en el otro

221
00:11:45,259 --> 00:11:47,159
siguiente iteración del bucle

222
00:11:47,159 --> 00:11:49,179
leer otros 1024 y copiar en el otro

223
00:11:49,179 --> 00:11:49,720
y ya está

224
00:11:49,720 --> 00:11:53,100
entonces uno lo que tiene es que

225
00:11:53,100 --> 00:11:54,960
pensar, vale, ¿cómo hago esto?

226
00:11:55,500 --> 00:11:57,000
bueno, pues primero la idea es esa

227
00:11:57,000 --> 00:11:58,659
un fichero del que leo

228
00:11:58,659 --> 00:12:01,500
y un montón de ficheros en los que voy a escribir de nuevas

229
00:12:01,500 --> 00:12:03,480
uno se abrirá

230
00:12:03,480 --> 00:12:05,259
con, habrá que ver qué clase

231
00:12:05,259 --> 00:12:07,539
pero con clase para leer y otros se abrirán

232
00:12:07,539 --> 00:12:09,539
habrá que ver qué clase pero con clases para escribir

233
00:12:09,539 --> 00:12:11,759
y ahora ya, ¿cómo organizo eso?

234
00:12:12,759 --> 00:12:13,100
bueno

235
00:12:13,100 --> 00:12:15,100
pues tengo que hacer un bucle

236
00:12:15,100 --> 00:12:17,139
porque tengo que escribir en una cantidad de ficheros

237
00:12:17,139 --> 00:12:18,980
no sé en cuántos, en unos cuantos

238
00:12:18,980 --> 00:12:21,019
en los que me hayan salido haciendo la división

239
00:12:21,019 --> 00:12:22,220
pues será un bucle

240
00:12:22,220 --> 00:12:24,419
pues ese bucle, ¿qué tendrá que hacer?

241
00:12:24,919 --> 00:12:26,419
coger 1024 y escribir

242
00:12:26,419 --> 00:12:28,500
y ya está, y en cada iteración

243
00:12:28,500 --> 00:12:30,379
iré leyendo 1024 y escribir

244
00:12:30,379 --> 00:12:32,379
y ya está, y ahora hay que programar eso

245
00:12:32,379 --> 00:12:34,759
que eso es lo que evaluamos

246
00:12:34,759 --> 00:12:36,559
¿vale? que sabéis programar

247
00:12:36,559 --> 00:12:38,139
algoritmos y traducirlos a Java

248
00:12:38,139 --> 00:12:39,639
pues venga

249
00:12:39,639 --> 00:12:41,440
vamos a

250
00:12:41,440 --> 00:12:44,519
a ir dándole

251
00:12:44,519 --> 00:12:45,279
forma a esto

252
00:12:45,279 --> 00:12:50,600
el enunciado dice que eso podía ser lo más

253
00:12:50,600 --> 00:12:52,659
lioso, que el contenido de fichero me da igual

254
00:12:52,659 --> 00:12:53,940
el que sea, porque un fichero

255
00:12:53,940 --> 00:12:55,980
no deja de ser una ristra de bytes

256
00:12:55,980 --> 00:12:58,779
otra cosa es como interprete uno de esos bytes

257
00:12:58,779 --> 00:13:01,019
si los interpreta según una tabla

258
00:13:01,019 --> 00:13:02,940
ASCII en el caso de que sean texto

259
00:13:02,940 --> 00:13:04,919
si los interpreta

260
00:13:04,919 --> 00:13:06,980
con un fichero Word, otra cosa es como lo interprete

261
00:13:06,980 --> 00:13:09,200
alguien, pero son una ristra de bytes

262
00:13:09,200 --> 00:13:10,679
en nuestro caso nos da igual

263
00:13:10,679 --> 00:13:13,139
lo que codifique esa ristra de bytes, porque lo único que vamos a hacer

264
00:13:13,139 --> 00:13:14,759
va a ser leer un byte

265
00:13:14,759 --> 00:13:17,159
y escribirlo ahí, leer uno y escribirlo ahí

266
00:13:17,159 --> 00:13:19,159
con lo cual nos da igual lo que tenga

267
00:13:19,159 --> 00:13:20,840
luego podemos usar nuestra clase

268
00:13:20,840 --> 00:13:22,740
FileReader, que nuestra clase FileReader

269
00:13:22,740 --> 00:13:23,940
lee

270
00:13:23,940 --> 00:13:26,480
8 bits

271
00:13:26,480 --> 00:13:29,799
lo que pasa es que si tú le haces el casting a char

272
00:13:29,799 --> 00:13:31,059
y lo muestras

273
00:13:31,059 --> 00:13:33,279
eso va a ser un carácter

274
00:13:33,279 --> 00:13:35,360
de la tabla ASCII porque ese fichero

275
00:13:35,360 --> 00:13:37,879
se supone que está codificando caracteres de la tabla ASCII

276
00:13:37,879 --> 00:13:39,200
pero entonces nos da igual

277
00:13:39,200 --> 00:13:41,340
nos da igual lo que esté codificando

278
00:13:41,340 --> 00:13:42,440
pero lo único que vamos a hacer va a ser

279
00:13:42,440 --> 00:13:44,299
con ese char que hemos leído

280
00:13:44,299 --> 00:13:46,039
luego mandarlo a otro

281
00:13:46,039 --> 00:13:49,179
entonces podemos usar la misma file reader

282
00:13:49,179 --> 00:13:50,820
nos da igual que lo que estemos leyendo

283
00:13:50,820 --> 00:13:53,600
no tenga luego ninguna conexión

284
00:13:53,600 --> 00:13:55,460
con la tabla ASCII con sentido

285
00:13:55,460 --> 00:13:57,659
nos da lo mismo, porque no lo vamos a hacer un casting

286
00:13:57,659 --> 00:13:59,759
a char, ni lo vamos a mostrar, ni vamos a hacer nada

287
00:13:59,759 --> 00:14:01,919
lo vamos a leer

288
00:14:01,919 --> 00:14:04,100
es decir, mover a una variable de la aplicación

289
00:14:04,100 --> 00:14:05,200
y luego de esa misma variable

290
00:14:05,200 --> 00:14:07,539
llevarla a otro

291
00:14:07,539 --> 00:14:09,639
entonces podemos usar el mismo file reader

292
00:14:09,639 --> 00:14:10,659
¿vale?

293
00:14:12,120 --> 00:14:13,820
pero a ver, lo primero que tenemos que hacer

294
00:14:13,820 --> 00:14:16,000
es ver cuantos ficheros vamos a necesitar

295
00:14:16,000 --> 00:14:17,580
entonces

296
00:14:17,580 --> 00:14:19,620
pues tenemos que ver

297
00:14:19,620 --> 00:14:21,120
el tamaño de ese fichero

298
00:14:21,120 --> 00:14:23,580
y dividirlo entre 1024

299
00:14:23,580 --> 00:14:25,480
a ver cuánto nos da

300
00:14:25,480 --> 00:14:27,299
y eso más el resto

301
00:14:27,299 --> 00:14:29,039
será el número de ficheros

302
00:14:29,039 --> 00:14:29,720
¿verdad?

303
00:14:30,879 --> 00:14:32,740
si tuviéramos 2048

304
00:14:32,740 --> 00:14:34,399
dividiendo en 24 te sale 2

305
00:14:34,399 --> 00:14:35,360
¿vale?

306
00:14:35,919 --> 00:14:38,740
pero si tiene más de 2048 te sale 2

307
00:14:38,740 --> 00:14:41,000
pero el resto es un tercer fichero

308
00:14:41,000 --> 00:14:43,460
entonces si el resto no fuera 0

309
00:14:43,460 --> 00:14:44,440
hay un tercer fichero

310
00:14:44,440 --> 00:14:45,879
con los que queden

311
00:14:45,879 --> 00:14:46,720
¿vale?

312
00:14:47,659 --> 00:14:50,080
bueno, pues entonces, primero vamos a calcular

313
00:14:50,080 --> 00:14:52,059
el número de ficheros, vamos por orden

314
00:14:52,059 --> 00:14:53,159
¿qué necesitamos?

315
00:14:53,580 --> 00:14:56,960
el número de fichero, necesitamos el tamaño

316
00:14:56,960 --> 00:14:58,600
de nuestro fichero original

317
00:14:58,600 --> 00:15:01,059
nosotros la clase

318
00:15:01,059 --> 00:15:02,779
file ya hemos visto

319
00:15:02,779 --> 00:15:05,039
que nos ofrece información sobre el fichero

320
00:15:05,039 --> 00:15:06,460
en general, el permiso de escritura

321
00:15:06,460 --> 00:15:09,159
entonces es el momento de cotillear en esa clase

322
00:15:09,159 --> 00:15:10,919
a ver si tuviera

323
00:15:10,919 --> 00:15:12,299
un método

324
00:15:12,299 --> 00:15:14,620
que me devolviera el tamaño del fichero

325
00:15:14,620 --> 00:15:18,330
y lo tiene

326
00:15:18,330 --> 00:15:21,269
tiene un método led que me devuelve

327
00:15:21,269 --> 00:15:22,330
cuántos bytes

328
00:15:22,330 --> 00:15:24,090
tiene el fichero

329
00:15:24,090 --> 00:15:29,570
si no lo tuviera

330
00:15:29,570 --> 00:15:30,750
no es grave

331
00:15:30,750 --> 00:15:33,690
porque lo que podemos es

332
00:15:33,690 --> 00:15:36,750
abrirlo

333
00:15:36,750 --> 00:15:39,509
para leer, hacer el bucle de lectura con un contador

334
00:15:39,509 --> 00:15:40,990
y ahí contar

335
00:15:40,990 --> 00:15:43,350
el bucle de lectura cuantas veces

336
00:15:43,350 --> 00:15:45,490
se ejecuta

337
00:15:45,490 --> 00:15:51,590
¿vale? es decir, podríamos hacer un contador

338
00:15:51,590 --> 00:15:53,570
abrir el fichero para leer

339
00:15:53,570 --> 00:15:55,590
meternos en el bucle de leer char, leer char

340
00:15:55,590 --> 00:15:57,450
leer char y cuando ese bucle ha terminado

341
00:15:57,450 --> 00:15:59,190
el contador tendrá

342
00:15:59,190 --> 00:16:00,450
cuantos caracteres tiene

343
00:16:00,450 --> 00:16:02,889
Entonces que no disponemos de este método

344
00:16:02,889 --> 00:16:04,250
Podríamos contarlos a mano

345
00:16:04,250 --> 00:16:06,330
Pero no nos hace falta contarlos a mano

346
00:16:06,330 --> 00:16:07,490
Porque ya lo tenemos aquí

347
00:16:07,490 --> 00:16:09,649
Vale, pues entonces

348
00:16:09,649 --> 00:16:12,590
El número de ficheros

349
00:16:12,590 --> 00:16:13,470
Ahora ya

350
00:16:13,470 --> 00:16:17,480
Lo podemos averiguar

351
00:16:17,480 --> 00:16:20,299
Porque podría ser algo como esto

352
00:16:20,299 --> 00:16:22,340
El resto de dividir

353
00:16:23,019 --> 00:16:24,559
Tam

354
00:16:24,559 --> 00:16:26,340
Entre 1024

355
00:16:27,059 --> 00:16:30,960
Es igual a 0

356
00:16:30,960 --> 00:16:33,399
Porque si es igual a 0

357
00:16:33,899 --> 00:16:45,600
El número de ficheros va a ser el cociente directamente entre TAM y 1024, que será un cociente exacto.

358
00:16:47,279 --> 00:16:50,399
Será un cociente exacto el que sea, pues ese será el número de ficheros.

359
00:16:51,159 --> 00:17:00,059
Pero si el resto no es cero, tengo un excedente de bytes que serán un fichero adicional.

360
00:17:01,360 --> 00:17:07,440
Luego, en el caso de que el resto no sea igual, pues el número de ficheros será este.

361
00:17:07,839 --> 00:17:14,079
aquí como esto me lo ha

362
00:17:14,079 --> 00:17:16,480
guardado en long

363
00:17:16,480 --> 00:17:17,880
pues por eso me dice long en int

364
00:17:17,880 --> 00:17:20,099
pierdo precisión porque claro el método length

365
00:17:20,099 --> 00:17:22,119
te da el tamaño en long

366
00:17:22,119 --> 00:17:23,880
entonces para no ir arrastrando en long

367
00:17:23,880 --> 00:17:25,980
todo el rato como no vamos a trabajar con ficheros

368
00:17:25,980 --> 00:17:27,539
de millones y millones de bytes

369
00:17:27,539 --> 00:17:30,059
vamos a hacer el casting aquí a int

370
00:17:30,059 --> 00:17:32,160
y ya está porque no va a ser

371
00:17:32,160 --> 00:17:34,259
más de los bytes que caben en un int

372
00:17:34,259 --> 00:17:37,349
bueno

373
00:17:37,349 --> 00:17:38,289
es el número de ficheros

374
00:17:38,289 --> 00:17:40,329
y ahora ya sí que hay que hacer un bucle

375
00:17:40,329 --> 00:17:42,390
y en ese buque ¿qué habrá que hacer?

376
00:17:43,529 --> 00:17:44,869
leer 1024

377
00:17:44,869 --> 00:17:47,190
e ir escribiendo

378
00:17:47,190 --> 00:17:48,630
en el fichero correspondiente

379
00:17:48,630 --> 00:17:51,750
entonces

380
00:17:51,750 --> 00:17:54,170
lo que está claro es que el fichero dividir hay que abrirlo

381
00:17:54,170 --> 00:17:54,609
para leer

382
00:17:54,609 --> 00:17:58,109
pues entonces el fichero dividir habrá que abrirlo así

383
00:17:58,109 --> 00:18:10,000
dividir

384
00:18:10,000 --> 00:18:17,269
este va a haber

385
00:18:17,269 --> 00:18:18,230
que abrirlo para leer

386
00:18:18,230 --> 00:18:22,529
sí

387
00:18:22,529 --> 00:18:23,809
es un rollo

388
00:18:23,809 --> 00:18:25,410
lo del try catch

389
00:18:25,410 --> 00:18:27,890
vamos a meterlo todo

390
00:18:27,890 --> 00:18:29,809
en el mismo try-catch

391
00:18:29,809 --> 00:18:33,980
para que sea más cómodo

392
00:18:33,980 --> 00:18:35,819
esto claro, por rapidez

393
00:18:35,819 --> 00:18:37,259
al no sacarlo a métodos

394
00:18:37,259 --> 00:18:39,839
externos y luego llamar desde aquí

395
00:18:39,839 --> 00:18:41,339
que quedaría el código más bonito

396
00:18:41,339 --> 00:18:43,839
pues nos queda aquí un método

397
00:18:43,839 --> 00:18:45,940
interno enorme

398
00:18:45,940 --> 00:18:47,279
que esto es feo, pero bueno

399
00:18:47,279 --> 00:18:50,119
lo ideal sería

400
00:18:50,119 --> 00:18:51,619
sacar esto a un método adicional

401
00:18:51,619 --> 00:18:53,500
llamar aquí al método dividir

402
00:18:53,500 --> 00:18:54,819
y al dividir hacerlo fuera

403
00:18:54,819 --> 00:18:57,740
y así queda más claro

404
00:18:57,740 --> 00:18:59,579
el código, vale, pues ahora ya

405
00:18:59,579 --> 00:19:00,880
sí que ya puede empezar el bucle

406
00:19:00,880 --> 00:19:03,400
y el bucle se va a ejecutar tantas veces como

407
00:19:03,400 --> 00:19:04,980
número de ficheros, lógicamente

408
00:19:04,980 --> 00:19:07,579
pues entonces el bucle, un bucle for normal

409
00:19:07,579 --> 00:19:09,500
y corriente, porque se va a ejecutar tantas

410
00:19:09,500 --> 00:19:10,900
veces como número de ficheros

411
00:19:10,900 --> 00:19:18,509
un tolen, no, número de

412
00:19:18,509 --> 00:19:27,460
ficheros, vale

413
00:19:27,460 --> 00:19:29,559
ahora

414
00:19:29,559 --> 00:19:31,259
aquí que tenemos, que

415
00:19:31,259 --> 00:19:33,599
crear un

416
00:19:33,599 --> 00:19:35,059
fichero con el nombre que toque

417
00:19:35,059 --> 00:19:37,220
que nos ha faltado

418
00:19:37,220 --> 00:19:39,480
lo tenemos que poner antes, pedir al usuario cuál va a ser

419
00:19:39,480 --> 00:19:41,579
la raíz de los nombres que van a tener

420
00:19:41,579 --> 00:19:43,720
los ficheros adicionales, nos ha faltado, se lo ponemos ahora

421
00:19:43,720 --> 00:19:45,660
pues hacer un fichero con el nombre

422
00:19:45,660 --> 00:19:47,480
que toque, que será datos

423
00:19:47,480 --> 00:19:49,539
concatenado con i, para que sea datos

424
00:19:49,539 --> 00:19:51,019
0, datos 1, datos 2

425
00:19:51,019 --> 00:19:53,759
hacer un fichero y hacerlo como escritura

426
00:19:53,759 --> 00:19:54,740
abrirlo como escritura

427
00:19:54,740 --> 00:19:57,700
leer 1024 bytes del original

428
00:19:57,700 --> 00:19:59,099
e irlos trasladando al otro

429
00:19:59,099 --> 00:20:01,000
y cerrar el que acabamos de abrir

430
00:20:01,000 --> 00:20:02,000
y se acabó

431
00:20:02,000 --> 00:20:04,680
entonces vamos a pedir antes que nada

432
00:20:04,680 --> 00:20:05,740
el nombrecito

433
00:20:05,740 --> 00:20:08,779
que va a tener

434
00:20:08,779 --> 00:20:12,079
los ficheros generados

435
00:20:12,079 --> 00:20:12,880
que van a compartir

436
00:20:12,880 --> 00:20:13,799
como raíz

437
00:20:13,799 --> 00:20:16,579
vale, pues entonces vamos a pedirlo

438
00:20:16,579 --> 00:20:17,819
aquí lo primero

439
00:20:17,819 --> 00:20:20,220
en un jOptionPanel

440
00:20:20,220 --> 00:20:22,200
vamos a ver si hay algún jOptionPanel

441
00:20:22,200 --> 00:20:24,759
que permita devolver

442
00:20:24,759 --> 00:20:26,880
si el showInputDialog

443
00:20:26,880 --> 00:20:28,460
te devuelve

444
00:20:28,460 --> 00:20:30,759
te abre un área de texto y devuelve un mensaje

445
00:20:30,759 --> 00:20:57,880
Pues venga, introduzca nombre de los ficheros y el nombre de los ficheros me lo devuelve aquí como valor de retorno.

446
00:20:57,880 --> 00:21:01,259
ahí, vale, esta es

447
00:21:01,259 --> 00:21:06,119
la raíz del nombre de los ficheros, venga pues ahora ya

448
00:21:06,119 --> 00:21:09,619
si que podemos, vamos a ver, nombre

449
00:21:09,619 --> 00:21:18,160
vamos a crear el nuevo fichero para escribir, file writer

450
00:21:18,160 --> 00:21:24,650
va a ser un new file writer y el nombre de ese fichero

451
00:21:24,650 --> 00:21:28,470
va a ser raíz concatenado

452
00:21:28,470 --> 00:21:32,289
con i para que sea raíz 0, raíz 1, raíz 2

453
00:21:32,289 --> 00:21:36,670
y ahora concatenado con la extensión

454
00:21:36,670 --> 00:21:38,930
que no sé si ponía .ptr o lo que fuera

455
00:21:38,930 --> 00:21:42,089
pero vamos, eso es lo de menos

456
00:21:42,089 --> 00:21:47,569
vale, pues ya hemos creado el fichero que toca

457
00:21:47,569 --> 00:21:50,569
para cada i con la extensión correspondiente

458
00:21:50,569 --> 00:21:56,190
sí

459
00:21:56,190 --> 00:22:01,440
añadimos el catch que me pide

460
00:22:01,440 --> 00:22:02,579
y ya está

461
00:22:02,579 --> 00:22:08,809
vale, ahora, ¿qué tenemos que hacer?

462
00:22:10,960 --> 00:22:23,839
Podemos leer del fichero original hasta 1024 o hasta fin de fichero, porque en el caso de que estemos ya en el último, llegará el fin de fichero antes de que hayamos leído 1024.

463
00:22:25,220 --> 00:22:26,740
Entonces, podemos hacer lo siguiente.

464
00:22:27,740 --> 00:22:30,680
Empezamos una cuenta de los ficheros, de los bytes a leer.

465
00:22:31,200 --> 00:22:32,240
Una cuenta igual a cero.

466
00:22:32,859 --> 00:22:33,720
Y ahora podemos hacer.

467
00:22:33,720 --> 00:23:03,410
Y ahora vamos a leer aquí int n va a ser para el carácter leído y ahora mientras cont sea menor que 1024 y además de ser cont menor de 1024 y además de ser menor de 1024

468
00:23:03,410 --> 00:23:05,269
no hemos llegado a fin de archivo

469
00:23:05,269 --> 00:23:07,289
es decir

470
00:23:07,289 --> 00:23:08,869
si n

471
00:23:08,869 --> 00:23:11,549
siendo n el resultado de haber leído yo

472
00:23:11,549 --> 00:23:12,670
de mi file reader

473
00:23:12,670 --> 00:23:16,950
es diferente de menos 1

474
00:23:16,950 --> 00:23:19,890
si se dan simultáneamente

475
00:23:19,890 --> 00:23:20,690
las dos cosas

476
00:23:20,690 --> 00:23:22,950
que no he llegado a fin de archivo

477
00:23:22,950 --> 00:23:24,630
y que contador

478
00:23:24,630 --> 00:23:26,190
no es 1024

479
00:23:26,190 --> 00:23:28,430
pues ¿qué hacemos con ese carácter?

480
00:23:28,430 --> 00:23:30,190
lo mandamos al otro fichero

481
00:23:30,190 --> 00:23:35,920
n

482
00:23:35,920 --> 00:23:37,559
lo mandamos al otro

483
00:23:37,559 --> 00:23:39,559
e incrementamos const para contar

484
00:23:39,559 --> 00:23:41,900
que ese carácter ya lo hemos movido

485
00:23:41,900 --> 00:24:00,559
bueno, cuando este bucle

486
00:24:00,559 --> 00:24:02,740
ha terminado, ya hemos leído

487
00:24:02,740 --> 00:24:04,680
o 1024 bytes

488
00:24:04,680 --> 00:24:06,200
o

489
00:24:06,200 --> 00:24:07,859
hemos acabado ya el fichero

490
00:24:07,859 --> 00:24:09,660
correspondiente, entonces

491
00:24:09,660 --> 00:24:11,299
ahora ya toca cerrar este

492
00:24:11,299 --> 00:24:17,690
y luego guardo

493
00:24:17,690 --> 00:24:19,390
y mando el array de bytes total

494
00:24:19,390 --> 00:24:21,589
y le das el tamaño de 1024

495
00:24:21,589 --> 00:24:23,910
si, lo que pasa es que en el último

496
00:24:23,910 --> 00:24:25,349
caso no sería de 1024

497
00:24:25,349 --> 00:24:28,329
pero bueno, se podría saber de qué

498
00:24:28,329 --> 00:24:29,849
porque calculamos el resto y ya está

499
00:24:29,849 --> 00:24:31,789
vale

500
00:24:31,789 --> 00:24:33,690
entonces

501
00:24:33,690 --> 00:24:36,049
ahora ya

502
00:24:36,049 --> 00:24:37,309
este toca cerrarlo

503
00:24:37,309 --> 00:24:42,220
este flujo toca cerrarlo porque con este archivo hemos acabado

504
00:24:42,220 --> 00:24:44,180
cuando el for vuelva

505
00:24:44,180 --> 00:24:46,059
arriba, creamos un fichero

506
00:24:46,059 --> 00:24:47,160
nuevo con el nuevo nombre

507
00:24:47,160 --> 00:24:49,000
y otra vez empezamos

508
00:24:49,000 --> 00:24:52,140
empezamos la cuenta

509
00:24:52,140 --> 00:24:53,880
y seguimos leyendo del mismo

510
00:24:53,880 --> 00:24:56,220
este no lo estamos

511
00:24:56,220 --> 00:24:58,359
cerrando. O sea, este en cada iteración del bucle

512
00:24:58,359 --> 00:24:59,940
for hemos leído 1024

513
00:24:59,940 --> 00:25:01,960
y se ha quedado ahí colocado. Ese no lo hemos cerrado.

514
00:25:02,519 --> 00:25:04,480
En la siguiente iteración del for

515
00:25:04,480 --> 00:25:06,180
seguirá leyendo los 1024 siguientes.

516
00:25:06,680 --> 00:25:08,140
Y en la siguiente seguirá leyendo

517
00:25:08,140 --> 00:25:09,720
los 1024. Así

518
00:25:09,720 --> 00:25:12,059
hasta que ya hayamos acabado con todos

519
00:25:12,059 --> 00:25:13,240
los ficheros.

520
00:25:14,220 --> 00:25:16,220
En la última de las iteraciones

521
00:25:16,220 --> 00:25:18,259
sabemos que el while va a

522
00:25:18,259 --> 00:25:19,980
terminar por esta, por aquí.

523
00:25:19,980 --> 00:25:21,319
Porque va a llegar a fin de fichero.

524
00:25:21,700 --> 00:25:23,599
En las anteriores no. En las anteriores va a acabar

525
00:25:23,599 --> 00:25:26,140
porque ya hemos escrito los 1024

526
00:25:26,140 --> 00:25:26,779
que tocaban

527
00:25:26,779 --> 00:25:36,700
aquí una vez que este for

528
00:25:36,700 --> 00:25:38,059
que está aquí acabado

529
00:25:38,059 --> 00:25:39,900
ya sí que

530
00:25:39,900 --> 00:25:42,140
podríamos cerrar este

531
00:25:42,140 --> 00:25:46,839
entonces yo creo que

532
00:25:46,839 --> 00:25:48,240
aquí no se nos escapa nada

533
00:25:48,240 --> 00:25:50,990
¿no?

534
00:25:51,650 --> 00:25:53,890
hemos visto cuántos ficheros necesitamos

535
00:25:53,890 --> 00:25:56,250
hemos abierto este para leer

536
00:25:56,250 --> 00:25:57,230
y hemos lanzado

537
00:25:57,230 --> 00:25:59,990
un bucle for donde en cada iteración

538
00:25:59,990 --> 00:26:02,289
leemos 1024

539
00:26:02,289 --> 00:26:03,789
y mandamos al otro

540
00:26:03,789 --> 00:26:05,609
cerramos y en la siguiente iteración

541
00:26:05,609 --> 00:26:06,450
fichero nuevo

542
00:26:06,450 --> 00:26:12,609
vale, entonces

543
00:26:12,609 --> 00:26:15,450
pues vamos a ver si se nos ha escapado

544
00:26:15,450 --> 00:26:17,250
algo, que errores nos salen, etc

545
00:26:17,250 --> 00:26:23,779
aquí como

546
00:26:23,779 --> 00:26:28,099
como estoy creando los ficheros

547
00:26:28,099 --> 00:26:30,740
directamente

548
00:26:30,740 --> 00:26:33,400
con el nombre sin ruta

549
00:26:33,400 --> 00:26:36,119
me los va a crear en la raíz del proyecto

550
00:26:36,119 --> 00:26:38,420
si yo pongo aquí otra ruta

551
00:26:38,420 --> 00:26:39,339
me los creará donde sea

552
00:26:39,339 --> 00:26:42,440
vale, pues voy a crear un fichero

553
00:26:42,440 --> 00:26:44,359
cualquiera aquí en el escritorio

554
00:26:44,359 --> 00:26:48,869
a ver si funciona

555
00:26:48,869 --> 00:26:50,210
para seleccionarlo

556
00:26:50,210 --> 00:27:00,049
este es cualquiera, si da igual

557
00:27:00,049 --> 00:27:02,049
si este es solo, como podría coger

558
00:27:02,049 --> 00:27:04,089
un fichero de Word, lo que fuera, lo que importa es ver

559
00:27:04,089 --> 00:27:06,130
si funciona y me aparecen luego

560
00:27:06,130 --> 00:27:08,369
tantos, venga pues este mismo

561
00:27:08,369 --> 00:27:14,559
este tiene

562
00:27:14,559 --> 00:27:16,619
este que acabo de crear

563
00:27:16,619 --> 00:27:17,440
tiene

564
00:27:17,440 --> 00:27:20,200
66, bueno, es que tiene que tener

565
00:27:20,200 --> 00:27:21,380
más de 1024, claro

566
00:27:21,380 --> 00:27:24,000
entonces, para hacer pruebas

567
00:27:24,000 --> 00:27:25,559
bueno, porque si no me creería uno solo

568
00:27:25,559 --> 00:27:28,259
entonces podemos coger cualquiera

569
00:27:28,259 --> 00:27:30,220
de Word gordote, por ejemplo

570
00:27:30,220 --> 00:27:30,839
este mismo

571
00:27:30,839 --> 00:27:33,799
que tengo aquí

572
00:27:33,799 --> 00:27:36,079
este mismo de Word

573
00:27:36,079 --> 00:27:38,460
a ver qué propiedades

574
00:27:38,460 --> 00:27:38,839
tiene

575
00:27:38,839 --> 00:27:41,779
este tiene, sí

576
00:27:41,779 --> 00:27:44,660
15.160

577
00:27:44,660 --> 00:27:45,279
bytes

578
00:27:45,279 --> 00:27:50,279
venga, cualquiera que tenga muchos bytes

579
00:27:50,279 --> 00:27:52,079
bueno, lo que pasa es que el SQL al ser de texto

580
00:27:52,079 --> 00:27:53,740
también van a ser gorditos

581
00:27:53,740 --> 00:27:54,940
a menos que tengáis uno enorme

582
00:27:54,940 --> 00:27:58,900
vale, pues vamos a probar

583
00:27:58,900 --> 00:28:00,200
porque aquí seguro que hay

584
00:28:00,200 --> 00:28:02,259
mil nullpoint que nos salen

585
00:28:02,259 --> 00:28:03,200
que no hemos tenido en cuenta

586
00:28:03,200 --> 00:28:06,500
aquí habrá mil rollos que nos van a fallar

587
00:28:06,500 --> 00:28:07,240
estoy convencida

588
00:28:07,240 --> 00:28:09,259
vamos a probarlo

589
00:28:09,259 --> 00:28:12,640
dividimos, selecciona fichero

590
00:28:12,640 --> 00:28:16,640
pues me voy aquí a mi escritorio

591
00:28:16,640 --> 00:28:20,240
y he dicho que

592
00:28:20,240 --> 00:28:21,880
este mismo

593
00:28:21,880 --> 00:28:25,220
abrir

594
00:28:25,220 --> 00:28:28,019
este es el fichero que voy a dividir, ya hago un split

595
00:28:28,019 --> 00:28:30,319
nombre de los ficheros

596
00:28:30,319 --> 00:28:32,119
pues datos, va a ser la raíz

597
00:28:32,119 --> 00:28:33,859
aceptar

598
00:28:33,859 --> 00:28:44,500
no ha salido ningún error

599
00:28:44,500 --> 00:28:46,859
pero esto no significa que lo haya hecho

600
00:28:46,859 --> 00:28:48,579
vamos a refrescar aquí

601
00:28:48,579 --> 00:28:49,880
refresh

602
00:28:49,880 --> 00:28:53,119
aquí hay un montón, datos 0, datos 1

603
00:28:53,119 --> 00:28:55,220
datos no sé cuántos. Lo que pasa es que

604
00:28:55,220 --> 00:28:57,119
claro, yo podría abrir aquí, pero lógicamente

605
00:28:57,119 --> 00:28:59,220
como son las porciones del Word, no voy a ver nada.

606
00:29:00,220 --> 00:29:01,579
Vamos a...

607
00:29:01,579 --> 00:29:02,900
Si tuviéramos un fichero de texto

608
00:29:02,900 --> 00:29:05,119
muy, muy, muy enorme, yo puedo

609
00:29:05,119 --> 00:29:07,220
guardar un Word como ASCII

610
00:29:07,220 --> 00:29:08,039
seguramente, ¿no?

611
00:29:09,599 --> 00:29:11,220
Entonces, lo digo porque así vamos a ver

612
00:29:11,220 --> 00:29:13,140
más fácil. Bueno, por lo pronto vamos a ver si el número

613
00:29:13,140 --> 00:29:14,039
de ficheros me encaja.

614
00:29:15,259 --> 00:29:16,680
Vamos a ver si el número de ficheros me encaja.

615
00:29:17,980 --> 00:29:19,099
Pero bueno, tiene toda la pinta

616
00:29:19,099 --> 00:29:20,000
de que lo está haciendo bien.

617
00:29:20,000 --> 00:29:22,000
A ver...

618
00:29:23,119 --> 00:29:50,799
Este mío tenía 15.160, entonces, si yo divido 15.160 entre 1.024, 14,8, 15 ficheros deberían haberme salido, 15.

619
00:29:51,940 --> 00:29:53,819
Vamos a ver si me han salido 15.

620
00:29:54,500 --> 00:29:59,009
Sí, me han salido 15 justo

621
00:29:59,009 --> 00:29:59,869
Del 0 al 14

622
00:29:59,869 --> 00:30:02,569
Hombre, pues casi tiene toda la pinta

623
00:30:02,569 --> 00:30:03,589
De que lo habrá dividido bien

624
00:30:03,589 --> 00:30:05,029
Porque si me ha hecho esos justo

625
00:30:05,029 --> 00:30:20,990
¿Te han salido?

626
00:30:23,869 --> 00:30:25,809
Pero porque igual tu fichero era enorme

627
00:30:25,809 --> 00:30:29,269
No, no