Saltar navegación

Clase 21-05-24 - 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 25 de mayo de 2024 por Raquel G.

9 visualizaciones

Más información Transcripción

Descargar la transcripción

Vale, pues nuestra aplicación editor de texto era esta de aquí, que tenía un menú, tenía este menú de aquí, para abrir un nuevo fichero, perdón, crear un fichero nuevo, abrir un fichero, poniendo ahí el contenido de texto que tuviera, guardarlo, guardar como, cerrar, ahora ya podemos hacer todo esto con ficheros. 00:00:02
vale, entonces 00:00:37
vamos a 00:00:39
copiar este proyecto 00:00:40
en otro, para este no tocarle, que este estaba 00:00:43
con la versión de maps, los ficheros 00:00:45
estaban en realidad, eran una variable 00:00:47
string en un map 00:00:50
pues vamos a ver 00:00:50
si yo puedo 00:00:53
a ver si aquí fuera tan listo de hacerme 00:00:55
un copiar 00:01:03
y pegar con otro nombre, yo creo que va a ser 00:01:07
sí, aplicación 00:01:09
editor de texto 2 00:01:11
Vale, pues aquí la tenemos 00:01:12
Editor de texto 2 00:01:29
Bueno, pues ¿dónde estaban nuestros ficheros en este caso? 00:01:30
Estaban aquí 00:01:39
No había ficheros en realidad como tal 00:01:40
Nuestras unidades de trabajo, nuestros ficheros 00:01:43
Eran cadenas 00:01:46
Que estaban guardadas en un map 00:01:47
Este era su contenido 00:01:51
Y este era su nombre 00:01:53
este era su contenido y su nombre 00:01:55
ahora no necesitamos esta clase, ya no necesitamos 00:01:57
porque nuestros ficheros están en el sistema 00:02:00
de archivos con el nombre que sea 00:02:02
esto ya no le necesitamos esta clase 00:02:03
en absoluto 00:02:06
bueno pues entonces 00:02:08
de nuestra aplicación editor de texto 2 00:02:10
todo este paquete de ficheros 00:02:12
ya directamente fuera 00:02:14
no nos hace falta esa clase, nuestros ficheros 00:02:15
están ahora en nuestro sistema de archivos 00:02:18
cada uno con su nombre 00:02:20
vale, y ahora ya si 00:02:21
nuestro editor de texto habrá que cambiar 00:02:25
las funcionalidades. 00:02:27
Ahora, 00:02:30
nuestro editor de texto 00:02:31
tenía 00:02:32
una etiqueta, perdón, una referencia 00:02:34
que era el nombre del archivo 00:02:37
con el que estábamos siempre trabajando. 00:02:39
El nombre del archivo que estaba abierto, 00:02:41
que habíamos creado nuevo, 00:02:43
el nombre del archivo que en ese momento estaba en el editor. 00:02:45
Bueno, pues eso nos sigue valiendo. 00:02:48
El nombre del archivo que está en ese momento 00:02:50
en el editor. Ahora, ¿qué es lo que va a cambiar? 00:02:51
ahora lo que va a cambiar es los eventos 00:02:53
¿no? ahora ya 00:02:56
pues cuando le demos a 00:02:58
a nuevo 00:03:00
pues no creará un nuevo 00:03:03
estrinometra en el map, no, tendrá que 00:03:05
crear un nuevo archivo y dejarlo ahí 00:03:07
abierto para escribir lo que 00:03:09
fuera, entonces los eventos cambiarán 00:03:11
eso lo único que cambiará, pues venga 00:03:13
vamos a hacer algunos, por ejemplo el de 00:03:15
abrir un archivo, vamos a hacer el de 00:03:17
abrir, vamos a 00:03:19
abrir un archivo de nuestro sistema de archivos 00:03:21
El evento de abrir 00:03:23
Estaba 00:03:25
Aquí 00:03:28
Era este 00:03:29
Vale, pues entonces 00:03:33
Opción nuevo 00:03:37
Vamos a hacer primero la opción abrir 00:03:42
Que es más fácil de entender 00:03:44
Opción abrir 00:03:45
Pues venga, solicitamos nombre de archivo 00:03:47
Pues ya está 00:03:49
El nombre de archivo 00:03:51
Lo cogíamos de 00:03:53
Aquí 00:03:57
introduzca nombre de archivo del jActionPanel 00:03:59
vale 00:04:04
y ahora 00:04:04
ahora 00:04:06
¿cómo podemos cambiar esto? 00:04:12
para que quede más profesional 00:04:14
en lugar de pedir el nombre de archivo 00:04:16
¿no teníamos un jFileChooser 00:04:18
que nos permite seleccionar 00:04:21
un nombre de archivo directamente? 00:04:23
en lugar de ponérselo a mano 00:04:25
pues sí, entonces vamos a cambiar 00:04:26
esto 00:04:28
por un jFileChooser 00:04:29
Que se abra 00:04:31
Y nos permita elegir el nombre del archivo 00:04:33
Que queremos abrir 00:04:35
¿No? 00:04:36
Vale, pues entonces todo esto se va afuera 00:04:39
¿Vale? Solitar el nombre del archivo 00:04:41
No lo vamos a hacer así 00:04:43
Lo vamos a hacer con un objeto file chooser 00:04:44
Que esto como funcionaba 00:04:46
Pues hacíamos 00:04:48
Un jfilechooser de estos 00:04:51
Este 00:04:53
Si me acordáis en que ejercicio está 00:04:55
Para hacer el 00:04:57
Copia y pega 00:04:58
Y así tardamos menos 00:05:01
Porque este no sé si se podía instanciar 00:05:02
Con el constructor así vacío 00:05:06
Sí, tenía un constructor 00:05:08
Entonces instanciábamos el objeto 00:05:12
Y ahora el JFileChooser este 00:05:14
Tenía para abrir la ventanita 00:05:16
ShowOpen 00:05:19
Esta de aquí 00:05:20
OpenDialog 00:05:21
Vale 00:05:24
Si le poníamos null es que asociado al frame 00:05:25
Y ahora 00:05:32
este nos devolvía en un int 00:05:33
si le habíamos dado a abrir o a cancelar 00:05:35
creo recordar 00:05:38
y ahora 00:05:41
la opción 00:05:45
es igual 00:05:47
punto 00:05:51
a proof option 00:05:59
a la opción 00:06:01
de aceptar 00:06:05
de abrir, sería esta 00:06:08
pues entonces ahora ya que tenemos 00:06:10
recogemos el nombre del archivo 00:06:12
el nombre del archivo, entonces el nombre del archivo 00:06:13
estaría aquí 00:06:16
tendría un get, ¿no? 00:06:19
o como era esto 00:06:22
get selected 00:06:23
get 00:06:36
podría ser, pero 00:06:37
no recuerdo 00:06:43
get selected file, ese justo 00:06:45
vale 00:06:47
y esto lo ponemos en nombre 00:06:49
GetSelectedFile 00:06:50
Pero esto no te lo devolvía en 00:07:00
Streams, sino... Ah, te lo devolvía 00:07:01
En File, vale 00:07:03
Entonces 00:07:04
Directamente te lo devuelve ya en 00:07:06
ObjetoFile, con lo cual ya podemos cambiar 00:07:09
Por lo tanto lo que nos interesa ahora 00:07:11
Es esto 00:07:13
File e importamos 00:07:16
Vale, pues ya hemos hecho 00:07:18
Con el FileChooser hemos abierto una ventanita 00:07:26
Y hemos cogido el 00:07:28
ObjetoFile que nos ha devuelto como 00:07:30
Que es el que hemos seleccionado nosotros 00:07:32
y lo hemos guardado aquí 00:07:34
ese es el fichero a abrir 00:07:36
y ahora que tenemos que hacer con él 00:07:38
entonces este do while era 00:07:39
mientras no 00:07:42
mientras no escribas uno que exista 00:07:43
este do while ya no existe 00:07:47
porque lo estamos seleccionando con un file chooser 00:07:48
entonces este do while ya es que no hace ninguna falta 00:07:50
vale pues entonces 00:07:53
ya tenemos 00:07:58
el fichero seleccionado 00:08:00
para abrir en file 00:08:02
ahora nuestro archivo de trabajo 00:08:03
El que ahora se queda abierto 00:08:05
Nuestro archivo de trabajo 00:08:07
Pues 00:08:08
Ahora 00:08:10
Nuestro archivo de trabajo 00:08:11
Ahora tiene mucho más sentido 00:08:18
Que en lugar de guardarlo 00:08:20
En nombre 00:08:23
Que está aquí 00:08:25
Este sea un file 00:08:26
Nuestro archivo de trabajo 00:08:28
Que sea un file, ya tenemos la clase file 00:08:31
Que sea un file 00:08:32
Y ahora ya nuestro archivo de trabajo 00:08:33
Se convierte en 00:08:38
Opción abrir 00:08:40
Se convierte en este 00:08:41
Vale 00:08:44
Ahora nos toca ponerlo en la etiqueta 00:08:45
Ahora ya 00:08:48
Esto era para poner el texto del archivo en la etiqueta 00:08:49
En el text field 00:08:54
Eso lo quitamos 00:08:55
Y esto era para poner el nombre del archivo en la etiqueta nombre archivo 00:08:56
Aquí tendremos que poner 00:09:00
Esto.getName 00:09:02
Este es el objeto file 00:09:03
Y ahora que nos falta aquí 00:09:07
Leer el archivo 00:09:08
Y poner su contenido en el área de texto 00:09:12
Es lo que nos falta 00:09:16
En el área de texto 00:09:17
Esto es lo que antes lo hacíamos 00:09:23
Cogiéndolo del map con el get 00:09:26
Lo cogíamos del map y lo plantamos en el área de texto 00:09:28
Porque el contenido estaba en el map 00:09:30
Ahora el contenido 00:09:32
Lo vamos a sacar abriendo el archivo para leer 00:09:33
Cogiendo los caracteres, etc 00:09:37
Pues venga, ahora ya vamos a leer del archivo 00:09:38
Entonces vamos a hacer un file 00:09:41
Reader 00:09:42
asociado a este archivo 00:09:44
que he cogido del file chooser 00:09:47
que se llama 00:09:49
nombre 00:09:56
o archivo trabajo porque he guardado uno en el otro 00:09:56
me da igual, vale 00:10:01
importamos 00:10:02
file reader, vale 00:10:04
ahora 00:10:10
vamos a concatenar sobre un string 00:10:12
todo el contenido de ese archivo 00:10:15
para luego plantarlo 00:10:17
en el área de texto 00:10:19
Y ahora ya sí que hacemos el bucle de lectura. 00:10:20
Mientras C, siendo C el resultado de leer del archivo sea diferente de menos 1, 00:10:30
¿qué hacemos? Concatenar sobre contenido. 00:10:41
Con suena contador. 00:10:48
Contenido más igual C. 00:10:52
ala, cuando este bucle ha terminado 00:10:55
ya podemos cerrar el 00:10:59
el file reader 00:11:01
y ahora ya nos falta ponerlo en el área 00:11:04
de texto, que el área de texto 00:11:07
no tenía que haberla borrado 00:11:08
porque ya no sé que área 00:11:10
se llama esta textarea 00:11:12
se llamará 00:11:14
un segundito que me encuentre 00:11:15
que estoy 00:11:18
en opción 00:11:21
estoy 00:11:25
opción abrir, estoy aquí, vale 00:11:30
a ver 00:11:33
que no he puesto 00:11:35
vale, vale, que he puesto 00:11:36
perdón, vale 00:11:42
vale, y ahora en text area 00:11:43
que se llamaba así 00:11:46
ponemos 00:11:48
el contenido que acabamos de leer 00:11:53
contenido 00:11:58
contenido 00:12:00
bueno, pues la opción 00:12:02
de abrir, ahora se transformaría en esto 00:12:09
cojo el file 00:12:11
con el file chooser 00:12:13
cojo el file seleccionado 00:12:14
leo su contenido 00:12:16
y una vez que tengo su contenido 00:12:18
lo coloco en el área de texto 00:12:20
y además fijo mi variable de fichero 00:12:21
con el que estoy trabajando 00:12:24
a ese, la fijo 00:12:25
para que luego en la opción de guardar 00:12:28
pues coja el área de texto 00:12:30
y eso se vaya sobre archivo en el que estoy trabajando 00:12:32
entonces para poder probarlo vamos a 00:12:34
comentar el resto de opciones 00:12:38
porque están mal, claro, porque siguen tirando 00:12:40
del map 00:12:42
Las vamos a comentar todas 00:12:42
Para poder ejecutarlo 00:12:45
La opción de abrir al menos 00:12:46
Vamos a comentar 00:12:49
El resto de opciones 00:12:51
La de guardar 00:12:54
La de nuevo 00:12:55
Que también 00:12:57
Tira de archivos 00:13:01
Con lo cual 00:13:07
Está mal 00:13:08
Vale 00:13:10
Entonces 00:13:11
La de nuevo está comentada 00:13:13
La de abrir es la que acabamos de hacer 00:13:15
La de guardar 00:13:17
Está comentada 00:13:22
La de guardar como también hay que comentarla 00:13:24
La de cerrar 00:13:27
Era ponerlo todo a nulo 00:13:40
Así que esta nos vale 00:13:41
Y luego venían las utilidades 00:13:42
Y me sigue quedando algo aquí 00:13:44
Las excepciones 00:13:48
Ahora ya tengo las excepciones 00:13:50
Estas de aquí 00:13:53
Entonces como estoy en una acción perform 00:13:54
Aquí no tiene sentido que yo haga un throws 00:13:57
Y le ponga el throws a la acción perform 00:13:59
vale, no tiene sentido 00:14:02
es que este método no debería tocarlo 00:14:04
entonces aquí vamos ya a capturar 00:14:07
vamos ya a capturar 00:14:09
y vamos a meter 00:14:11
esto en un try catch 00:14:13
veis, de hecho, ni me ofrece 00:14:19
la opción de throws, ni me la ofrece 00:14:21
pero es que estoy dentro de un método 00:14:22
del que tengo que respetar la cabecera 00:14:24
no puedo añadir en esa cabecera 00:14:26
lo que me dé la gana 00:14:28
vale, pues entonces 00:14:29
Ya hemos metido 00:14:31
Esto en un try catch 00:14:35
¿Vale? ¿Qué más? 00:14:36
Este también puede dar 00:14:39
Un, pues nada 00:14:41
A try catch también 00:14:43
Ala, y ese también 00:14:44
Pues a try catch 00:14:47
¿Y qué más tiene? 00:14:48
Error por ahí abajo 00:14:55
Ah, la opción está de nuevo 00:14:57
De aquí 00:15:00
Vale 00:15:02
y aquí arriba esto que ya no existe 00:15:15
esto ya no existe porque he borrado ese paquete 00:15:19
entonces ahora ya la aplicación solamente tiene 00:15:22
funcionalidad la parte del menú de abrir 00:15:25
es la unidad que tiene, que es esta 00:15:28
cuando le demos la de abrir 00:15:30
es la unidad que tiene funcionalidad, el resto no van a hacer nada 00:15:34
porque están todas comentadas 00:15:37
y la única funcionalidad que tiene la de abrir es esto 00:15:38
mediante el file chooser nos permite seleccionar un objeto file 00:15:41
que guardamos aquí, ese objeto file 00:15:45
lo fijamos este como mi archivo de trabajo 00:15:47
a partir de ese momento 00:15:49
para luego las opciones 00:15:51
de guardar 00:15:53
y ahora ya 00:15:54
leemos el contenido 00:15:57
colocamos el área de texto 00:15:59
y listo 00:16:01
venga, pues vamos a 00:16:03
ejecutar el editor de texto 00:16:05
a ver 00:16:07
venga, vamos a abrir uno 00:16:09
pues venga, vamos a abrir 00:16:14
El escritorio 00:16:16
Tengo aquí alguno de texto 00:16:20
Pruebas, ficheros 00:16:22
Ahí tenía uno de texto 00:16:23
A abrir 00:16:24
¿Esto es lo que tenía en el fichero de texto? 00:16:25
Y me pone aquí el nombre, fichero de texto 00:16:32
Pues tiene toda la pinta de que es muy raro 00:16:34
Que tuvieras en el fichero de texto 00:16:36
Vamos a ver 00:16:37
No lo tengo, ¿qué es lo que ha pasado? 00:16:38
Que no he hecho la conversión 00:16:46
Achar 00:16:47
recordáis que el rea te lee como int 00:16:49
vale, entonces 00:16:51
aquí 00:16:53
cuando contenido 00:16:54
más, vamos a 00:16:57
ahí 00:16:59
yo leo, me lo guarda como entero 00:17:03
lo concateno 00:17:05
lo convierto en char y ya voy concatenando 00:17:07
en contenido que empieza habiendo cero, etc 00:17:09
entonces vamos a poner aquí 00:17:11
un contenido 00:17:13
que se entienda para 00:17:14
a ver 00:17:17
Vamos a ver este archivo si me lo abre el editor nuestro 00:17:22
Este fuera 00:17:25
Vale, pues venga, abrimos 00:17:27
Nos vamos al escritorio 00:17:39
Este, este 00:17:44
Le damos a abrir 00:17:46
Y ahora pues ya me abre el archivo y es este 00:17:49
Vale 00:17:52
Luego podemos implementar nuestra opción de guardar 00:17:53
La de guardar, pues ¿cuál sería? 00:17:56
Pues abrir 00:17:58
El fichero de trabajo 00:18:00
Que es este, abrirlo ahora como file writer 00:18:02
Y escribirle 00:18:05
Esto, y ya está 00:18:06
O sea, yo aquí ya escribo lo que sea 00:18:08
Y ahora cuando le de a guardar 00:18:10
Ahora mismo 00:18:13
Esto no hace nada 00:18:15
Pero que tendría que hacer simplemente 00:18:15
El archivo de trabajo 00:18:18
Abrirlo con el file writer 00:18:20
Y mandarle todo este text area 00:18:21
Y mandárselo 00:18:24
y ya está 00:18:25
sobre escribiendo lo que hubiera 00:18:26
y un mensajito pues ya está, se escribió en el archivo 00:18:28
cuando lo vuelva a abrir 00:18:30
pues volveremos a ver 00:18:32
que efectivamente se ha guardado el archivo, etc 00:18:34
entonces el resto de funcionalidades 00:18:36
pues son 00:18:39
sencillas de hacer 00:18:40
vale, las podéis completar 00:18:41
ya tirando de archivos 00:18:44
si queréis 00:18:46
bueno 00:18:48
dudas 00:18:56
preguntas 00:19:00
vale, pues quedaos con esas clases 00:19:03
FileReader, FileWriter, como se usan 00:19:08
BufferReader cuando quiero leer una línea 00:19:10
de golpe 00:19:12
y la clase 00:19:13
File, claro 00:19:16
vamos a hacer lo del listado recursivo 00:19:17
a ver, ¿lo habéis hecho? 00:19:21
y así probamos la 00:19:24
recursividad 00:19:25
venga, pues vámonos 00:19:26
otra vez a 00:19:30
ejemplos, entrada, salida 00:19:34
aquí 00:19:36
Venga, vamos a hacer un paquete aparte 00:19:43
Para no mezclar 00:19:52
Listado 00:19:53
Recur 00:19:55
El que tenía creado 00:19:57
Sí 00:20:03
Que podía en esa clase haber puesto ese método 00:20:08
Pero bueno, lo hago en una parte 00:20:11
Porque como la recursividad no es algo 00:20:12
Que os vayamos a preguntar 00:20:15
Pues bueno, para que no 00:20:16
Se quede mezclado con el resto 00:20:18
De las clases que sí son 00:20:20
Contenido que os tenéis que estudiar 00:20:22
pero realmente 00:20:23
salir de primero sin haber hecho un poquito 00:20:28
de recursividad, pues hombre, no es deseable 00:20:31
entonces, no está mal 00:20:33
que lo hagamos 00:20:35
pues venga, vamos a hacernos un proyecto cualquiera para meter ese método 00:20:36
y se acabó 00:20:39
listado recursivo 00:20:40
aquí, nueva clase 00:20:44
bueno, pues lo que son 00:21:04
recursivos 00:21:16
son los métodos o las funciones 00:21:16
dicho en términos generales 00:21:19
porque método es la terminología de Java 00:21:22
o en general de la programación orientada a objetos 00:21:25
para llamar a las funciones 00:21:28
pero la función es un concepto más amplio 00:21:29
una función es un trozo de código 00:21:31
que puede ser código de script de un sistema operativo 00:21:35
un trozo de código de SQL 00:21:37
un trozo de código recogido bajo un nombre 00:21:41
y uno lo llama cuando quiere con ese nombre y se ejecuta ese código 00:21:44
en términos generales es lo que significa función 00:21:47
y la programación de entrada de objetos a eso lo llama método 00:21:50
porque tiene la particularidad de que va metida en objetos 00:21:54
en declaraciones de clases 00:21:57
y lo que significa conceptualmente es que son cosas 00:21:59
que los objetos pueden ejecutar 00:22:03
es decir, es comportamiento de los objetos 00:22:05
entonces como tiene unas particularidades relacionadas 00:22:07
con el significado de la programación de entrada de objetos 00:22:10
pues lo llama método, ya está 00:22:13
pero no deja de ser un trozo de código bajo un nombre 00:22:14
bueno, pues lo que pueden ser recursivas 00:22:17
son las funciones o los métodos, como las clases y nada de eso. 00:22:19
Es decir, una función o método recursivo 00:22:24
es el que se llama a sí mismo para 00:22:27
completar su funcionamiento. Necesita llamarse a sí mismo. 00:22:31
Entonces, la recursividad se basa. 00:22:36
Bueno, vamos a hacer esto así. 00:22:42
Vale, pues entonces nuestra función era, lo que nosotros queríamos resolver 00:22:44
era un método 00:22:48
vamos a hacerlo aquí estático 00:22:50
claro, un método 00:22:52
listado de un directorio 00:22:53
donde le pasamos un directorio 00:22:58
y él tiene que 00:23:01
listar todo su contenido 00:23:04
si tiene subcarpetas 00:23:06
a su vez el contenido de subcarpetas y así 00:23:10
todo el rato, entonces eso es lo que tiene que hacer 00:23:12
una vez que hemos tenido lo que tiene que hacer 00:23:14
pues ahora ya vamos mirando que 00:23:16
métodos tenemos para ayudarnos 00:23:18
bueno, pues nosotros ya vimos ayer 00:23:20
que 00:23:22
la clase file 00:23:23
tiene 00:23:26
un método 00:23:28
para listar el contenido 00:23:30
de directorio, de hecho tiene varios 00:23:32
list files te lo da ya 00:23:34
como array de file 00:23:37
y list 00:23:38
te da un array de los nombres 00:23:39
entonces hombre, es más práctico el list file 00:23:42
porque te lo da ya en file 00:23:44
y de file puedes sacar mucha información 00:23:45
el list te da solo el nombre del archivo 00:23:47
tendrías que volver a hacer luego 00:23:50
el new file, si quieres meterte en él 00:23:52
lo que fuera, entonces el list file es más práctico 00:23:54
porque te da toda la lista de objetos 00:23:56
files contenido, entonces 00:23:58
este método 00:24:00
ya nos permite sacar todo 00:24:01
el contenido 00:24:06
de ese directorio 00:24:07
¿vale? 00:24:09
entonces, ahora esto 00:24:13
simplemente, pues tendríamos que ir 00:24:18
uno por uno, ¿verdad? 00:24:20
para cada file 00:24:24
f en contenido 00:24:26
¿qué ocurre? 00:24:28
aquí ya 00:24:32
si f es fichero 00:24:33
ya está, lo único que hay que hacer 00:24:35
mostrar su nombre 00:24:38
se acabó 00:24:41
entonces, ¿cómo sabemos si f es fichero 00:24:42
o directorio? 00:24:45
porque tenemos un método 00:24:47
que es 00:24:49
isFile 00:24:50
entonces si es file, entonces 00:24:53
si esto me da true, o no hace falta 00:24:55
que ponga true, claro 00:24:57
entonces ahora ya simplemente mostramos 00:24:58
por consola 00:25:01
f.getName 00:25:02
y ala 00:25:05
¿pero qué ocurre? 00:25:09
si f es directorio 00:25:13
si f es directorio 00:25:15
pues entonces ahora 00:25:24
¿qué tenemos que hacer? 00:25:26
pues 00:25:29
listar todo el 00:25:29
contenido de f 00:25:32
listar todo su contenido 00:25:33
¿cómo listamos todo su contenido? 00:25:34
pues podríamos 00:25:38
otra vez hacer f list files 00:25:40
y otra vez nos tendríamos que meter en un for 00:25:42
y luego para 00:25:46
dentro de ese for en el save 00:25:48
otra vez hacer un list file 00:25:50
eso no acabaría nunca 00:25:52
pero es que claro, tenemos un método 00:25:54
que se llama listado directorio que ya lo hace 00:25:56
o que pretendemos que lo haga 00:25:58
tenemos un método listado directorio 00:26:00
que está pensado para que 00:26:02
cuando le damos un objeto 00:26:03
que es directorio lo liste 00:26:06
ya tenemos un método que lo hace, pues es que es justo lo que queremos 00:26:07
hacer con F. Es justo lo que queremos 00:26:10
hacer. Queremos 00:26:12
pasárselo al método listarDirectorio para 00:26:13
que lo liste. Pues ya está. Si ya tenemos un método 00:26:16
que lo hace, pues venga. 00:26:18
Ya está. Ya lo tenemos. 00:26:31
Entonces no hay que tenerle miedo a la recursividad. 00:26:32
Porque la recursividad nos permite 00:26:35
resolver cosas aparente complicadas 00:26:37
en un pispás. 00:26:39
Lo que pasa es que lo dificultoso 00:26:41
la recursividad es identificar 00:26:43
cuándo un problema 00:26:45
se puede resolver de forma recursiva 00:26:46
y cuándo no tiene ningún sentido. 00:26:48
eso es lo único difícil 00:26:50
entonces en este caso está claro 00:26:53
esta función que tiene que hacer 00:26:55
tiene que listar 00:26:57
el contenido de un directorio 00:26:59
que yo le paso, esa es su funcionalidad 00:27:01
pues resulta que eso es justo 00:27:04
lo que queremos hacer en este punto 00:27:06
listar el contenido 00:27:08
de este f, es justo eso lo que queremos 00:27:09
hacer, pues entonces no hay que tener ningún miedo 00:27:12
en llamarla 00:27:13
porque 00:27:14
lo que queremos hacer con este f 00:27:17
es justo el propósito 00:27:19
para el que yo he diseñado esta función 00:27:21
es justo el mismo propósito 00:27:23
entonces ahí no hay que tener miedo 00:27:26
en llamar a la función recursivamente 00:27:28
claro, el problema de la recursividad 00:27:29
es si nunca jamás acabara 00:27:33
porque si nunca jamás acabara 00:27:35
cada vez que hacemos una llamada recursiva 00:27:37
en la pila del proceso 00:27:39
se va metiendo el contador de programa 00:27:41
para luego cuando salgas de la recursividad 00:27:43
irlo sacando 00:27:45
entonces, si nunca jamás acabara 00:27:46
la pila de llamadas 00:27:49
la pila desbordaría 00:27:52
y petaría 00:27:54
el programa y petaría el ordenador 00:27:56
pero es que claro que va a acabar 00:27:58
porque mi sistema de archivos no es 00:28:00
infinito, llegará un momento en que ya 00:28:02
no haya ninguna subcarpeta 00:28:04
no es infinito 00:28:06
¿vale? entonces no hay miedo 00:28:07
en llamar a recursividad, primero 00:28:09
uno, cuando hemos 00:28:12
identificado que es un caso 00:28:14
que tiene sentido plantearlo de forma recursiva 00:28:15
Y es cuando lo que yo tengo que hacer dentro, en un punto concreto, es exactamente para lo que estoy diseñando el método. 00:28:18
Cuando eso ocurre, entonces lo puedo llamar sin ningún miedo. 00:28:28
¿Y a qué ocurre? Lo que yo quiero hacer con este f es exactamente lo mismo para lo cual yo estoy diseñando este método. 00:28:32
Pues no hay ningún problema, lo llamo. 00:28:38
Y ahora, siguiente pregunta que me tengo que hacer. 00:28:40
esta recursividad 00:28:42
de llamarse, llamarse, llamarse 00:28:44
va a acabar alguna vez 00:28:46
si estamos en un problema en el que va a acabar 00:28:47
porque es un problema de árbol finito 00:28:51
si es un problema en el que 00:28:52
no va a acabar nunca, entonces la he planteado 00:28:54
mal o tengo que plantearla de otra manera 00:28:57
o estoy en un problema que no es 00:28:58
ya habría que ver, en este caso no hay problema 00:29:00
va a acabar porque el árbol de directorios 00:29:03
es finito, no hay un sistema de archivos 00:29:05
hasta el infinito 00:29:07
bueno pues venga vamos a probarlo 00:29:09
y entonces esto 00:29:13
que a priori parecería complicadísimo 00:29:14
tengo que irme metiendo, irme metiendo 00:29:16
al darle la solución recursiva se convierte 00:29:18
en nada 00:29:21
entonces la recursividad 00:29:21
da códigos muy cortitos 00:29:24
pero muy peligrosos 00:29:26
si no lo hemos planteado bien 00:29:28
y la recursividad no acaba 00:29:30
entonces vamos a probarlo aquí 00:29:31
a ver que nos sale 00:29:34
vale, pues vamos a listar 00:29:36
el directorio actual y ya está 00:29:48
listado 00:29:50
directorio 00:29:53
le vamos a dar 00:29:56
new file 00:29:59
el actual, que es la raíz del proyecto 00:30:02
entonces me tiene que sacar todo lo que tengo 00:30:05
en mi proyecto, con la carpeta bin, src 00:30:07
la que sea 00:30:09
y así meterse en una tras otra 00:30:10
vamos a ejecutarlo a ver que pasa 00:30:13
me lo ha sacado todo 00:30:15
porque claro, vale 00:30:25
estos son ficheros 00:30:30
donde hay un directorio 00:30:31
Un directorio está 00:30:33
Ah, vale, los nombres de directorio 00:30:37
No me los está poniendo 00:30:49
Me está poniendo nombres de ficheros 00:30:50
En el directorio se está metiendo 00:30:51
Pero no me está poniendo el nombre 00:30:53
Entonces me falta antes poner el nombre 00:30:54
Y luego ya que se meta 00:30:58
Entonces se están saltando los nombres de directorios 00:30:59
F.getName 00:31:01
Que lo podía sacar fuera del if, pero bueno 00:31:06
Vale 00:31:07
Vamos a volver a probarlo 00:31:09
Entonces 00:31:11
efectivamente me está sacando 00:31:15
todo lo que hay 00:31:19
este es un directorio 00:31:20
src bin 00:31:22
y se está metiendo en bin 00:31:23
porque aquí está el ejemplo file.class 00:31:25
que está en bin 00:31:28
pero es dificilísimo de interpretar 00:31:29
como nos gustaría que sacara el directorio 00:31:31
y luego lo que está dentro del directorio 00:31:34
nos lo metiera al menos tabulado 00:31:36
o algo así 00:31:38
porque así es que es complicadísimo de entender 00:31:38
pero esto ya implica retocar esto 00:31:42
Vamos a retocarlo para que quede bonito 00:31:48
Y ya lo dejamos 00:31:50
Que esto es 00:31:51
Un poquito más complicado de entender 00:31:52
Hasta aquí lo que hemos hecho está claro 00:31:55
Y por qué lo hemos planteado así 00:31:57
Y hemos visto que efectivamente 00:31:58
Me va entrando en todo el árbol 00:32:01
Me va entrando en todo 00:32:02
Me va mostrando directorios, lo que hay dentro 00:32:04
Pero claro, como me lo muestra todo seguido 00:32:07
No entendemos nada 00:32:08
Pero está entrando en todo el árbol entero 00:32:09
No ha habido un solo archivo o carpeta 00:32:12
Que cuelgue de aquí 00:32:14
de ejemplo que no me lo haya mostrado 00:32:16
todo lo que hay, me lo ha mostrado 00:32:18
todo 00:32:20
lo que pasa es que bueno 00:32:21
que un poco 00:32:23
desordenado 00:32:26
vale, pues ¿cómo podemos arreglar esto? 00:32:28
vale, pues hombre, sería lo ideal 00:32:32
que cada vez que entra 00:32:34
en listado directorio, cada vez que entra 00:32:35
todos los system out 00:32:38
que hace 00:32:40
los hiciera con una tabulación, por ejemplo 00:32:41
cada vez que entra aquí 00:32:44
los hiciera con una tabulación más 00:32:45
por ejemplo 00:32:47
entonces, esto después de mucho pensar 00:32:49
nos ahorramos todo el pensamiento 00:32:52
podríamos hacer, vale, pues vamos a 00:32:53
al listado directorio pasarle un siguiente 00:32:56
parámetro, que sea 00:32:58
el orden de profundidad en el que 00:33:00
vas a hacer tu system out print del n 00:33:02
y entonces, cada vez que llames 00:33:04
al listado directorio, cada vez que hagas una llamada 00:33:06
recursiva, dale un orden 00:33:08
de profundidad mayor, y así cada llamada 00:33:10
recursiva entra con un orden de profundidad 00:33:12
mayor para su system out print del n 00:33:14
Es decir, me explico 00:33:16
Al listado directorio vamos a darle un string 00:33:18
Además, un parámetro añadido 00:33:20
Que sea 00:33:22
La profundidad 00:33:24
Que va a concatenar a su system out 00:33:26
¿Vale? 00:33:28
Entonces, su system out le vamos a concatenar 00:33:30
Con esa profundidad 00:33:33
Con esa profundidad 00:33:34
Y ahora, cuando llamamos 00:33:37
Al listado directorio 00:33:39
Lo llamamos concatenándole 00:33:40
Un tabulador nuevo 00:33:43
un tabulador más 00:33:45
a el anterior 00:33:46
e inicialmente que sea 00:33:50
esto 00:33:53
repetimos 00:33:54
inicialmente yo le paso un orden de profundidad 00:33:57
que es vacío, le paso uno que es vacío 00:34:00
vale, él va a concatenar 00:34:02
con el vacío 00:34:04
pero cuando llamo recursivamente 00:34:05
a lo que tuviera de antes, le pongo 00:34:08
un tabulador, entonces la siguiente llamada 00:34:10
al listado directorio concatenará 00:34:12
en un tabulador 00:34:14
la siguiente llamada 00:34:14
le concatenará otro más al que ya tenía 00:34:17
la siguiente 00:34:20
le concatenará otro más al que ya tenía 00:34:22
entonces cada llamada recursiva 00:34:24
todo su system out 00:34:26
los hace un tabulador más a la derecha 00:34:27
una solución de las muchas 00:34:30
que se le podría haber ocurrido 00:34:32
entonces esto ya 00:34:33
se ve mejor 00:34:38
aquí ya 00:34:40
pues vemos, esta es una carpeta 00:34:43
esta carpeta bin 00:34:46
Tiene a su vez la carpeta file 00:34:47
Y la carpeta file tiene este fichero 00:34:49
Luego, esta cuelga de bin 00:34:50
Que a su vez tiene esta 00:34:54
Entonces aquí ya sí que se ve 00:34:56
Todos esos son ficheros, ficheros 00:34:57
Aquí de nuevo tenemos una carpeta 00:34:58
Con su contenido 00:35:00
Esto ya sí que lo vemos un poco más bonito 00:35:02
No todo 00:35:05
Todo seguido como lo estábamos viendo antes 00:35:06
Ahora 00:35:09
De aquí a aquí, como viene una carpeta 00:35:09
Se ha tenido que meter recursivamente 00:35:13
Por eso me ha metido un tabulador más 00:35:15
me ha metido todo este tabulador 00:35:17
ahora 00:35:18
en file, como era una carpeta 00:35:19
metió otro tabulador, por eso metió este 00:35:22
¿vale? y esto ya era un fichero 00:35:24
pues ya lo imprimió con los dos tabuladores 00:35:28
con este y con este 00:35:30
y salimos de la recursión y nos colocamos 00:35:32
aquí 00:35:34
bueno, esto 00:35:34
lo podéis mirar despacio, tranquilamente 00:35:37
para entenderlo 00:35:40
porque bueno, es interesante 00:35:42
pero la conclusión 00:35:44
aquí es 00:35:46
que hay problemas 00:35:47
que de forma natural son recursivos 00:35:49
de forma natural lo son 00:35:52
porque se resuelven 00:35:53
apoyándose en ellos mismos 00:35:55
de forma natural 00:35:58
el factorial, muchos 00:35:59
problemas se resuelven de forma recursiva 00:36:01
este 00:36:03
cuando hay juegos, por ejemplo 00:36:05
los que se van eliminando a gente 00:36:07
es un juego, el resultado del juego 00:36:09
es eliminar a unos y se vuelve 00:36:12
a jugar, pues entonces ese método 00:36:14
juego se tendrá que llamar a sí mismo 00:36:15
lo que pasa es que cada vez con menos jugadores 00:36:17
por ejemplo, entonces hay problemas 00:36:19
que de forma natural son recursivos 00:36:21
que lo que cambian son 00:36:23
los parámetros de ese juego 00:36:25
los parámetros de ese problema 00:36:27
entonces los que de forma natural son recursivos 00:36:28
se hace un método recursivo sin ningún miedo 00:36:31
y en el momento 00:36:33
en el cual necesites llamarte a ti mismo 00:36:35
te llamas y no pasa nada 00:36:37
te llamas, pero eso sí, siempre hay que asegurarse 00:36:39
que alguna vez va a acabar 00:36:42
este problema, un juego que va eliminando 00:36:43
gente y cada vez se juega con menos 00:36:45
pues dentro del método juego al que le pasas 00:36:47
primero una raya así de mil personas 00:36:49
pues él se irá llamando a sí mismo pero cada vez 00:36:51
le pasas una raya más pequeñito 00:36:53
entonces ahí la pregunta sería ¿llegará un momento en que ya 00:36:54
no le pases jugadores porque se han acabado? 00:36:57
hombre pues sí, porque la raya llega al momento en que se 00:36:59
acabe, pues sí, entonces aquí no tendrás ese 00:37:01
problema, eso es el tipo de 00:37:03
cuestiones que tenéis que pensar cuando 00:37:05
se hacen cosas recursivas, pero claro 00:37:07
la recursividad tiene que acabar 00:37:09
imaginaos que hacemos aquí 00:37:11
un método 00:37:15
con una recursividad que no acaba nunca 00:37:18
por ejemplo 00:37:21
vamos a hacer 00:37:22
este método 00:37:23
que lo que hace es llamarse a sí mismo 00:37:28
no hay ningún problema 00:37:32
es un método recursivo 00:37:35
¿esta recursividad va a acabar alguna vez? 00:37:36
jamás 00:37:39
va a estar todo el rato llamándose 00:37:40
no va a acabar nunca 00:37:42
¿qué pasa si yo ejecuto esto? 00:37:43
vamos a 00:37:47
Llamar a ese método recursivo 00:37:48
Que no acaba nunca 00:37:52
Está mal planteado 00:37:53
Un método recursivo que no acaba nunca 00:37:54
Está mal planteado 00:37:55
Pues ahora ejecutamos esto 00:37:56
Y como era de prever 00:37:58
Pues después de hacer 00:38:03
200.000 intentos 00:38:06
Una vez que los he hecho todos 00:38:08
Me dice 00:38:11
Error, ni siquiera excepción 00:38:12
Porque esto ya es grave 00:38:14
Me dice, pues te has cargado la pila del proceso 00:38:15
pues ya está, porque no puedes 00:38:18
hacer tantas recursiones 00:38:20
aquí habrá hecho, si nos pusiéramos a contar 00:38:22
que son 00:38:24
muchas, no podemos contar 00:38:26
veríamos cuánto cabe 00:38:27
en la pila, si vamos 00:38:30
una por una veríamos cuántos contadores de 00:38:32
programa caben en la pila del proceso 00:38:34
pero hombre, es un poco loco estar aquí 00:38:36
contando lo tras otro, cuando ya la pila del proceso 00:38:38
se ha acabado, dice, ya no puedo llamar 00:38:40
recursivamente más, es imposible 00:38:42
venga, pues paramos otro momentito 00:38:44
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
9
Fecha:
25 de mayo de 2024 - 17:57
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
38′ 52″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
182.15 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid