Saltar navegación

20250506 EjerSplitMerge_2 - 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.

6 visualizaciones

Más información Transcripción

Descargar la transcripción

Bueno, pues vamos a ver qué nos decía la otra pestañita. 00:00:02
Le damos un nombre. 00:00:08
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. 00:00:11
Bueno, nosotros lo hemos hecho antes con 0, pero da igual. 00:00:26
Sería empezar la I en lugar de 0 en 1, pero da lo mismo. 00:00:28
y a partir de ahí 00:00:31
leemos los ficheros 00:00:33
los guardamos 00:00:35
en una estructura de datos dinámica 00:00:40
que contenga file 00:00:42
y ahora 00:00:44
tendremos que leer 00:00:48
de todos esos y llevarlos a un fichero 00:00:50
con el nombre indicado 00:00:53
bueno, más o menos entendemos lo que hay que hacer 00:00:53
nos van a dar un nombre, una raíz común 00:00:57
habrá que buscar 00:01:00
todos los ficheros 00:01:02
que se llamen así 00:01:05
no especifica en qué ruta 00:01:05
vamos a poner que en la ruta por defecto 00:01:08
del proyecto 00:01:10
todos los ficheros que se llamen así 00:01:11
seguidos de un numerito 00:01:14
y una extensión ptr 00:01:16
y luego tendrá que ir leyendo 00:01:17
de ellos e ir escribiéndolo 00:01:20
todo sucesivamente en otro fichero final 00:01:22
pues venga va a tener 00:01:24
solamente un botón 00:01:26
merge 00:01:28
y el nombre 00:01:30
en un text field 00:01:32
con el nombre de la raíz. 00:01:37
Vale. 00:01:39
Ah, no, en este text field 00:01:44
el fichero destino. 00:01:45
Y los... 00:01:47
Ah, vale, el merge solicita... 00:01:51
Venga, pues a ver. 00:01:54
Vamos a ver. 00:01:55
Emerge, entonces. 00:01:59
Primero, un text field 00:02:02
A ver, primero, antes que nada 00:02:06
Poner el 00:02:08
Antes que nada 00:02:09
Poner 00:02:19
Venga, continuamos 00:02:19
Vamos a acabar 00:02:24
¿Qué? 00:02:25
¿Vas a seguir un rato a dar una vuelta? 00:02:27
¡Hala! Panel de Merge 00:02:29
Absolute Layout 00:02:31
Ahora hemos dicho 00:02:33
Un Text Fill 00:02:35
Para poner 00:02:35
La raíz 00:02:37
De los ficheros que se van a unir 00:02:40
Vale 00:02:42
Texto raíz le voy a llamar 00:02:45
Texto raíz 00:02:49
Vale 00:02:52
Vamos a poner una etiqueta 00:02:53
Para indicar al usuario lo que tiene que poner ahí 00:02:55
Y ahí en esa etiqueta 00:02:57
Pues tiene que haber 00:03:01
Raíz 00:03:02
De los ficheros 00:03:06
A unir 00:03:09
raíz de los ficheros 00:03:11
a unir, vale, ya está 00:03:17
ahora, botón de merge, pues venga 00:03:25
botón, se va a ir aquí 00:03:29
y este botón va a tener como texto, pues eso 00:03:32
merge 00:03:43
y ya está 00:03:44
no hay más controles que poner 00:03:48
ahí se pone la raíz y cuando se dé al botón 00:03:50
él te pide en un jOptionPane el nombre del fichero destino 00:03:53
y te hace todo eso 00:03:55
que dice que hay que hacer 00:03:57
pues venga, solo hay un evento entonces 00:03:58
el del botón, pues vamos a hacer el evento 00:04:01
venga, evento del botón 00:04:03
primero 00:04:14
nos va a abrir 00:04:16
un jOptionPane 00:04:18
para pedirnos el nombre del fichero 00:04:20
destino. Pues un jOptionPane 00:04:22
como el que hemos abierto antes para 00:04:25
poner el fichero de destino 00:04:29
sobre el que vamos a escribir. El fichero 00:04:33
de destino va a ser 00:04:38
la vuelta que nos da un jOptionPane 00:04:40
con el showInputDialog que le ponemos 00:04:44
introduzca 00:04:52
nombre 00:04:55
fichero, destino 00:04:57
bueno, pues sobre este fichero 00:04:59
vamos a escribir 00:05:11
vale, pero ahora 00:05:12
sobre todo 00:05:14
lo que nos importa es 00:05:17
crear una estructura 00:05:19
dinámica, una estructura de este tipo 00:05:21
por ejemplo 00:05:23
una release, esta misma 00:05:33
una estructura dinámica 00:05:34
con todos los objetos file que se van a unir. 00:05:38
Porque una vez que tengamos una estructura dinámica 00:05:43
con todos los objetos file que se van a unir, 00:05:45
se tratará de recorrerla y abrimos para leer 00:05:49
y escribimos en el otro. 00:05:53
Y este primero lo cerramos. 00:05:55
En la siguiente iteración sobre el list, 00:05:57
abrimos el siguiente y seguimos escribiendo en el otro 00:05:59
que se abrió para escribir al principio de todo. 00:06:02
Luego, una vez que tengamos esta estructura 00:06:05
con los ficheros a unir es un bucle que itere por el file 00:06:07
y lea cada uno de ellos y escriba el otro 00:06:10
y ya está, pero claro, tenemos que conseguir 00:06:13
todos esos files, bueno 00:06:16
pues no es tan difícil porque tendremos que 00:06:18
listar todos los ficheros que estén 00:06:21
en el directorio en el que se supone que estamos trabajando 00:06:24
no nos lo especifica, nos supone que estamos trabajando en la raíz del proyecto 00:06:27
para que no sea, de todos esos ficheros 00:06:30
ir cogiendo aquellos cuyo nombre 00:06:33
siga este patrón 00:06:37
empieza con lo que hay en área de texto 00:06:38
continúa con 00:06:41
un numerito y tiene como extensión 00:06:43
ptr 00:06:45
pues venga, vamos a hacerlo primero esto 00:06:46
vamos a listar 00:06:48
todos los 00:06:53
ficheros que están 00:06:55
en el directorio de trabajo 00:06:56
ala, esto mismo que he hecho 00:07:04
esta línea que he hecho, lo he hecho sobre una línea 00:07:11
no os agobia, o sea, new file 00:07:13
recordad que el punto 00:07:15
es el directorio actual de trabajo 00:07:18
el punto siempre significa el directorio actual de trabajo 00:07:21
que en nuestro caso es la raíz del proyecto 00:07:23
vale 00:07:25
entonces 00:07:27
a la vez que instancio ese objeto file 00:07:28
en lugar de guardar una referencia aparte 00:07:31
y luego esa referencia 00:07:33
hacer ya list files para que me dé todos los ficheros que tiene 00:07:34
pues no lo guardo en una referencia aparte 00:07:37
ya directamente le hago list files 00:07:40
y ya recordad que este método 00:07:41
que lo hemos usado alguna vez 00:07:43
nos da un array con todos los objetos file 00:07:44
que está en esa ubicación 00:07:47
vale, pues ahora habrá que ir 00:07:49
uno por uno y todos aquellos 00:07:52
que sean ficheros 00:07:54
y cuyo nombre 00:07:55
empiece con la raíz común 00:07:56
continúe con un número y tenga extensión 00:07:59
ptr, pues todos esos se van a la estructura 00:08:03
file 00:08:05
bueno, no, estos son todos los que hay en la carpeta 00:08:05
todos 00:08:12
pero tengo que 00:08:13
meter en el list de arriba los que me interesan 00:08:15
vale, pues 00:08:18
entonces, esto ahora ya 00:08:19
podemos hacer, vamos a ir uno por uno 00:08:21
para cada objeto file 00:08:23
en este listado de 00:08:31
ficheros, para cada objeto file 00:08:35
¿qué tenemos que hacer? 00:08:37
si cumple la condición 00:08:40
que 00:08:42
necesitamos y es que su nombre responde 00:08:44
al patrón correspondiente 00:08:46
si la cumple se va al listado de arriba 00:08:47
entonces 00:08:50
esto si que vamos a sacarlo, método aparte 00:08:51
por comodidad, entonces podemos hacer 00:08:53
validar nombre 00:08:55
de f 00:09:03
pues si validara el nombre 00:09:04
entonces es uno de los ficheros a unir 00:09:07
ficheros unir 00:09:09
punto ad f 00:09:11
bueno vamos a ponerle antes y si es fichero 00:09:12
porque puede ser directorio porque list file 00:09:18
me saca todo lo que hay dentro de 00:09:20
esto sean directorios 00:09:22
sean ficheros entonces puedo ser primero 00:09:24
punto isFile 00:09:30
y además 00:09:33
de ser fichero 00:09:37
vale, pues este bucle está claro 00:09:38
lo que hace, se va 00:09:59
a todos y cada uno de los ficheros 00:10:00
que están contenidos en el 00:10:03
directorio de trabajo 00:10:05
si son ficheros 00:10:07
y además su nombre 00:10:09
valida, que todavía no hemos hecho el método de validar 00:10:11
añádelo como fichero a unir 00:10:13
a la estructura de fichero a unir 00:10:15
que está arriba, entonces este método 00:10:17
validar, vamos a tener que hacerlo 00:10:22
vamos a tener que hacerlo 00:10:23
pues por ejemplo vamos a hacerlo 00:10:26
aquí 00:10:27
static boolean 00:10:32
validar 00:10:42
está sin hacer, con lo cual 00:10:45
un retunfalse, porque ahora mismo está sin hacer 00:10:50
ahora mismo subimos que no valida ninguno 00:10:52
vale 00:10:53
tendremos que meter ahora aquí el código 00:10:55
para ver si este fichero 00:10:58
su nombre cumple la condición que queremos 00:11:00
venga 00:11:02
validar 00:11:04
vale 00:11:10
y estamos 00:11:11
en este evento 00:11:13
en cual estamos aquí 00:11:16
vale, pues entonces seguimos 00:11:18
nos falta reinar este huequito 00:11:23
claro, como validar el nombre de ese fichero 00:11:25
una vez que se fuera terminado 00:11:26
ya tenemos en esta 00:11:28
estructura de arriba 00:11:31
todos los ficheros a unir, pues ahora lleven 00:11:32
la parte fácil, que es recorrerlos 00:11:34
abrirlos para leer y escribir en el 00:11:36
de destino. El de destino 00:11:39
su nombre, ¿dónde está? Aquí. 00:11:41
Pues este vamos a abrirlo para escribir. 00:11:43
Pues entonces 00:11:46
nos abrimos 00:11:46
este. 00:11:48
Fichero destino. 00:12:00
Y un try-cash 00:12:06
dentro del cual metemos 00:12:07
todo lo demás. Vale, ahora 00:12:09
ya sí que hay que hacer un bucle que vaya recorriendo 00:12:17
los ficheros a unir. 00:12:19
Pues para cada fichero 00:12:21
F dentro de 00:12:23
ficheros a unir, ¿qué hay que hacer? 00:12:25
lo abrimos como lectura, hacemos un bucle que lo lea hasta el final 00:12:33
y cada carácter leído se envía aquí 00:12:37
pues venga, lo abrimos como lectura, nos metemos en el bucle 00:12:40
de lectura de toda la vida, para leer el fichero enterito 00:12:55
while n, siendo n que 00:12:59
pues siendo n el resultado de haber leído de este 00:13:05
sea diferente de menos uno 00:13:10
pues ¿qué tenemos que hacer mientras sea diferente de menos uno? 00:13:15
escribirlo en el otro 00:13:19
ya está, cuando este while ha terminado 00:13:20
ya hemos leído ese fichero que lo cerramos 00:13:29
entonces este for va fichero por fichero 00:13:32
lo abre para leer, lo lee entero y lo manda al de destino 00:13:44
y así todos uno tras otro 00:13:47
cuando el bucle for ha terminado 00:13:50
ya hemos escrito todos, con lo cual 00:13:52
este último ya lo podemos cerrar 00:13:55
cuando el bucle fuera terminado 00:13:57
ya hemos leído todos los que había que unir 00:14:00
los hemos mandado al de destino 00:14:03
pues ya cerramos el de destino 00:14:04
ya están todos unidos en el de destino 00:14:06
lo único que nos falta ahora es 00:14:12
este método 00:14:17
que seleccione solamente 00:14:18
los ficheros cuyo nombre responde al patrón 00:14:21
correspondiente, ya está 00:14:23
bueno, lo que hemos hecho está claro 00:14:25
para poder probarlo vamos a 00:14:49
completar validar, porque ahora 00:14:53
si lo probamos no va a seleccionar ningún fichero 00:14:54
porque todo sale en falso, así que 00:14:56
vamos a hacer 00:14:58
el método validar 00:15:01
el método validar tiene que quedarse 00:15:02
con el nombre del fichero y ver 00:15:06
si valida 00:15:08
string 00:15:09
nombre 00:15:12
igual a f.getName 00:15:13
este es el nombre 00:15:16
entonces hay que ver 00:15:18
si la primera parte del fichero es igual 00:15:21
a la raíz que me han dado, entonces la raíz que me han dado estaba 00:15:26
a ver si no nos perdemos con validar 00:15:30
se supone que estaba en este, que es texto raíz 00:15:34
en texto raíz, aquí está 00:15:36
pues entonces en validar 00:15:40
string la raíz 00:15:48
Está en 00:15:53
Texto raíz 00:15:54
Punto get 00:15:57
Text 00:15:59
Y texto raíz 00:16:03
Ah, vale, sí 00:16:06
No me lo coge 00:16:12
Porque claro, no está declarada 00:16:14
Como estática 00:16:16
Vale, vamos a pasarle 00:16:18
Al botón validar 00:16:30
El fichero y el 00:16:32
Y la raíz 00:16:34
La vamos a pasar 00:16:36
Así no la tenemos que coger aquí 00:16:38
entonces la raíz se la vamos a pasar 00:16:39
sí, pero porque 00:16:43
lo tendrás de cara a otro sitio, lo habrás puesto 00:16:49
como estática, pero yo no quiero 00:16:51
o el método, porque el método 00:16:52
lo has puesto, igual no lo has sacado 00:16:55
de la clase, sino que lo has hecho en la clase interna 00:16:57
depende de donde lo hayas colocado 00:16:59
claro, pero es que yo lo he sacado fuera 00:17:00
pero bueno 00:17:03
déjalo como lo tienes si quieres, entonces 00:17:04
mi validar 00:17:07
que está aquí 00:17:09
a mi validar le voy a pasar 00:17:10
la raíz, que es texto 00:17:13
raíz punto 00:17:16
de text 00:17:18
vale 00:17:20
a validar le paso 00:17:21
el fichero y la raíz 00:17:26
común para que se ponga a validar 00:17:28
pues venga 00:17:30
ahora ya me voy otra vez aquí 00:17:30
vale, pues entonces tenemos que ver 00:17:33
aquí donde 00:17:39
ahí 00:17:47
al método validar lo he cambiado para que reciba 00:17:47
dos parámetros, el fichero del cual tiene que validar nombre 00:17:51
y la raíz que tiene que comprobar 00:17:53
que está en el nombre y eso está en el text field 00:17:57
del área de texto, por eso lo he puesto ahí 00:18:00
vale, pues nos vamos aquí abajo 00:18:02
y ahora ya 00:18:07
ahora ya esto lo podemos validar, pues bueno, vamos a ver 00:18:10
por ejemplo, el nombre 00:18:13
es un string y la clase string tiene un montón 00:18:17
de métodos útiles que hemos mirado en su momento 00:18:20
por ejemplo, tiene el método 00:18:22
substring 00:18:24
o incluso 00:18:25
este nos es más útil, el startsWith 00:18:30
este solo por el nombre nos viene muy bien 00:18:31
que es, si empieza 00:18:34
con, entonces este 00:18:36
te dice 00:18:38
si el string 00:18:40
este empieza con lo que tú le des 00:18:41
vale, pues entonces 00:18:44
si empieza con 00:18:46
raíz 00:18:51
esta ya 00:18:52
tiene la primera validación hecha 00:18:55
¿verdad? por ejemplo 00:18:56
validación una 00:19:01
que empiece 00:19:07
con el texto de la raíz 00:19:09
entonces 00:19:11
igual que tiene un startsWith es probable que tenga 00:19:13
un end, porque si tuviera 00:19:15
un método endsWith 00:19:17
pues estupendo 00:19:19
termina con .ptr 00:19:20
pues si termina con .ptr 00:19:23
ya tenemos la otra validación 00:19:29
vale 00:19:31
si las dos 00:19:37
son válidas 00:19:41
está empezando con la raíz que está ahí 00:19:41
y además está terminando con PTR 00:19:44
entonces 00:19:46
ahora la otra validación es más rara 00:19:48
porque hay que ver que entre la raíz 00:19:50
y PTR todo lo que hay son cifras 00:19:52
decimales, numeritos 00:19:54
todo lo que hay son cifras decimales 00:19:56
entonces aquí 00:19:57
nos tendríamos que quedar 00:19:58
con la subcadena 00:20:01
comprendida entre raíz y PTR 00:20:03
ir carácter por carácter 00:20:06
viendo si esos caracteres están todos comprendidos 00:20:08
en la tabla ASCII entre el 0 y el 9 00:20:10
vale, venga, vamos a ver, es un poco retorcido 00:20:11
yo creo que Estefano tenía en mente 00:20:14
validar números de diferentes 00:20:16
cifras, solo de una, pero vamos a hacerlo 00:20:18
vale, pues ahora ya sí que nos podemos 00:20:20
quedar con 00:20:22
hay un método 00:20:23
substring para extraer subcadenas 00:20:26
si uno cotilla aquí los 00:20:28
métodos, pues tenemos 00:20:30
el método substring 00:20:32
que le dices 00:20:33
una posición inicial 00:20:36
y una posición final 00:20:38
y te da la subcadena comprendida en esas posiciones 00:20:40
entonces 00:20:43
aquí lo único que hay que fijar 00:20:44
la posición que hay que darle 00:20:46
porque 00:20:48
de substring empieza 00:20:50
a donde le digamos 00:20:53
begin index 00:20:54
entonces hay que darle el tamaño de raíz 00:20:55
y termina 00:20:59
hasta end index 00:21:01
menos uno 00:21:02
que será la longitud de la cadena 00:21:03
menos los cuatro caracteres 00:21:06
de ptr 00:21:09
O sea, yo creo 00:21:09
Así a voz de pronto 00:21:11
Pero bueno, habría que probarlo 00:21:13
Esto sería 00:21:14
Raíz punto length 00:21:17
Y luego sería 00:21:21
Nombre punto length 00:21:23
Menos 4 00:21:28
Quitándole las posiciones 00:21:30
De punto ptr que son 4 00:21:31
Pero vamos a hacer la prueba 00:21:33
Que no la vas a hacer 00:21:39
No la vas a hacer por hacer cosas raras, ¿verdad? 00:21:42
y ahora 00:21:45
vamos ahora simplemente 00:21:51
que muestre 00:22:06
la subcadena 00:22:07
y ahora vamos 00:22:10
a rápidamente 00:22:20
hacer un 00:22:21
main de prueba, muy rápido 00:22:24
prueba, vale 00:22:25
entonces voy a copiar 00:22:42
este de validar aquí para hacer 00:22:44
así la prueba. Y ahora voy a llamar a este método de validar, pasándole un objeto file 00:22:46
con un nombrecito datos98.ptr y pasándole como raíz datos. Y ahora vamos a ver si este 00:23:04
System.out me muestra 98 00:23:24
Porque si no me muestra 00:23:26
98, tengo que mover 00:23:28
Hacia más 1 00:23:30
O menos 1, alguno de estos 00:23:32
Vamos simplemente a ejecutar este 00:23:33
Main, a ver, que me muestra 00:23:36
98, bueno, le hemos clavado 00:23:38
A la primera, vale 00:23:44
Vale, el substring, entonces 00:23:46
Empieza aquí y acaba aquí 00:23:50
Entonces, si le paso 986 00:23:52
A ver 00:23:54
clavado, bueno, bueno 00:23:55
somos muy listos, venga 00:23:58
ya está, pues entonces 00:24:00
nos vamos aquí 00:24:02
ahora ya efectivamente esta es 00:24:03
la subcadena que tiene lo que está entre la 00:24:06
raíz y el ptr, pues vamos a ver 00:24:08
si todas las cifras que tiene son 00:24:10
caracteres decimales 00:24:12
pues ahora ya 00:24:13
boolean 00:24:15
valid 3 00:24:19
igual a true 00:24:21
lo más complicado es la validación 00:24:24
Esto es una locura que no podríamos 00:24:26
En un examen 00:24:28
Y ahora ya sí que vamos a recorrer 00:24:29
Para cada int 00:24:32
Y igual a cero 00:24:35
Mientras y sea menor que 00:24:36
Subcadena.length 00:24:38
Incrementando 00:24:42
Igual a 00:24:59
Valir 3 00:25:00
And 00:25:02
Subcadena.length 00:25:03
char add i 00:25:16
para ver si esto es 00:25:18
dígito, vamos a ver la tabla 00:25:21
ASCII 00:25:23
ahora cuando esté todo escrito lo vais a 00:25:24
entender 00:25:27
bien 00:25:28
en la tabla ASCII 00:25:30
ASCII 00:25:33
vale, los números están 00:25:35
entre el 00:25:43
48 y el 00:25:45
57, luego 00:25:47
48 y 57 00:25:48
luego esto entonces 00:25:50
char add i 00:25:53
mayor o igual que 48 00:25:54
subcadena 00:26:00
punto 00:26:02
char add i 00:26:05
53 hemos dicho 00:26:07
menor o igual que 57 00:26:12
pues esta es la validación 3 00:26:15
que es liosa de entender 00:26:22
porque vamos, sobre un true inicial 00:26:23
vamos concatenando los and 00:26:26
de que cada char 00:26:28
sea un dígito 00:26:30
¿veis? los vamos 00:26:32
haciendo una concatenación acumulativa 00:26:34
de ands, entonces cuando 00:26:36
alguno ya no sea dígito 00:26:37
este and ya me va a dar 00:26:39
falso, pero si todos fueran 00:26:42
dígitos, todos fueran dígitos 00:26:44
yo a este valid3 inicial true 00:26:45
le estoy concatenando todo el tanto and true 00:26:47
entonces al final sería true 00:26:49
en cuanto uno de estos no sea dígito 00:26:51
este and 00:26:54
concatenado, acumulado, ya va a dar 00:26:56
falso, entonces cuando este for 00:26:58
ha terminado, que este for termina aquí 00:27:00
tengo dos opciones, que valid 3 00:27:02
siga siendo true, porque todo lo que he concatenado 00:27:04
sobre él es true, true, true, true 00:27:06
o que sea falso, porque alguno de los que he concatenado 00:27:07
no fue dígito, entonces 00:27:10
esta ya es la validación 3, luego si pasa 00:27:11
la 1, que es que empiece con raíz 00:27:14
pasa la 2, que acabe con ptr 00:27:15
y pasa la 3, que es que todo lo que 00:27:17
esté entre raíz y ptr sean dígitos 00:27:19
pues entonces ha pasado la total 00:27:21
pues entonces ahora ya le tenemos que devolver 00:27:23
return valid1 00:27:25
and 00:27:27
valid2 and 00:27:31
valid3 00:27:37
este es el método 00:27:40
validar, vale pues 00:27:41
esto es programar en realidad 00:27:45
esto, hacer estas cositas 00:27:47
bueno pues ya 00:27:53
aparentemente tenemos este método de validar 00:27:59
correcto 00:28:01
si el fichero 00:28:02
ahora ya nos podemos ir a nuestro 00:28:05
evento otra vez 00:28:08
que era listamos todos los 00:28:09
ficheros 00:28:13
si son ficheros y validan 00:28:14
los añadimos a la estructura 00:28:17
y ahora ya recorremos la estructura 00:28:19
para irlos leyendo y escribiendo 00:28:21
vamos a probarlo 00:28:23
así de buenas a primeras es un poco 00:28:25
complicado, ahora yo voy a intentar unir 00:28:27
todos esos que hice 00:28:29
Que empezaban con datos 00:28:31
Que empezaban con datos 00:28:33
Pues voy a intentar unir todos estos 00:28:34
A ver si hay suerte 00:28:38
Y no salen errores 00:28:39
Pero bueno, es raro 00:28:41
Que no la hayamos liado en alguna cosa 00:28:43
Venga 00:28:47
Merge, raíz de los ficheros a unir 00:28:50
Datos, ¿no? Se llamaban los míos 00:28:52
Creo, con minúscula 00:28:55
Sí, datos 00:28:56
Datos 00:28:57
Y este 00:29:05
¿Qué te está pasando? 00:29:06
A ver 00:29:16
A ver, vamos a probar esto 00:29:17
Y si eso, me subes tú este 00:29:20
Y lo miro aquí 00:29:22
Venga, datos, los que empiezan por datos 00:29:23
Merge 00:29:25
Nombre de fichero destino 00:29:28
Pues todos 00:29:30
Se va a llamar todos 00:29:32
Y ahora al darle a aceptar 00:29:33
a saber que sale aquí, que pasa aquí 00:29:35
esto ya era mucho 00:29:37
que a la primera no salir era mucho pedir 00:29:40
entonces 00:29:41
nos hemos pasado 00:29:43
datos 5, 4 00:29:48
para length 8 00:29:50
a ver en algún 00:29:51
momento cuando he hecho un substring o algo 00:29:54
de eso 00:29:55
me he pasado 00:29:56
aquí, vamos a ver 00:29:59
vale, hacer la subcadena 00:30:01
pero 00:30:05
datos 00:30:06
si es fichero 00:30:09
ah claro, a ver, es que esta validación 00:30:13
de aquí, solo tiene sentido 00:30:15
que la haga si ha pasado las anteriores 00:30:17
porque si no ha pasado las anteriores 00:30:19
el fichero a lo mejor se llama O 00:30:21
entonces si se llama O, no puedo hacer yo 00:30:23
hacer un substring con 4 00:30:25
con ptr, entonces esta validación 3 00:30:27
solo tiene sentido hacerla 00:30:29
si ya ha pasado la 1 y la 2 00:30:31
si no tiene sentido hacerla 00:30:32
vale, entonces 00:30:34
Si no valida 00:30:38
Si no valida la primera 00:30:43
No valida la segunda 00:30:46
Ya está, retum falso 00:30:49
Y se acabó 00:30:52
Porque una de las dos 00:30:55
No la ha validado, o la primera o la segunda 00:30:57
Entonces si valida las dos 00:30:59
Ahora ya ha sido 00:31:02
Vale, pues venga 00:31:03
Siguiente intento 00:31:05
Venga, raíz de los ficheros a unir 00:31:14
datos, merge, todos, aceptar, vamos a ver si me ha hecho un todos por ahí, aquí está 00:31:16
mi todos, entonces vamos a ver qué tamaño tiene, que eso ya nos da una pista, 24.926, 00:31:36
todos 00:31:49
a ver 00:31:56
ha unido estos 00:31:57
a ver si yo pudiera 00:32:00
voy a copiarlo y pegarlo 00:32:03
y abrirlo con Word porque esos venían de partir 00:32:05
un Word, entonces 00:32:07
a ver 00:32:08
donde lo tengo 00:32:11
aquí 00:32:28
cambiar nombre 00:32:28
pero los bytes no me suena que estén bien 00:32:32
entonces 00:32:37
vale 00:32:38
no parece el mismo 00:32:44
fichero del que dividí 00:32:47
entonces 00:32:48
repito, ahora que ya hemos entendido la aplicación 00:32:50
hemos visto como hacerla 00:33:01
vamos simplemente a cambiar la clase 00:33:02
file-reader-file-writer por file-input-stream 00:33:05
file-output-stream para que se quede 00:33:07
como la haríamos en original 00:33:09
con esa clase básica que mueve el byte tal cual 00:33:11
porque el fichero puede tener cualquier cosa 00:33:13
no tengo por qué interpretar yo que sea un char 00:33:15
entonces simplemente 00:33:17
voy a cambiar aquí 00:33:18
cada file reader 00:33:20
y cada file writer 00:33:23
claro 00:33:30
lo voy a cambiar por la clase con la que lo haríamos 00:33:32
pero repito que esto lo subo 00:33:34
luego todo por si alguien 00:33:36
file output stream 00:33:38
queda como mejor 00:33:40
no es que quede mejor es que esta 00:33:42
esta clase te lee el byte directamente 00:33:44
sin darle ninguna interpretación 00:33:46
no es como file reader 00:33:48
que asume que es un char 00:33:48
entonces cuando tú haces el casting a char 00:33:51
te muestra algo con sentido 00:33:52
esta te coge el byte 00:33:55
y te lo lleva a la variable 00:33:56
esta de aquí tal cual 00:33:59
pues 00:34:00
en nuestro caso que estamos moviendo bytes 00:34:01
sin ninguna interpretación es como lo haríamos 00:34:05
vale pues entonces 00:34:07
este 00:34:09
se cambia 00:34:10
por inputStream 00:34:13
pues los métodos son iguales 00:34:14
todo es igual 00:34:17
file input string 00:34:17
ala, file output string 00:34:25
vale, esto ya lo tenemos 00:34:32
y ahora 00:34:34
este método de aquí 00:34:37
pues aquí lo mismo 00:34:39
en lugar de file 00:34:45
readder 00:34:48
file input string 00:34:48
y en lugar de file writer 00:34:51
file output string 00:34:54
y todo lo demás 00:34:57
igual 00:34:59
vale 00:35:00
y voy a probar ahora a dividir un word 00:35:17
a ver si luego al reconstruirlo me sale el word 00:35:19
entero otra vez 00:35:21
venga vamos a dividir 00:35:22
un word 00:35:28
cualquiera 00:35:29
este 00:35:30
lo vamos a dividir en 00:35:42
datos 00:35:48
vale 00:35:49
ahora vamos a ver 00:35:51
aquí están todos los datos 00:35:54
los 15 ficheros 00:35:59
y ahora voy a unirlos 00:36:01
a ver si el que me sale 00:36:02
fuera un 00:36:03
si Word lo interpretara, que debería 00:36:05
porque lo hemos movido sin más 00:36:08
vamos a ver 00:36:09
ejecutamos esto otra vez 00:36:11
y le decimos, vamos a hacer un 00:36:14
merg de todos los que se llaman datos 00:36:16
y donde lo vas 00:36:17
a guardar, en resul.docx 00:36:20
por ejemplo 00:36:24
y ya está 00:36:24
vale, entonces 00:36:29
refresh 00:36:31
vale 00:36:33
result doc x está aquí 00:36:37
este 00:36:40
voy a sacarlo fuera 00:36:43
copiar, pegar 00:36:44
hay, mete algún carácter 00:36:54
en algún momento que hace que luego 00:37:01
algún carácter que hace que ya sea elegible 00:37:03
para el Word, no sé muy bien 00:37:05
que 00:37:07
los permisos 00:37:08
no, no, permisos no son algún carácter 00:37:10
en algún momento 00:37:13
pero no debería porque estamos 00:37:14
cogiendo los 00:37:18
estamos, es que los bytes tal cual 00:37:19
los estamos poniendo en trocitos y luego pegándolos otra vez 00:37:23
no debería perder 00:37:25
no sé por qué no lo 00:37:26
no lo sé, se podría 00:37:28
indagar a ver por qué no reconstruye el Word igual 00:37:30
pero a ver, lo que 00:37:33
me importa ahora, bueno, es que hayáis 00:37:34
entendido la aplicación 00:37:37
a ver, un segundito 00:37:39
esto, vamos aquí 00:38:50
vale, pues aquí en el aula 00:38:56
virtual aquí abajo está 00:39:15
está todo lo que hemos hecho respecto a los enunciados anteriores que hay aquí arriba. 00:39:17
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:
6
Fecha:
7 de mayo de 2025 - 19:35
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
39′ 45″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
202.39 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid