Saltar navegación

20250506 EjerSplitMerge_1 - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 7 de mayo de 2025 por Raquel G.

23 visualizaciones

Más información Transcripción

Descargar la transcripción

venga pues nada vamos a hacer entonces la interfaz un nuevo frame os voy a que 00:00:00
no lo sé ya lo sabrás el viernes vale 00:00:17
que sí vale pues entonces ya tenemos el frame hemos dicho que dos pestañas un tablet pan y 00:00:23
con dos pestañas, bueno, pues venga 00:00:35
para hacer dos 00:00:36
paneles con pestañas 00:00:40
pues primero colocábamos 00:00:42
el panel tabulado este 00:00:44
bueno 00:00:46
voy a poner el 00:00:48
el absolute layout aquí 00:00:50
ahí 00:00:52
y ahora el panel 00:00:55
este de aquí 00:00:56
vale 00:00:58
y ahora vamos a poner ya 00:01:05
un panel 00:01:08
ahí, con una pestañita 00:01:09
Y esta pestañita va a ser la pestañita de split. 00:01:14
Este va a ser panel split. 00:01:39
Y ahora vamos a hacernos un panel que es el panel de merge. 00:01:44
Y este, vale. 00:02:00
Pues empezamos con el panel de Split. 00:02:17
¿Qué tiene que tener? 00:02:19
Tiene que tener un control para introducir el nombre del 00:02:20
fichero, ¿verdad? 00:02:23
Se selecciona un fichero, al ser posible, con un file chooser. 00:02:25
Vale, pues un botoncito, seleccionar fichero. 00:02:28
Y una vez seleccionado, se hace clic en un botón Split y te 00:02:31
dice, vale, ¿cuál va a ser el nombre del usuario, 00:02:38
el nombre del fichero? 00:02:43
Por ejemplo, data, esto no lo entiendo. 00:02:44
Ah, sí, los nombres de los ficheros. 00:02:47
¿Data 1, data 2 y de nombre datos? 00:02:49
Vale, si datos 1, datos 2 es que vale. 00:02:52
Vale, pues data es la raíz común que tendrán los nombres de los ficheros en los que se va a dividir. 00:02:54
Entonces, si ponemos data, serán data 1, data 2, data 3, data 4. 00:03:02
¿Vale? 00:03:05
Cada uno con 1024 bits más el restante. 00:03:06
Venga, pues entonces. 00:03:09
Necesitamos, por tanto, un botón para que salga el file chooser. 00:03:14
un botón de split 00:03:17
y cuando le damos al botón de split 00:03:19
va a aparecer un jOptionPane 00:03:21
para pedirte el nombre del fichero 00:03:23
y luego ya 00:03:24
cuando le demos a aceptar a ese 00:03:26
jOptionPane pues ya se hace la división 00:03:29
y se acabó, entonces no hacen falta más 00:03:31
controles que esos, pues venga 00:03:33
vamos a poner un botoncito 00:03:35
para seleccionar el fichero 00:03:37
voy a ponerle al 00:03:38
panel este de aquí 00:03:46
panel split 00:03:47
el absolute layer 00:03:49
estaba buscando el gestor de ubicación del panel 00:04:08
vale, en este panel absolute layer 00:04:10
para poner el botón donde queramos 00:04:12
ahora ya sí, un botón que sea 00:04:13
elegir fichero 00:04:16
botón 00:04:20
elegir fichero 00:04:24
vale, y el botón 00:04:27
elegir fichero va a tener un texto arriba 00:04:29
selecciona 00:04:31
fichero, vale 00:04:35
este es nuestro botoncito que abriría 00:04:40
el file chooser 00:04:42
bueno, luego vamos a ponerle otro botón 00:04:43
que es para darle ya la orden de hacer el split 00:04:46
pues ese botón aquí debajo 00:04:48
lo llamamos 00:04:51
botón split, por ejemplo 00:04:53
como nos dé la gana 00:04:55
y le ponemos el texto 00:04:56
split 00:05:00
y ya está, porque cuando le damos a split se hace la división 00:05:02
y se acabó, entonces ya no hay más controles 00:05:12
aquí, venga, pues 00:05:13
evento del primer botón, el más fácil, abrir el file 00:05:15
chooser para seleccionar un nombre de fichero 00:05:17
luego ya el más complicado es el otro, el que tiene 00:05:19
toda la división, claro, pues venga 00:05:21
vámonos al evento de este botoncito 00:05:23
este botoncito va a 00:05:25
seleccionar el fichero 00:05:30
para seleccionar el 00:05:31
nos va a permitir seleccionar el fichero 00:05:34
para eso ya nos lo sabemos de memoria 00:05:36
instanciamos este objeto 00:05:38
y luego abrimos la ventana de 00:05:45
diálogo, vale 00:05:51
vamos a abrir la ventana de diálogo que sabemos 00:05:59
que nos devuelve 00:06:01
un entero con 00:06:02
la respuesta que ha dado 00:06:05
el usuario, si ha dado 00:06:07
save, open, cancel, lo que sea 00:06:09
y ahora ya hacemos aquí 00:06:11
show open 00:06:14
diálogo 00:06:17
y ahora ya 00:06:17
si no le han dado a cancel 00:06:25
porque podrían haberle dado a cancel 00:06:27
porque se han equivocado, si no le han 00:06:28
dado a cancel o lo que es lo mismo. Si la opción 00:06:31
que ha devuelto la ventanita cuando es la opción de 00:06:34
aprobar, entonces 00:06:39
ya vamos a quedarnos con el 00:06:45
fichero que esté seleccionado. Entonces, de nuevo, eso que nos devuelve 00:06:48
el file chooser es un objeto file que tiene que estar accesible 00:06:53
para el resto de la aplicación, en concreto para el botón de split. Pues ese es un dato de la 00:06:56
aplicación. Pues ese dato de la aplicación 00:07:00
para que esté accesible 00:07:03
para el resto de métodos y clases 00:07:04
internas, lo declaramos 00:07:06
aquí fuera. 00:07:08
Pues este es el fichero a dividir. 00:07:11
El fichero que vamos a dividir es 00:07:17
este. 00:07:18
Bueno, pues el fichero que vamos a dividir 00:07:23
es este y le damos ya 00:07:25
valor en este momento. 00:07:26
Ahí ya tiene valor. 00:07:37
Ay, perdón, no lo he puesto aquí. 00:07:40
Fichero 00:07:42
dividir 00:07:43
ahí, vale, pues ya tenemos 00:07:45
el file, ese botón era solamente para el file 00:07:49
dime 00:07:51
eh, sí 00:07:51
sí, sí, vale 00:07:54
ahora ya, pues 00:07:56
podemos poner el 00:07:58
fichero que se ha seleccionado, a lo mejor en el propio 00:08:00
botón o en algún sitio para que se vea 00:08:03
cuál es el que hemos seleccionado 00:08:04
bueno, vamos a hacerlo en una 00:08:06
etiqueta 00:08:10
para no estropear tampoco el botón 00:08:11
entonces vamos a ponernos una etiqueta cualquiera 00:08:14
por aquí 00:08:18
da igual, lo que queramos, con lo que importa es que esté informativo 00:08:21
vale, y esta etiqueta que inicialmente 00:08:27
no tiene texto, en esta etiqueta que se llama nombre fichero 00:08:36
aprovechamos y lo ponemos 00:08:47
ponemos aquí, bueno, vamos a sacarla 00:08:48
a clase, porque si no, no va a ser accesible 00:08:52
desde la clase interna, ya la hemos sacado 00:08:56
nombre fichero, y ahora ya ponemos en 00:09:00
nombre fichero 00:09:04
pues vamos a fijarle ese texto, sectes 00:09:10
pues de nuestro fichero, dividir 00:09:14
dividir 00:09:16
que nos muestre 00:09:20
venga 00:09:21
esto 00:09:23
el fichero con toda su ruta 00:09:25
entonces ya este botón podríamos probarlo 00:09:28
rápidamente a ver si 00:09:32
nos deja seleccionar un fichero correctamente 00:09:33
esto es 00:09:38
un poquito 00:09:40
seleccionamos fichero 00:09:46
venga a suponer que selecciono este 00:09:48
abrir pues ya está 00:09:50
este, seleccionado está y está en file 00:09:52
pero nos falta este botoncito 00:09:54
ahora ya que es el botoncito complicado 00:09:56
vale, ese es el botoncito de pensar 00:09:58
venga 00:10:01
panel de split otra vez 00:10:04
evento, bueno 00:10:06
pues ahora viene la parte importante 00:10:13
la parte importante en programación 00:10:15
cómo organizar mis ideas 00:10:18
para elaborar un algoritmo 00:10:21
que haga lo que tiene que hacer 00:10:24
eso es lo que yo haría con un lápiz 00:10:25
y un papel pensando con palabras 00:10:28
del idioma natural. 00:10:30
Eso es lo que importa en programación. 00:10:32
Luego ya escribir el código 00:10:35
y hacer las cosas mecánicas 00:10:36
pues ya es fácil. 00:10:37
Entonces ahora tenemos que pensar ya sin ordenador y sin nada. 00:10:40
¿Cómo podemos resolver este problema? 00:10:42
Me dan un fichero 00:10:44
que tiene los bytes que sean. 00:10:45
Me da igual lo que tengan, dentro de un montón de bytes. 00:10:48
Y ahora, tengo que 00:10:50
crear otros 00:10:52
que cada uno de ellos tenga 00:10:53
1024 bytes del anterior. 00:10:55
entonces 00:10:58
del primer fichero tendré que leer 00:11:01
eso está claro 00:11:03
y los demás serán ficheros 00:11:04
en los que tendré que escribir 00:11:07
y los crearé 00:11:09
de nuevas y ya más o menos 00:11:11
puedo vislumbrar, ah pues yo puedo hacer 00:11:13
una cosa, primero voy a ver 00:11:15
cuántos ficheros voy a necesitar 00:11:17
pues calculamos el tamaño del fichero 00:11:18
y lo dividimos entre 1024 00:11:21
y eso nos dará cuántos ficheros necesitamos 00:11:22
con eso ya tenemos un array 00:11:24
de objetos file 00:11:27
que son los ficheros en los que tengo que escribir 00:11:28
y ahora hay un bucle en el cual 00:11:30
abro 00:11:33
del primero, leo hasta 00:11:35
1024, copio en el otro 00:11:36
y cierro el otro 00:11:38
siguiente iteración del bucle, leer 00:11:40
otros 1024 y copiar en el otro 00:11:43
siguiente iteración del bucle 00:11:45
leer otros 1024 y copiar en el otro 00:11:47
y ya está 00:11:49
entonces uno lo que tiene es que 00:11:49
pensar, vale, ¿cómo hago esto? 00:11:53
bueno, pues primero la idea es esa 00:11:55
un fichero del que leo 00:11:57
y un montón de ficheros en los que voy a escribir de nuevas 00:11:58
uno se abrirá 00:12:01
con, habrá que ver qué clase 00:12:03
pero con clase para leer y otros se abrirán 00:12:05
habrá que ver qué clase pero con clases para escribir 00:12:07
y ahora ya, ¿cómo organizo eso? 00:12:09
bueno 00:12:12
pues tengo que hacer un bucle 00:12:13
porque tengo que escribir en una cantidad de ficheros 00:12:15
no sé en cuántos, en unos cuantos 00:12:17
en los que me hayan salido haciendo la división 00:12:18
pues será un bucle 00:12:21
pues ese bucle, ¿qué tendrá que hacer? 00:12:22
coger 1024 y escribir 00:12:24
y ya está, y en cada iteración 00:12:26
iré leyendo 1024 y escribir 00:12:28
y ya está, y ahora hay que programar eso 00:12:30
que eso es lo que evaluamos 00:12:32
¿vale? que sabéis programar 00:12:34
algoritmos y traducirlos a Java 00:12:36
pues venga 00:12:38
vamos a 00:12:39
a ir dándole 00:12:41
forma a esto 00:12:44
el enunciado dice que eso podía ser lo más 00:12:45
lioso, que el contenido de fichero me da igual 00:12:50
el que sea, porque un fichero 00:12:52
no deja de ser una ristra de bytes 00:12:53
otra cosa es como interprete uno de esos bytes 00:12:55
si los interpreta según una tabla 00:12:58
ASCII en el caso de que sean texto 00:13:01
si los interpreta 00:13:02
con un fichero Word, otra cosa es como lo interprete 00:13:04
alguien, pero son una ristra de bytes 00:13:06
en nuestro caso nos da igual 00:13:09
lo que codifique esa ristra de bytes, porque lo único que vamos a hacer 00:13:10
va a ser leer un byte 00:13:13
y escribirlo ahí, leer uno y escribirlo ahí 00:13:14
con lo cual nos da igual lo que tenga 00:13:17
luego podemos usar nuestra clase 00:13:19
FileReader, que nuestra clase FileReader 00:13:20
lee 00:13:22
8 bits 00:13:23
lo que pasa es que si tú le haces el casting a char 00:13:26
y lo muestras 00:13:29
eso va a ser un carácter 00:13:31
de la tabla ASCII porque ese fichero 00:13:33
se supone que está codificando caracteres de la tabla ASCII 00:13:35
pero entonces nos da igual 00:13:37
nos da igual lo que esté codificando 00:13:39
pero lo único que vamos a hacer va a ser 00:13:41
con ese char que hemos leído 00:13:42
luego mandarlo a otro 00:13:44
entonces podemos usar la misma file reader 00:13:46
nos da igual que lo que estemos leyendo 00:13:49
no tenga luego ninguna conexión 00:13:50
con la tabla ASCII con sentido 00:13:53
nos da lo mismo, porque no lo vamos a hacer un casting 00:13:55
a char, ni lo vamos a mostrar, ni vamos a hacer nada 00:13:57
lo vamos a leer 00:13:59
es decir, mover a una variable de la aplicación 00:14:01
y luego de esa misma variable 00:14:04
llevarla a otro 00:14:05
entonces podemos usar el mismo file reader 00:14:07
¿vale? 00:14:09
pero a ver, lo primero que tenemos que hacer 00:14:12
es ver cuantos ficheros vamos a necesitar 00:14:13
entonces 00:14:16
pues tenemos que ver 00:14:17
el tamaño de ese fichero 00:14:19
y dividirlo entre 1024 00:14:21
a ver cuánto nos da 00:14:23
y eso más el resto 00:14:25
será el número de ficheros 00:14:27
¿verdad? 00:14:29
si tuviéramos 2048 00:14:30
dividiendo en 24 te sale 2 00:14:32
¿vale? 00:14:34
pero si tiene más de 2048 te sale 2 00:14:35
pero el resto es un tercer fichero 00:14:38
entonces si el resto no fuera 0 00:14:41
hay un tercer fichero 00:14:43
con los que queden 00:14:44
¿vale? 00:14:45
bueno, pues entonces, primero vamos a calcular 00:14:47
el número de ficheros, vamos por orden 00:14:50
¿qué necesitamos? 00:14:52
el número de fichero, necesitamos el tamaño 00:14:53
de nuestro fichero original 00:14:56
nosotros la clase 00:14:58
file ya hemos visto 00:15:01
que nos ofrece información sobre el fichero 00:15:02
en general, el permiso de escritura 00:15:05
entonces es el momento de cotillear en esa clase 00:15:06
a ver si tuviera 00:15:09
un método 00:15:10
que me devolviera el tamaño del fichero 00:15:12
y lo tiene 00:15:14
tiene un método led que me devuelve 00:15:18
cuántos bytes 00:15:21
tiene el fichero 00:15:22
si no lo tuviera 00:15:24
no es grave 00:15:29
porque lo que podemos es 00:15:30
abrirlo 00:15:33
para leer, hacer el bucle de lectura con un contador 00:15:36
y ahí contar 00:15:39
el bucle de lectura cuantas veces 00:15:40
se ejecuta 00:15:43
¿vale? es decir, podríamos hacer un contador 00:15:45
abrir el fichero para leer 00:15:51
meternos en el bucle de leer char, leer char 00:15:53
leer char y cuando ese bucle ha terminado 00:15:55
el contador tendrá 00:15:57
cuantos caracteres tiene 00:15:59
Entonces que no disponemos de este método 00:16:00
Podríamos contarlos a mano 00:16:02
Pero no nos hace falta contarlos a mano 00:16:04
Porque ya lo tenemos aquí 00:16:06
Vale, pues entonces 00:16:07
El número de ficheros 00:16:09
Ahora ya 00:16:12
Lo podemos averiguar 00:16:13
Porque podría ser algo como esto 00:16:17
El resto de dividir 00:16:20
Tam 00:16:23
Entre 1024 00:16:24
Es igual a 0 00:16:27
Porque si es igual a 0 00:16:30
El número de ficheros va a ser el cociente directamente entre TAM y 1024, que será un cociente exacto. 00:16:33
Será un cociente exacto el que sea, pues ese será el número de ficheros. 00:16:47
Pero si el resto no es cero, tengo un excedente de bytes que serán un fichero adicional. 00:16:51
Luego, en el caso de que el resto no sea igual, pues el número de ficheros será este. 00:17:01
aquí como esto me lo ha 00:17:07
guardado en long 00:17:14
pues por eso me dice long en int 00:17:16
pierdo precisión porque claro el método length 00:17:17
te da el tamaño en long 00:17:20
entonces para no ir arrastrando en long 00:17:22
todo el rato como no vamos a trabajar con ficheros 00:17:23
de millones y millones de bytes 00:17:25
vamos a hacer el casting aquí a int 00:17:27
y ya está porque no va a ser 00:17:30
más de los bytes que caben en un int 00:17:32
bueno 00:17:34
es el número de ficheros 00:17:37
y ahora ya sí que hay que hacer un bucle 00:17:38
y en ese buque ¿qué habrá que hacer? 00:17:40
leer 1024 00:17:43
e ir escribiendo 00:17:44
en el fichero correspondiente 00:17:47
entonces 00:17:48
lo que está claro es que el fichero dividir hay que abrirlo 00:17:51
para leer 00:17:54
pues entonces el fichero dividir habrá que abrirlo así 00:17:54
dividir 00:17:58
este va a haber 00:18:10
que abrirlo para leer 00:18:17
sí 00:18:18
es un rollo 00:18:22
lo del try catch 00:18:23
vamos a meterlo todo 00:18:25
en el mismo try-catch 00:18:27
para que sea más cómodo 00:18:29
esto claro, por rapidez 00:18:33
al no sacarlo a métodos 00:18:35
externos y luego llamar desde aquí 00:18:37
que quedaría el código más bonito 00:18:39
pues nos queda aquí un método 00:18:41
interno enorme 00:18:43
que esto es feo, pero bueno 00:18:45
lo ideal sería 00:18:47
sacar esto a un método adicional 00:18:50
llamar aquí al método dividir 00:18:51
y al dividir hacerlo fuera 00:18:53
y así queda más claro 00:18:54
el código, vale, pues ahora ya 00:18:57
sí que ya puede empezar el bucle 00:18:59
y el bucle se va a ejecutar tantas veces como 00:19:00
número de ficheros, lógicamente 00:19:03
pues entonces el bucle, un bucle for normal 00:19:04
y corriente, porque se va a ejecutar tantas 00:19:07
veces como número de ficheros 00:19:09
un tolen, no, número de 00:19:10
ficheros, vale 00:19:18
ahora 00:19:27
aquí que tenemos, que 00:19:29
crear un 00:19:31
fichero con el nombre que toque 00:19:33
que nos ha faltado 00:19:35
lo tenemos que poner antes, pedir al usuario cuál va a ser 00:19:37
la raíz de los nombres que van a tener 00:19:39
los ficheros adicionales, nos ha faltado, se lo ponemos ahora 00:19:41
pues hacer un fichero con el nombre 00:19:43
que toque, que será datos 00:19:45
concatenado con i, para que sea datos 00:19:47
0, datos 1, datos 2 00:19:49
hacer un fichero y hacerlo como escritura 00:19:51
abrirlo como escritura 00:19:53
leer 1024 bytes del original 00:19:54
e irlos trasladando al otro 00:19:57
y cerrar el que acabamos de abrir 00:19:59
y se acabó 00:20:01
entonces vamos a pedir antes que nada 00:20:02
el nombrecito 00:20:04
que va a tener 00:20:05
los ficheros generados 00:20:08
que van a compartir 00:20:12
como raíz 00:20:12
vale, pues entonces vamos a pedirlo 00:20:13
aquí lo primero 00:20:16
en un jOptionPanel 00:20:17
vamos a ver si hay algún jOptionPanel 00:20:20
que permita devolver 00:20:22
si el showInputDialog 00:20:24
te devuelve 00:20:26
te abre un área de texto y devuelve un mensaje 00:20:28
Pues venga, introduzca nombre de los ficheros y el nombre de los ficheros me lo devuelve aquí como valor de retorno. 00:20:30
ahí, vale, esta es 00:20:57
la raíz del nombre de los ficheros, venga pues ahora ya 00:21:01
si que podemos, vamos a ver, nombre 00:21:06
vamos a crear el nuevo fichero para escribir, file writer 00:21:09
va a ser un new file writer y el nombre de ese fichero 00:21:18
va a ser raíz concatenado 00:21:24
con i para que sea raíz 0, raíz 1, raíz 2 00:21:28
y ahora concatenado con la extensión 00:21:32
que no sé si ponía .ptr o lo que fuera 00:21:36
pero vamos, eso es lo de menos 00:21:38
vale, pues ya hemos creado el fichero que toca 00:21:42
para cada i con la extensión correspondiente 00:21:47
sí 00:21:50
añadimos el catch que me pide 00:21:56
y ya está 00:22:01
vale, ahora, ¿qué tenemos que hacer? 00:22:02
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. 00:22:10
Entonces, podemos hacer lo siguiente. 00:22:25
Empezamos una cuenta de los ficheros, de los bytes a leer. 00:22:27
Una cuenta igual a cero. 00:22:31
Y ahora podemos hacer. 00:22:32
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 00:22:33
no hemos llegado a fin de archivo 00:23:03
es decir 00:23:05
si n 00:23:07
siendo n el resultado de haber leído yo 00:23:08
de mi file reader 00:23:11
es diferente de menos 1 00:23:12
si se dan simultáneamente 00:23:16
las dos cosas 00:23:19
que no he llegado a fin de archivo 00:23:20
y que contador 00:23:22
no es 1024 00:23:24
pues ¿qué hacemos con ese carácter? 00:23:26
lo mandamos al otro fichero 00:23:28
lo mandamos al otro 00:23:35
e incrementamos const para contar 00:23:37
que ese carácter ya lo hemos movido 00:23:39
bueno, cuando este bucle 00:23:41
ha terminado, ya hemos leído 00:24:00
o 1024 bytes 00:24:02
hemos acabado ya el fichero 00:24:06
correspondiente, entonces 00:24:07
ahora ya toca cerrar este 00:24:09
y luego guardo 00:24:11
y mando el array de bytes total 00:24:17
y le das el tamaño de 1024 00:24:19
si, lo que pasa es que en el último 00:24:21
caso no sería de 1024 00:24:23
pero bueno, se podría saber de qué 00:24:25
porque calculamos el resto y ya está 00:24:28
vale 00:24:29
entonces 00:24:31
ahora ya 00:24:33
este toca cerrarlo 00:24:36
este flujo toca cerrarlo porque con este archivo hemos acabado 00:24:37
cuando el for vuelva 00:24:42
arriba, creamos un fichero 00:24:44
nuevo con el nuevo nombre 00:24:46
y otra vez empezamos 00:24:47
empezamos la cuenta 00:24:49
y seguimos leyendo del mismo 00:24:52
este no lo estamos 00:24:53
cerrando. O sea, este en cada iteración del bucle 00:24:56
for hemos leído 1024 00:24:58
y se ha quedado ahí colocado. Ese no lo hemos cerrado. 00:24:59
En la siguiente iteración del for 00:25:02
seguirá leyendo los 1024 siguientes. 00:25:04
Y en la siguiente seguirá leyendo 00:25:06
los 1024. Así 00:25:08
hasta que ya hayamos acabado con todos 00:25:09
los ficheros. 00:25:12
En la última de las iteraciones 00:25:14
sabemos que el while va a 00:25:16
terminar por esta, por aquí. 00:25:18
Porque va a llegar a fin de fichero. 00:25:19
En las anteriores no. En las anteriores va a acabar 00:25:21
porque ya hemos escrito los 1024 00:25:23
que tocaban 00:25:26
aquí una vez que este for 00:25:26
que está aquí acabado 00:25:36
ya sí que 00:25:38
podríamos cerrar este 00:25:39
entonces yo creo que 00:25:42
aquí no se nos escapa nada 00:25:46
¿no? 00:25:48
hemos visto cuántos ficheros necesitamos 00:25:51
hemos abierto este para leer 00:25:53
y hemos lanzado 00:25:56
un bucle for donde en cada iteración 00:25:57
leemos 1024 00:25:59
y mandamos al otro 00:26:02
cerramos y en la siguiente iteración 00:26:03
fichero nuevo 00:26:05
vale, entonces 00:26:06
pues vamos a ver si se nos ha escapado 00:26:12
algo, que errores nos salen, etc 00:26:15
aquí como 00:26:17
como estoy creando los ficheros 00:26:23
directamente 00:26:28
con el nombre sin ruta 00:26:30
me los va a crear en la raíz del proyecto 00:26:33
si yo pongo aquí otra ruta 00:26:36
me los creará donde sea 00:26:38
vale, pues voy a crear un fichero 00:26:39
cualquiera aquí en el escritorio 00:26:42
a ver si funciona 00:26:44
para seleccionarlo 00:26:48
este es cualquiera, si da igual 00:26:50
si este es solo, como podría coger 00:27:00
un fichero de Word, lo que fuera, lo que importa es ver 00:27:02
si funciona y me aparecen luego 00:27:04
tantos, venga pues este mismo 00:27:06
este tiene 00:27:08
este que acabo de crear 00:27:14
tiene 00:27:16
66, bueno, es que tiene que tener 00:27:17
más de 1024, claro 00:27:20
entonces, para hacer pruebas 00:27:21
bueno, porque si no me creería uno solo 00:27:24
entonces podemos coger cualquiera 00:27:25
de Word gordote, por ejemplo 00:27:28
este mismo 00:27:30
que tengo aquí 00:27:30
este mismo de Word 00:27:33
a ver qué propiedades 00:27:36
tiene 00:27:38
este tiene, sí 00:27:38
15.160 00:27:41
bytes 00:27:44
venga, cualquiera que tenga muchos bytes 00:27:45
bueno, lo que pasa es que el SQL al ser de texto 00:27:50
también van a ser gorditos 00:27:52
a menos que tengáis uno enorme 00:27:53
vale, pues vamos a probar 00:27:54
porque aquí seguro que hay 00:27:58
mil nullpoint que nos salen 00:28:00
que no hemos tenido en cuenta 00:28:02
aquí habrá mil rollos que nos van a fallar 00:28:03
estoy convencida 00:28:06
vamos a probarlo 00:28:07
dividimos, selecciona fichero 00:28:09
pues me voy aquí a mi escritorio 00:28:12
y he dicho que 00:28:16
este mismo 00:28:20
abrir 00:28:21
este es el fichero que voy a dividir, ya hago un split 00:28:25
nombre de los ficheros 00:28:28
pues datos, va a ser la raíz 00:28:30
aceptar 00:28:32
no ha salido ningún error 00:28:33
pero esto no significa que lo haya hecho 00:28:44
vamos a refrescar aquí 00:28:46
refresh 00:28:48
aquí hay un montón, datos 0, datos 1 00:28:49
datos no sé cuántos. Lo que pasa es que 00:28:53
claro, yo podría abrir aquí, pero lógicamente 00:28:55
como son las porciones del Word, no voy a ver nada. 00:28:57
Vamos a... 00:29:00
Si tuviéramos un fichero de texto 00:29:01
muy, muy, muy enorme, yo puedo 00:29:02
guardar un Word como ASCII 00:29:05
seguramente, ¿no? 00:29:07
Entonces, lo digo porque así vamos a ver 00:29:09
más fácil. Bueno, por lo pronto vamos a ver si el número 00:29:11
de ficheros me encaja. 00:29:13
Vamos a ver si el número de ficheros me encaja. 00:29:15
Pero bueno, tiene toda la pinta 00:29:17
de que lo está haciendo bien. 00:29:19
A ver... 00:29:20
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. 00:29:23
Vamos a ver si me han salido 15. 00:29:51
Sí, me han salido 15 justo 00:29:54
Del 0 al 14 00:29:59
Hombre, pues casi tiene toda la pinta 00:29:59
De que lo habrá dividido bien 00:30:02
Porque si me ha hecho esos justo 00:30:03
¿Te han salido? 00:30:05
Pero porque igual tu fichero era enorme 00:30:23
No, no 00:30:25
Materias:
Programación
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado superior
      • Primer Curso
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
23
Fecha:
7 de mayo de 2025 - 19:35
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
30′ 29″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
146.08 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid