Saltar navegación

Clase 20-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.

10 visualizaciones

Más información Transcripción

Descargar la transcripción

este máximo es uno de los más 00:00:00
claros 00:00:03
que podemos encontrar 00:00:05
mi resultado final 00:00:07
es un objeto file, ese es mi resultado 00:00:09
final, el más grande de todos 00:00:11
vale, pues de partida asumo que el primero 00:00:13
de todos, que el primero es 00:00:15
el mayor, y ahora empiezo a recorrer los demás 00:00:17
si uno de ellos 00:00:20
supera en tamaño 00:00:24
al que es máximo en ese instante 00:00:25
ya tengo nuevo máximo y ya está 00:00:27
cuando el for ha terminado, ya tengo en esta referencia 00:00:31
el que era máximo y se acabó 00:00:34
vale 00:00:36
no hay más 00:00:37
bueno, alguna duda sobre esto 00:00:40
vale, pues vamos a usarlo 00:00:49
pasándole un array de ficheros 00:00:51
entonces, ¿de dónde sacamos 00:00:54
aquí un array de ficheros? 00:00:59
pues por ejemplo, vamos a usar 00:01:01
alguno de los métodos de file para coger 00:01:03
un array de ficheros como ejemplo 00:01:05
por ejemplo, en la ruta 00:01:07
Primera 00:01:09
La ruta primera 00:01:10
Vamos a hacer una ruta que sea un subdirectorio 00:01:12
Esta primera 00:01:17
Por ejemplo vamos a coger aquí 00:01:19
Lo voy a poner como ruta absoluta 00:01:21
Por si luego usáis el proyecto 00:01:25
Lo que sea 00:01:27
Entonces vamos a 00:01:27
En esta carpeta ficheros de aquí 00:01:29
En esta carpeta ficheros 00:01:32
Que está en mi proyecto 00:01:36
Ficheros 00:01:39
Ahora tiene un fichero 00:01:46
Vamos a hacer 00:01:47
Vamos a hacer tres más 00:01:47
Fichero 2 00:01:50
Al que le ponemos también unos caracteres 00:01:56
Creía que me iba a preguntar si guardaba 00:02:01
No me ha preguntado 00:02:05
Vale, y vamos a hacer otro 00:02:06
Vale, pues le voy a pasar 00:02:18
Un array con estos tres ficheros 00:02:28
Un array con estos tres 00:02:31
Podría 00:02:32
Lógicamente hacer esto 00:02:35
Podría hacer esto 00:02:36
New file de tres 00:02:44
Voy a meter tres 00:02:52
Y ahora ya 00:02:53
Files de 00:02:55
Cero 00:02:58
Igual a pues new file 00:02:58
Y la ruta del primero 00:03:04
Vale, podría ir así a lo cutre 00:03:06
Ir uno por uno 00:03:35
Fichero, fichero 1 y fichero 2 00:03:36
Creo que se llaman 00:03:45
Fichero, fichero 2 y fichero 3 00:03:46
No, se llaman fichero, fichero 2 00:03:50
Y fichero 3 00:03:52
Bueno, pues para hacer mi prueba 00:03:55
He puesto 11 00:03:57
Pues me saldría un 00:04:01
Arraindes va un exception, ¿verdad? 00:04:03
vale, bueno, pues podría ir así a lo 00:04:05
a lo bestia 00:04:08
como sé que voy a pasar 3 00:04:09
en concreto 3 00:04:11
pues me hago un array con espacio para 3 00:04:13
y ahora en cada uno de ellos 0, 1 y 2 00:04:16
me creo el objeto file 00:04:18
con la ruta, y ahora llamo 00:04:19
entonces, esto me va a devolver 00:04:22
el fichero más grande, si yo lo llamo sin guardarlo 00:04:23
en algún sitio, pues pierdo 00:04:26
la referencia, vaya tontería 00:04:28
y ahora ya podría decir 00:04:29
mostrar el resultado 00:04:32
El fichero de más tamaño es 00:04:34
Y ahora voy a concatenarlo 00:04:42
Con el nombre del fichero que está aquí 00:04:47
Que no sé cuál es 00:04:54
Pero de nuevo la clase File me permite mil cosas 00:04:55
Por ejemplo, tiene un método que es GetName 00:04:58
¿Verdad? Tiene un método que es GetName 00:05:00
y este método me devuelve el nombre 00:05:04
del objeto que está asociado a esta referencia 00:05:06
entonces 00:05:09
el objeto file 00:05:11
resultado de la llamada al método 00:05:13
ese objeto file es el que tiene el mayor 00:05:15
tamaño, pues puedo mostrar ya 00:05:18
el resultado aquí 00:05:19
es este 00:05:20
los métodos de la clase file 00:05:22
permiten hacer muchas cosas 00:05:25
entonces vamos a probarlo 00:05:26
para estos tres 00:05:28
que me he hecho yo aquí a mano, 0, 1 y 2 00:05:31
para estos tres 00:05:33
entonces si ejecutamos esto 00:05:34
pues me dice 00:05:38
que el 2 es el que tiene más 00:05:40
más bytes 00:05:42
vamos a ver 00:05:44
si es verdad 00:05:47
pues si tiene toda la pinta 00:05:48
de que este es el que tenía 00:05:56
más caracteres 00:05:59
bueno 00:06:00
para probar otros métodos de la clase file 00:06:02
antes de pasar ya a clases que nos permiten leer y escribir 00:06:05
por ejemplo 00:06:07
imaginaos que lo que me dicen 00:06:09
Oye, pero esto de pasármelos así uno por uno, este, este, este, no. 00:06:11
Quiero ver cuál es el más grande de todos los que están en un directorio. 00:06:18
Tendría más sentido a lo mejor plantearse eso, ¿no? 00:06:22
Yo tengo un directorio y el fichero más grande de todos los que están en ese directorio. 00:06:25
¿Vale? 00:06:31
Vale, pues por ejemplo, vamos a hacerlo con otro método. 00:06:32
un objeto file 00:06:35
me va a devolver 00:06:40
fichero más grande 00:06:42
y ahora que le pasamos 00:06:45
un único objeto file 00:06:48
que es 00:06:49
una referencia 00:06:51
a una ruta que es el 00:06:54
directorio al cual yo quiero 00:06:56
entrar para ver los que son más grandes 00:06:58
vale, voy a poner aquí un return null 00:06:59
para que el compilador 00:07:03
se me quite 00:07:05
el error, vale 00:07:06
pues esta es otra versión del método 00:07:08
otra versión a la que le paso una ruta 00:07:11
asociada a un objeto file 00:07:13
le paso una ruta 00:07:14
esta ruta en particular no es de un fichero 00:07:15
esta ruta es de un directorio 00:07:18
y ahora 00:07:20
este método tendrá que mirar todos los archivos 00:07:21
de ese directorio a ver cuál es mayor 00:07:25
y devolverlo 00:07:26
por ejemplo, he dejado el mismo 00:07:28
nombre que el de arriba 00:07:32
¿pasa algo porque he dejado el mismo 00:07:34
nombre? 00:07:36
¿por qué el compilador me permite 00:07:37
que dos métodos 00:07:40
se llamen igual, me lo está permitiendo 00:07:42
se llaman igual y no pasa nada 00:07:44
¿por qué? estamos volviendo al primer trimestre 00:07:45
todo el rato 00:07:48
efectivamente 00:07:49
porque 00:07:52
se puede distinguir en la llamada 00:07:53
por el parámetro, si tú le pasas un array de fichero 00:07:56
estás llamando a este 00:07:58
pero si le pasas un único file 00:07:58
le estás llamando al otro 00:08:02
entonces nunca va a haber confusión respecto a cuál estás llamando 00:08:03
por la lista de parámetros 00:08:06
Esto es lo que se llama que el método está sobrecargado 00:08:08
¿Verdad? 00:08:11
Vale, pues entonces ahora ¿Qué hacemos? 00:08:12
Vamos a hacer este otro método 00:08:14
¿Cómo podemos sacar los ficheros 00:08:15
Que están en esa ruta? 00:08:19
Bueno, pues de nuevo 00:08:21
Vamos a ver 00:08:22
¿Qué métodos tiene File que me permitan hacer eso? 00:08:24
Vamos a ver este dir 00:08:28
Que a mí me han pasado como parámetro 00:08:29
Si yo cotilleo 00:08:31
Los métodos que tiene 00:08:33
Pues resulta que tiene uno 00:08:34
que es listFiles 00:08:37
directamente, que te devuelve 00:08:39
un array de file, pues justo 00:08:41
lo que estamos buscando 00:08:43
este método 00:08:44
listFiles te devuelve 00:08:47
un array de file 00:08:50
con todos los ficheros 00:08:50
que hay en ese directorio 00:08:53
con el contenido 00:08:55
ala, pues ya tengo 00:09:01
un array de ficheros 00:09:07
un array de ficheros 00:09:09
que es el contenido 00:09:10
de este dir 00:09:13
Y ahora ya puedo hacer lo que he hecho antes 00:09:15
Entonces, para repetir el código 00:09:18
¿Para qué voy a repetir el código? 00:09:23
Si ya tengo un método que me lo hace 00:09:25
¿Para qué lo voy a repetir? 00:09:27
Pues vamos a hacer esto y apañado 00:09:28
retum 00:09:31
fichero más grande 00:09:32
contenido 00:09:34
¡Hala! 00:09:37
Y terminado este método 00:09:39
¿No? 00:09:41
O sea, fichero más grande 00:09:43
cuando le pasas un array se refiere al método 00:09:45
de arriba, ¿verdad? 00:09:47
fijaos que uno mirando esto 00:09:48
podría decir, uy, esto es una cosa recursiva 00:09:55
estoy desde un método 00:09:58
volviéndose a llamar a sí mismo 00:09:59
no, no, no, no se está volviendo a llamar a sí mismo 00:10:01
está llamando al de arriba 00:10:03
¿por qué? porque lo que le estamos pasando 00:10:04
es un array de ficheros 00:10:07
entonces como lo que le estamos pasando es un array de ficheros 00:10:09
no estamos llamando a este 00:10:11
estamos llamando al que reciba 00:10:13
un array de ficheros 00:10:15
y el que recibe un array de ficheros es este 00:10:16
luego entonces 00:10:19
aquí estamos llamando al de arriba 00:10:21
¿vale? 00:10:23
entonces esta es otra versión 00:10:26
de ese método que le pasas un directorio 00:10:27
y te dice de todos los que haya 00:10:29
20, 30, 50, no sabemos 00:10:31
los que salgan aquí, no sabemos 00:10:33
de todos los que haya cuál es el más grande 00:10:35
bueno pues si lo probamos desde 00:10:36
está claro ¿no? 00:10:41
si lo probamos desde nuestro main 00:10:45
a este lo llamaríamos así 00:10:47
sería mucho más fácil 00:10:49
porque le llamaríamos 00:10:51
Vamos a ver cuál es el más grande 00:10:53
Ejemplo file 00:10:55
Porque como no lo tengo static 00:11:03
Lo estoy llamando como un objeto de la clase 00:11:04
Todo el rato 00:11:06
New ejemplo file 00:11:07
¿Y qué hay que pasarle? 00:11:12
Hay que pasarle la ruta del directorio que queremos 00:11:15
La ruta del directorio 00:11:17
Pero en objeto file 00:11:19
Pues entonces 00:11:23
Le puedo pasar esto, new file 00:11:24
Y ahora ya le pongo 00:11:26
ficheros 00:11:28
barra barra, ya está 00:11:31
ficheros, ya la tengo 00:11:33
vale 00:11:34
entonces esta es una ruta relativa 00:11:38
que es la carpeta 00:11:41
ficheros que cuelga del 00:11:43
de la raíz del proyecto, la carpeta 00:11:45
ficheros, vale, se la estoy pasando a este método 00:11:47
instanciada 00:11:49
como file, se la estoy pasando a este método y ahora este 00:11:51
método es 00:11:53
este 00:11:55
que ya lista el contenido 00:11:55
de esa carpeta que yo le he pasado 00:11:58
y apoyándose en el de arriba 00:12:00
pues ya me devuelve el más grande 00:12:02
pues venga, y ahora podría hacer lo mismo 00:12:04
el fichero de más tamaño 00:12:08
es F2, el que me haya salido 00:12:15
vale, pues entonces si ejecutamos 00:12:17
esto me tendrá que dar el mismo 00:12:28
mensaje dos veces 00:12:30
esto me lo ha hecho 00:12:30
con la primera versión 00:12:35
y esto me lo ha hecho con la segunda 00:12:37
que es lo mismo 00:12:39
vale, que es lo mismo 00:12:40
bueno hasta aquí vamos bien más o menos 00:12:43
vale 00:12:57
entonces el método 00:13:03
listFiles para listar contenido 00:13:05
de un fichero está muy bien 00:13:07
de hecho 00:13:08
voy a hacer para luego dejaros planteado 00:13:12
una cosa ya para que hagáis vosotros 00:13:15
por ejemplo un método 00:13:17
que te muestra por consola 00:13:19
simplemente te muestra por consola 00:13:21
el contenido 00:13:23
de un directorio 00:13:25
listar directorio 00:13:26
y yo le paso aquí un directorio 00:13:32
entonces este sería 00:13:35
sacaría 00:13:38
todo el contenido de ese directorio 00:13:41
con el list files 00:13:42
lo sacaría 00:13:44
y ahora ya podemos recorrerlo y mostrarlo 00:13:45
contenido 00:13:49
f.getname 00:13:58
vale, por ejemplo 00:14:04
este sería como el comando dir 00:14:15
del sistema operativo 00:14:16
como el comando 00:14:19
dir, le pasas un directorio 00:14:20
y te lista todo lo que contiene 00:14:22
porque este método te devolvía 00:14:24
un array de objetos file con lo que tiene 00:14:29
y este 00:14:31
te lo recorre ya lo que tiene 00:14:32
además podemos hacer 00:14:34
para que me diga en el listado 00:14:38
si es fichero o si es directorio 00:14:41
podemos hacer 00:14:43
f.is 00:14:44
es directorio 00:14:50
porque si es directorio 00:14:53
entonces 00:14:56
lo que nos muestre 00:14:57
que sea 00:15:00
f.getName 00:15:01
y si no, que f.getName 00:15:06
concatenado con 00:15:08
para que se vea que es un fichero, por ejemplo 00:15:12
y si no, que nos muestre 00:15:14
f.getName 00:15:16
pero concatenado con d 00:15:19
para que se vea que es un directorio 00:15:21
vale, voy a pasar 00:15:24
este paréntesis abajo para que se vea mejor 00:15:28
lo he pasado 00:15:31
aquí abajo, entonces 00:15:33
¿qué me muestra el system.out.println? pues depende 00:15:34
depende 00:15:37
¿f 00:15:39
es un directorio? me hago la pregunta 00:15:40
antes de pasarle el parámetro 00:15:43
¿f es un directorio? 00:15:44
si es un directorio, pues entonces 00:15:47
muéstrame, lo he hecho justo al revés 00:15:49
entonces muéstrame el nombre 00:15:51
seguido de d, ¿no lo es? 00:15:53
pues entonces la alternativa 00:15:55
que será el nombre seguido de f 00:15:57
vale 00:15:58
pues este sería un dir 00:16:00
que le pasas tú un fichero y te muestra 00:16:06
todo lo que hay, si es fichero o es directorio 00:16:09
vale, vamos a probarlo 00:16:11
bueno y vamos a ponerle un barra n 00:16:16
porque si no va a salir todo seguido y va a ser bastante horrible 00:16:18
vamos a ponerle 00:16:20
un barra n por aquí 00:16:22
ah no, que ya tiene 00:16:23
un println, perdón, perdón, no hace falta 00:16:26
porque cada uno se va en la línea distinta 00:16:28
ya tiene el println 00:16:30
vale, vamos a probar este dir 00:16:31
este listar directorio 00:16:35
lo vamos a probar 00:16:36
aquí al final de este código 00:16:39
y lo vamos, ¿qué directorio vamos a listar? 00:16:40
a listar, bueno, vamos a listar el actual 00:16:57
por ejemplo 00:16:58
punto, recordad que punto siempre se refiere 00:16:59
al directorio en el que estoy 00:17:02
vale 00:17:04
punto se refiere al que estoy 00:17:05
pero claro, se lo tengo que pasar como file 00:17:08
new file 00:17:10
vale, pues con este método 00:17:12
estaría listando todo el contenido 00:17:20
¿de qué directorio? 00:17:22
de este 00:17:24
¿y este cuál es? el actual 00:17:25
el actual 00:17:27
¿cuál es? la raíz del proyecto 00:17:28
la raíz del proyecto es 00:17:32
la ruta 00:17:33
por defecto 00:17:35
de la máquina virtual 00:17:38
pues venga 00:17:40
vamos a ver que tiene mi 00:17:42
proyecto 00:17:43
lo ejecutamos 00:17:45
tiene, efectivamente tiene 00:17:59
esto que es un fichero, esto que es un fichero, eso que es un fichero 00:18:01
bin que es un directorio 00:18:05
esto que era otro directorio y esto que era otro directorio 00:18:08
efectivamente esto es lo que está contenido dentro de la carpeta de mi 00:18:12
proyecto 00:18:16
me está diciendo si es fichero y directorio 00:18:18
y esto ya 00:18:24
pero esto ya sí que os lo dejo 00:18:26
como trabajo de curiosidad avanzada, entre comillas, 00:18:28
porque en la recursividad no nos hemos metido. 00:18:33
Lo ideal sería hacer un dir que se siga metiendo en todo el árbol de directorios. 00:18:36
Miguel, escucha. Y tú, Kevin, también, que eso me lo tenéis que hacer. 00:18:42
Lo ideal sería modificar listar directorio para que cuando se encuentre un directorio 00:18:47
se vuelva a meter y te saque abajo lo que tiene. 00:18:52
A ser posible tabulado. 00:18:55
Y si dentro del otro directorio se vuelve a meter recursividad, eso. Pues entonces, la mejora estupendísima ya de este método sería la mejora estupendísima de listar directorio. 00:18:57
Esta ya como recibe lo mismo 00:19:17
A este sí que tenemos que darle 00:19:26
Otro nombre 00:19:28
Esta sería 00:19:30
Que muestra 00:19:41
Todo el árbol de directorios 00:19:44
Todo, y si hay una carpeta se mete dentro 00:19:46
¿Vale? Bueno, esto lo dejo ahí 00:19:48
Porque si alguien quiere investigar la recursividad 00:20:01
De ahí hacerlo 00:20:04
Pero no lo digo en general que lo hagáis todos 00:20:04
Bueno 00:20:08
Pues estos son los misterios de la clase 00:20:09
file, que no tiene más que estos 00:20:12
un punto 00:20:14
de mi sistema de archivos, un punto 00:20:16
lo puedo asociar a un objeto file 00:20:18
y ahora ya con ese objeto file puedo 00:20:19
hacer cosas que llegan hasta donde llegan 00:20:22
pues ver los permisos que tengo, el tamaño 00:20:24
ver contenido si es un directorio 00:20:26
algunas cositas de esas ya 00:20:28
poco más, ¿vale? 00:20:29
bueno, pero nosotros habíamos empezado 00:20:31
todo esto 00:20:33
de entrada y salida 00:20:34
y de ficheros para poder hacer aplicaciones 00:20:39
que leyeran el contenido de archivos 00:20:42
y guardaran el resultado en archivos 00:20:44
para eso lo habíamos hecho 00:20:47
la clase file no nos vale para eso 00:20:48
no nos vale para escribir variables dentro de archivos 00:20:50
ni para leer contenido de archivos 00:20:53
las variables 00:20:55
con la clase file 00:20:56
el contenido de estos archivos 00:20:58
estos de aquí 00:21:02
que yo he creado 00:21:12
este contenido con la clase file a él no llego 00:21:12
no llego 00:21:15
Bueno, pues necesitamos otras clases 00:21:17
Otras clases para 00:21:20
Acceder, leer y escribir archivos 00:21:21
Vale, pues vamos a hacerlo en otro paquete 00:21:25
Que en lugar de file se va a llamar 00:21:28
Ahora ya 00:21:30
Entrada-salida o leer-escribir 00:21:31
Lectura-escritura 00:21:33
Porque ahora ya sí que vamos a leer y escribir en archivos 00:21:37
Bueno, pues a ver 00:21:40
Vamos a ver 00:21:46
Ay no, me deja así 00:21:47
bueno, pues a ver 00:21:57
clases para hacer 00:22:07
ahora ya sí, lectura y 00:22:11
escritura en archivos 00:22:13
bueno, pues aquí hay varias cosas 00:22:14
de esta, esto va a ser 00:22:23
repito, una visión muy por 00:22:25
encima, luego ya hay 00:22:28
más clases y más cosas para hacer cosas más 00:22:30
específicas, pero va a ser una visión muy 00:22:31
por encima de la base, de cómo funciona 00:22:34
bueno, pues hay varias cosas 00:22:35
que vamos a ir 00:22:37
dejando claras 00:22:39
primero, lo habitual es que uno 00:22:41
cuando usa un archivo 00:22:44
lo use o solo para leer 00:22:48
o solo para escribir 00:22:51
es decir, yo necesito leer de un archivo 00:22:52
lo abro, como se dice, lo abro, me conecto a él 00:22:55
ahora veremos qué significa abrirlo o conectarse a él 00:22:58
lo abro para leer, leo, recojo y llevo variables 00:23:00
y luego ya lo cierro 00:23:04
y ya está, acaba ese proceso 00:23:06
Ahora no, ahora lo que quiero es escribir 00:23:09
Pues lo abro para escribir 00:23:11
Cojo mis variables y las voy pasando al fichero 00:23:14
Cuando he terminado 00:23:18
Lo cierro 00:23:20
Luego cuando uno se conecta o abre 00:23:21
Ahora veremos qué significa eso en Java 00:23:24
Un fichero 00:23:26
O lo hace para leer 00:23:27
O lo hace para escribir 00:23:28
Más que nada porque si no es un desmadre 00:23:31
Porque tú 00:23:33
Tú estás leyendo 00:23:35
Cuando vas leyendo 00:23:37
vas leyendo secuencialmente 00:23:38
lees este, entonces el puntero interno 00:23:40
se queda en el siguiente carácter 00:23:42
ahora lees este, el puntero interno 00:23:44
se queda aquí 00:23:46
y si ahora mandas a escribir, ¿dónde se escribe? 00:23:47
¿se escribe donde está el puntero de lectura? 00:23:50
¿se escribe desde arriba? 00:23:51
se pueden generar muchos efectos indeseados 00:23:53
entonces hay muy pocas clases 00:23:56
que permitan que un archivo puedas abrirlo 00:23:58
para leer y escribir a la vez, muy pocas 00:24:00
lo normal es que tú tengas 00:24:02
que organizar tus aplicaciones 00:24:05
para decidir cuándo quieres leer 00:24:06
y entonces lees. Ahora ya tengo 00:24:09
la información, hago lo que sea. Ahora 00:24:11
quiero escribir. Pues voy y escribo. 00:24:13
Hay que organizar nuestras aplicaciones 00:24:16
para que el recurso 00:24:17
esté abierto o para recoger 00:24:19
los datos a variables 00:24:21
o para mandar los datos de variables al archivo. 00:24:22
Eso es la primera cosa. 00:24:26
Entonces lo escribimos aquí 00:24:28
de cualquier manera para que 00:24:29
se abre 00:24:30
para leer o 00:24:34
para escribir. 00:24:37
para eso se abre 00:24:39
vale 00:24:41
bueno, pues vamos a 00:24:41
plantearnos primero escribir un archivo 00:24:44
vamos a plantearnos 00:24:47
que tenemos un método, una aplicación 00:24:49
que ha hecho cosas y ahora yo quiero 00:24:51
mis resultados pasarlos a un archivo 00:24:53
vale, pues como escribimos en un archivo 00:24:55
bueno, pues para escribir 00:24:57
en un archivo, tanto las lecturas 00:25:00
como las escrituras 00:25:02
Java tiene dos modos 00:25:03
o el modo byte 00:25:05
que se llama, que es el básico 00:25:07
tú lees byte por byte 00:25:10
porque los ficheros ya sabéis 00:25:13
que son sucesiones de bytes, bueno cada byte 00:25:15
a su vez son 8 bits, pero bueno 00:25:16
el byte es la 00:25:19
unidad 00:25:20
mínima 00:25:21
de transporte, de llevar de acá para allá 00:25:24
datos para cualquier programa 00:25:27
el byte 00:25:29
de hecho tenemos una variable primitiva 00:25:30
que es byte, que permite alojar un byte 00:25:33
que son 8 bits, pero tenemos una variable 00:25:35
primitiva que sea bit, que permite alojar 00:25:37
un bit, esa variable primitiva no existe 00:25:39
o sea, la unidad más pequeñita 00:25:40
en la cual 00:25:43
se puede guardar información 00:25:44
en cualquier lenguaje de programación es el bytes, son 8 bits 00:25:46
el byte, ¿vale? 00:25:49
bueno, pues entonces, Java 00:25:50
considera que tú puedes trabajar de dos modos 00:25:52
o transfiriendo, tanto para 00:25:54
escribir como para leer bytes directamente 00:25:57
o, como se 00:25:58
usan mucho y muy a menudo los ficheros de texto 00:26:01
transfiriendo caracteres 00:26:03
teniendo en cuenta 00:26:05
que son caracteres y por tanto 00:26:07
haciendo las correspondientes 00:26:09
transformaciones para que 00:26:10
el ASCII 00:26:13
siempre se conserve 00:26:15
entonces 00:26:16
es posible 00:26:18
modo byte 00:26:27
o modo carácter 00:26:29
el primer ejemplo que vamos a hacer es en modo carácter 00:26:34
porque es lo más sencillo 00:26:41
para que lo entendamos porque un fichero de texto 00:26:43
como lo podemos abrir y ver 00:26:45
con un editor de notas 00:26:47
con un blog de notas como lo podemos ver 00:26:48
nos va a ser más fácil 00:26:50
al principio entenderlo con un fichero de texto 00:26:52
pero es a los que estamos acostumbrados 00:26:54
un fichero que no es ASCII 00:26:55
tú no lo puedes visualizar con ningún 00:26:57
programa que no sea el fichero que lo hizo 00:27:00
con ningún otro 00:27:02
pero sin embargo un fichero de texto lo puedes 00:27:03
visualizar con cualquier editor de texto 00:27:06
y siempre vas a ver su contenido 00:27:08
sin problemas 00:27:10
pero eso solo pasa con los ficheros de texto 00:27:10
los que tienen ASCII 00:27:14
que lo puedes visualizar con cualquier editor de texto 00:27:16
cualquier otro 00:27:18
fichero que no tenga ASCII 00:27:20
que no esté codificado 00:27:22
con el código ASCII 00:27:24
estará codificado con el código 00:27:25
propio de la aplicación que lo generó 00:27:28
¿no? como un fichero de Word 00:27:30
solo lo puedes visualizar con Word 00:27:32
o con otro que sea capaz de 00:27:34
convertirlo, pero no con un editor de texto 00:27:36
por ejemplo, un fichero de Excel 00:27:38
igual, no tiene código 00:27:40
ASCII, entonces solo lo puedes visualizar con 00:27:42
Excel o aplicaciones compatibles 00:27:44
bueno, pues entonces vamos a empezar 00:27:45
con modo carácter 00:27:48
que nos va a ser lo más fácil de entender 00:27:50
bueno 00:27:52
pues las clases 00:27:53
para leer y escribir 00:27:54
en modo carácter 00:27:57
las clases son 00:28:00
file 00:28:02
reader para leer 00:28:04
ahora vemos como usarlas 00:28:07
y file writer 00:28:08
para escribir 00:28:11
estas son dos clases muy sencillas 00:28:16
de usar y que 00:28:18
sí que se usan porque en cualquier 00:28:19
momento uno tiene un fichero de texto 00:28:22
sea un fichero de propiedades, de proper 00:28:23
que sea un fichero de log, sea lo que sea 00:28:25
y FileReader es una clase sencillísima 00:28:27
para leer el contenido de lo que tiene 00:28:30
bueno, pues vamos 00:28:31
a usar estas clases 00:28:34
vamos primero a escribir un archivo 00:28:35
a ver, pues venga 00:28:37
vamos al otro paquete que teníamos 00:28:42
y vamos a hacernos 00:28:46
una clase nueva 00:28:51
venga, esta clase 00:28:52
ejemplo, lectura 00:29:00
la escritura. Y aquí en métodos lo 00:29:03
metemos todo. 00:29:05
Siempre se me olvida el main. 00:29:14
Nunca, en todos estos meses que llevamos 00:29:33
ya de relación, nadie 00:29:35
me ha preguntado qué es eso. 00:29:37
Sí, pero ¿por qué está ahí? ¿Qué pinta? 00:29:43
¿Qué pinta? Porque es que no lo hemos 00:29:46
usado jamás. ¿Alguna vez lo hemos usado aquí dentro 00:29:47
de ARCS? ¿Este parámetro ARCS? Nunca jamás, 00:29:49
¿verdad? Nadie me lo había preguntado 00:29:51
nunca jamás. 00:29:53
Bueno, pues para pasar, luego lo comentaremos, ¿eh? 00:29:58
Para pasar parámetros en la llamada al programa. 00:30:02
¿Qué está ocurriendo? 00:30:06
Nosotros hasta ahora, siempre que hemos ejecutado el programa, 00:30:07
lo hemos ejecutado, hemos dicho, ejecútate. 00:30:10
Bien con la flechita verde, como fuera. 00:30:12
Pero hemos dicho, ejecútate. 00:30:15
Y ya está, no le hemos dado ninguna información adicional. 00:30:17
Pero cuando uno manda a un programa que tiene método main 00:30:19
a ejecutarse, le puede mandar a ejecutarse 00:30:23
Y además, pasarle unos parámetros adicionales. 00:30:27
Pues esos parámetros adicionales, si yo se los paso, van a caer aquí. 00:30:32
Si yo no se los he pasado, aquí no cae nada. 00:30:38
Vamos a hacer un main simplemente que recorra este array a ver qué tiene. 00:30:42
Uy, perdón, ese. 00:30:59
Vale, voy a ejecutar este programita. 00:31:02
a ver qué me dice que tiene ahí 00:31:05
qué me dice que tiene 00:31:07
pues no tiene nada 00:31:08
porque no le ha pasado nada 00:31:20
pero yo podría llamar a este programa 00:31:22
pasándole parámetros 00:31:24
porque le quiero dar unos parámetros 00:31:25
en función de los cuales a lo mejor 00:31:28
este programa hace una cosa o hace otra 00:31:30
¿vale? 00:31:32
entonces, ¿cómo se los puedo pasar? 00:31:34
si yo ejecutara este programa llamándole por la consola 00:31:35
que eso lo hemos hecho 00:31:38
¿no? 00:31:40
cuando vimos compilar, ejecutar 00:31:42
vimos que uno podía compilar con javac 00:31:44
y el nombre del programa 00:31:46
luego ejecutarlo con java y el nombre del programa 00:31:47
pues si yo lo llamo desde la consola 00:31:50
la ejecución, hago java 00:31:52
y nombre de la clase ya compilada 00:31:54
que eso ya lo hicimos 00:31:56
la forma de pasarle parámetros 00:31:57
sería si los voy pasando separados por espacios 00:31:59
en este caso haría en la consola 00:32:02
java, ejemplo, lectura, escritura 00:32:04
que es el nombre del programa que tiene el main 00:32:07
de la clase que tiene el main y luego le diría 00:32:09
parámetro 1, parámetro 2, parámetro 3 00:32:10
todo eso en la lista de comandos y ya está 00:32:12
y este arc se llenaría de esos 00:32:14
si estoy con el eclipse 00:32:16
o con otro entorno de desarrollo 00:32:19
como yo entonces no ejecuto con la consola 00:32:20
sino con la flechita verde 00:32:22
entonces tengo que configurar 00:32:23
lo que se llama la configuración de ejecución 00:32:26
le dice, y esta ejecución 00:32:28
configúramela, ¿qué quieres meter en ella? 00:32:30
pues en esa configuración de ejecución 00:32:32
que nunca hemos entrado 00:32:33
porque siempre hemos usado por defecto 00:32:35
en esa configuración de ejecución puedo yo decirle 00:32:37
oye, estos parámetros, si es que quiero 00:32:39
entonces esa configuración de ejecución 00:32:41
se verá 00:32:44
en run configurations 00:32:46
¿veis? cuando yo doy a ejecutar 00:32:49
que me sale aquí 00:32:51
o java application o 00:32:52
configuración de ejecución 00:32:54
pues le doy ahí 00:32:56
y fijaos lo que me ha salido 00:32:58
me sale aquí una pestañita 00:33:01
que me dice argumentos 00:33:04
primero ¿veis? 00:33:06
me dice argumentos 00:33:09
y yo aquí en argumentos le puedo escribir 00:33:10
lo que yo quiera, que entiendo, voy a probarlo 00:33:15
que 00:33:17
con ponerse, no sé si separas 00:33:18
por espacio, aquí no 00:33:21
voy a ponerle 00:33:22
venga, param1, param2 00:33:25
param3, estoy poniendo 00:33:28
tal y como yo los pondría en la consola 00:33:31
si llamara mi programa desde la consola 00:33:33
pero no sé si él me lo va a pedir ahora 00:33:34
como él luego lo transforma a consola 00:33:37
no sé si le valdrá así o querrá salto de línea 00:33:39
vamos a probarlo y ya está 00:33:41
venga, estos parámetros 00:33:42
ala, vamos a 00:33:44
ejecutarlo 00:33:49
y a ver que ha pasado 00:33:51
pues aquí están 00:33:53
vale 00:33:55
ahora ya esos tres parámetros 00:33:56
que yo he escrito, se han usado 00:33:59
para rellenar este array 00:34:01
y aquí los tengo 00:34:03
entonces pues 00:34:05
esto en algunos casos puede tener su utilidad 00:34:10
un programa a lo mejor 00:34:12
pues un programa se ejecuta en dos modos 00:34:14
modo admin o modo usuario 00:34:16
por ejemplo 00:34:18
Tiene dos formas de uso 00:34:19
Entonces tú puedes pasarle 00:34:20
La aplicación 00:34:22
La interfaz gráfica o lo que sea 00:34:24
En función de si tu perfil es admin o no 00:34:26
Pues llamará al main 00:34:28
Poniéndole después admin o poniéndole después usuario 00:34:30
Por ejemplo 00:34:33
Y ahora este ya distinguirá en este ans 00:34:33
Si eres admin, si eres usuario 00:34:36
Pues bueno, esto tiene todos los usos que uno quiera darle 00:34:37
¿Vale? 00:34:40
Luego repito 00:34:43
Esto es una manera, una posibilidad 00:34:44
De pasar parámetros al programa 00:34:46
en el momento en el que lo llamas 00:34:48
solo en ese momento 00:34:49
y esos parámetros que siempre son cadenas de texto 00:34:51
irán a este array 00:34:55
y ya está 00:34:56
y tú lo usas si lo necesitas, si te da la gana, lo que sea 00:34:57
pero bueno 00:35:00
nosotros ahora no lo vamos a 00:35:02
no lo estamos usando 00:35:04
entonces vamos a quitar 00:35:05
para que no pierda tiempo 00:35:07
cogiendo parámetros que no va a usar 00:35:09
vamos a quitarle esto 00:35:11
y ya está 00:35:14
vale 00:35:15
Bueno, pues para qué estábamos haciendo este programa 00:35:20
Nuestro nosotros 00:35:23
Primero para escribir un fichero 00:35:24
Pues ahora vamos a hacer un método 00:35:27
Para escribir 00:35:29
En un fichero 00:35:31
Pues una serie 00:35:32
De caracteres que nos dé un usuario 00:35:38
Pues venga 00:35:41
El método nos va a devolver 00:35:44
El objeto 00:35:47
File que ha creado 00:35:49
escribir 00:35:51
fichero 00:35:55
vale 00:35:59
vale, entonces este método 00:36:04
que va a hacer 00:36:10
este método 00:36:11
este método 00:36:13
devuelve un objeto 00:36:15
file 00:36:21
con el 00:36:23
texto que se ha solicitado 00:36:25
al usuario 00:36:27
vale, y vamos a ponerle aquí 00:36:28
un return null para que el compilador 00:36:36
no nos dé la brasa hasta que no acabemos 00:36:38
me falta importar, claro 00:36:44
vale 00:36:46
vale, pues entonces 00:36:48
nosotros primero tenemos que 00:36:53
darnos cuenta de que queremos hacer 00:36:56
lo que queremos es pasar información a un 00:36:57
fichero, vale 00:37:00
ahora, ¿esa información son caracteres 00:37:01
de texto? sí, son caracteres 00:37:04
de texto porque es texto que me va a meter el 00:37:06
usuario por la consola, es texto 00:37:08
Vale, pues entonces, la clase que vamos a usar es FileWriter, pues ahora la podemos ya, esta clase, FileWriter, esta referencia es la que vamos a necesitar, y la importamos de Java.io, porque esta clase es la que vale para escribir en un fichero caracteres, esta es, para escribir caracteres en un fichero. 00:37:10
vale, tenemos que instanciarla 00:37:37
para poder usarla, claro, tendremos que instanciarla 00:37:41
bueno, pues de nuevo 00:37:43
FileWriter se instancia con su 00:37:44
constructor 00:37:47
y el constructor 00:37:47
está sobrecargado, admite varias 00:37:50
modalidades 00:37:53
una de ellas, la más básica 00:37:54
es pasarle directamente 00:37:57
un string con el nombre del fichero 00:37:59
en el que yo voy a escribir 00:38:01
por ejemplo, podríamos decirle aquí 00:38:02
el usuario 00:38:05
Introduzca el nombre del fichero 00:38:05
Introduzca el nombre del fichero 00:38:09
Vale, pues entonces él 00:38:17
Vamos a leer con un 00:38:19
Bueno, yo voy a leer con la clase en teclado para no 00:38:22
Tener problemas 00:38:27
Le añado un jar 00:38:31
Que estaba en el escritorio 00:38:36
Ahí 00:38:40
Pero vamos, si lo hacéis con el escáner 00:38:41
Pues venga 00:38:44
Aquí como 00:38:46
El nombre del fichero 00:38:52
Stream 00:38:54
Non fichero 00:38:55
Va a ser igual a 00:38:58
Teclado punto leer cadena 00:39:01
Ala ya está 00:39:04
Ese es el nombre del fichero que ha metido el usuario 00:39:06
Pues venga 00:39:09
Yo ya le puedo pasar directamente aquí 00:39:10
Un stream 00:39:12
Con el nombre del fichero 00:39:13
¿Vale? 00:39:15
entonces ya he instanciado este objeto 00:39:20
y este objeto ya me va a permitir 00:39:22
escribir en un fichero 00:39:23
con este nombre 00:39:26
es para eso 00:39:27
este objeto, para escribir caracteres 00:39:28
en un fichero con este nombre 00:39:32
ahora ya 00:39:33
podría empezar a escribir caracteres 00:39:36
¿por qué me dice el compilador eso? 00:39:37
pues porque FileWriter puede sacar una excepción 00:39:40
de tipo 00:39:42
ioException 00:39:44
entonces las clases 00:39:46
que trabajan con entrada y salida 00:39:47
como las entradas y salidas 00:39:49
son peligrosas porque dependen 00:39:50
que existan recursos externos, ajenos 00:39:53
todas están hechas 00:39:55
para que lancen excepciones 00:39:57
y avisarte, excepción de tipo exception 00:39:58
ni siquiera runtime exception, sino exception 00:40:01
y a ti te avisan 00:40:03
y tú usas este método, en este caso el constructor 00:40:04
usas el método constructor 00:40:07
y te dicen, oye cuidado 00:40:09
que puede salir 00:40:11
te puede salir una 00:40:13
excepción de entrada y salida 00:40:15
porque no esté disponible 00:40:17
algo 00:40:20
vale, pues entonces no te queda más remedio 00:40:21
que o capturar o propagar 00:40:24
ahora mismo por no engrosar 00:40:26
el código y porque quede 00:40:28
claro lo que nos interesa que es la lectura y la escritura 00:40:30
por no engrosarlo vamos a ponerle 00:40:32
un throws, propagamos y ya está 00:40:34
porque si hago un try catch pongo más líneas 00:40:36
de código y se hace más pesado 00:40:38
entonces la propago, throws exception y ya está 00:40:39
vale 00:40:44
bueno pues ahora 00:40:45
ahora ya, ¿qué tendríamos que hacerle? 00:40:46
pues pedirle al usuario 00:40:52
que vaya introduciendo las líneas 00:40:53
las líneas que va a querer ir escribiendo 00:40:55
en el fichero, pues venga, se lo podemos decir 00:40:58
así 00:41:00
ala 00:41:00
introduzca texto 00:41:02
y le podemos decir 00:41:06
que introduzca fin cuando ya quiera terminar 00:41:08
de introducir el contenido en el fichero 00:41:10
fin para terminar 00:41:12
Terminar, por ejemplo. 00:41:16
Vale, pues ahora ya empezaría un bucle que está todo el rato. 00:41:20
Leyendo línea, mandando al fichero. 00:41:23
Leyendo línea, mandando al fichero. 00:41:25
Leyendo línea, mandando al fichero. 00:41:27
Así mientras la línea leída sea diferente de fin. 00:41:30
¿Vale? 00:41:33
Bueno, pues entonces ahora ya podemos hacer lo siguiente. 00:41:35
Aquí la línea leída. 00:41:40
Inicialmente vacío, por ejemplo. 00:41:45
Y ahora, mientras línea no sea fin 00:41:47
O sea, leemos la primera, perdón 00:41:52
Leo la primera línea 00:41:58
Mientras línea sea diferente de fin 00:42:01
Que es la marca que dice el usuario cuando ya ha terminado 00:42:07
Pues mientras sea diferente de fin, ¿qué tenemos que hacer aquí? 00:42:10
Escribir esa línea leída y leer la siguiente 00:42:15
esta sería la estructura de mi programa 00:42:18
escribo esa línea 00:42:30
y leo la siguiente 00:42:33
sigue siendo diferente de fin 00:42:34
escribo la línea y leo la siguiente 00:42:36
sigue siendo diferente de fin 00:42:38
escribo la línea y leo la siguiente 00:42:40
he leído la primera fuera 00:42:41
porque si la primera ya es fin 00:42:44
directamente no escribo nada 00:42:45
fin es solo la marca 00:42:47
bueno pues entonces 00:42:48
leer la siguiente 00:42:51
es esto otra vez 00:42:53
leer la siguiente tiene poco que pensar 00:42:55
leer la siguiente es esto 00:42:57
y ahora, ¿cómo escribo una línea en el fichero? 00:42:59
pues para eso tengo el objeto 00:43:02
que sirve para escribir 00:43:05
¿qué métodos tiene? 00:43:07
pues bueno, se trata de ver qué métodos tiene 00:43:12
a ver cuál me es interesante 00:43:14
pues aquí si uno se pone 00:43:15
a mirar 00:43:18
pues los que empiezan por write 00:43:19
tiene toda la pinta que son los que son para escribir 00:43:21
vale, son los que son 00:43:23
para escribir 00:43:26
y tengo 00:43:26
uno, great string 00:43:29
que tiene toda la pinta que me escribe 00:43:30
directamente todo un string 00:43:33
todo un string en el fichero 00:43:35
pues esa estaría bien utilizarla 00:43:36
porque es justo lo que quiero, un string 00:43:39
tengo otra que es great 00:43:40
que solo admite 00:43:44
una variable, esto es para escribir un carácter 00:43:46
de uno en uno 00:43:49
diréis, ¿y por qué 00:43:50
lo mete como int en vez de como c? 00:43:54
porque se lo tienes que dar 00:43:58
como int, aunque el char vaya 00:43:59
en el menos significativo. 00:44:01
¿Por qué? Lo entenderemos cuando veamos 00:44:02
cómo lee. 00:44:04
Vale, pero de los que hay, 00:44:08
por ejemplo, este, le pasas un array 00:44:10
de char, tiene toda la pinta, un array de char, 00:44:12
y te escribe un array de char, estupendo. 00:44:13
Este tiene toda la pinta, si uno mira 00:44:16
en la ayuda, que le pasas un array de char, 00:44:18
una posición 00:44:21
de partida y una cantidad, 00:44:22
y te escribe de ese array de char 00:44:24
desde esa posición, esa cantidad. 00:44:26
Bueno, diferentes 00:44:29
Variantes de write, write está sobrecargado 00:44:30
Tiene diferentes 00:44:32
Pero esta es la que más nos gusta 00:44:33
Porque le pasamos un string directamente 00:44:35
Y me lo escribe 00:44:37
Bueno, pues entonces 00:44:40
¿Qué hace 00:44:45
El método write? 00:44:46
Mueve, o sea, cuando mueve 00:44:49
No interpretéis que lo saca del string, ¿no? 00:44:50
Línea se queda teniendo lo que tiene 00:44:53
O sea, lo que hay en línea 00:44:54
Lo lleva al archivo 00:44:55
Entonces 00:44:58
Silencio por ahí atrás 00:44:59
Pero, si este es mi archivo 00:45:03
¿Dónde están aquí los cuadraditos? 00:45:10
Ah, aquí 00:45:18
Vale, imaginaos que este es mi archivo 00:45:18
¿Vale? 00:45:24
Y este es mi variable string 00:45:25
Esta es mi variable string 00:45:28
Esta es línea 00:45:32
No se le da igual 00:45:33
Vale 00:45:46
Esta es mi variable string, este es mi fichero 00:45:48
Entonces, el primer write 00:45:51
me llevará 00:45:53
el primer white me llevará 00:45:54
esto 00:45:56
al fichero 00:45:58
¿y dónde se queda posicionado en la siguiente lectura? 00:46:00
se queda posicionado después 00:46:03
de donde acabó 00:46:04
ahora, la siguiente vez que llevo línea 00:46:06
lo lleva 00:46:09
a continuación 00:46:10
e internamente este fichero 00:46:12
sin que nosotros tengamos que gestionar nada 00:46:14
si que tengamos que gestionar nada 00:46:16
se queda posicionado 00:46:18
después de la última escritura, se queda aquí a la espera 00:46:19
ahora, vuelvo a hacer un 00:46:22
write línea, pues esta línea 00:46:25
se viene aquí 00:46:27
e internamente, sin que tengamos que gestionar 00:46:28
nada, este fichero se queda 00:46:31
posicionado para escribir después 00:46:33
con lo cual 00:46:35
las líneas se van escribiendo 00:46:37
una debajo de la otra, yo no tengo que gestionar 00:46:38
que el fichero internamente se vaya 00:46:41
posicionando para que se vaya 00:46:43
escribiendo, no, no 00:46:45
él lleva avanzando, vale 00:46:46
entonces, vamos a probar 00:46:48
antes de descansar este 00:46:52
este método 00:46:54
entonces 00:46:57
vamos a terminar el método 00:46:59
una vez que 00:47:00
hemos terminado de escribir 00:47:02
que este objeto ha terminado 00:47:04
conviene cerrarlo 00:47:06
efectivamente 00:47:08
entonces una vez que hemos terminado 00:47:16
y ya no vamos a usar más 00:47:20
ya no vamos a escribir más 00:47:21
el recurso de este FileWriter 00:47:23
se debería cerrar 00:47:25
luego, esto es el equivalente a abrir 00:47:26
entre comillas, instanciar 00:47:29
este asociado a un fichero, el equivalente a abrir 00:47:31
con este escribimos 00:47:33
todo lo que haya que escribir 00:47:35
y ahora deberíamos cerrarlo 00:47:36
entonces, ¿cómo se cierra un recurso? 00:47:39
pues así, con close 00:47:41
ya está cerrado 00:47:43
y ahora tenemos que devolver 00:47:44
con orden retorno el file 00:47:47
del fichero que hemos creado 00:47:49
bueno, pues no pasa nada 00:47:50
ahora ya devolvemos 00:47:53
return 00:47:54
que ya lo hemos oído 00:47:56
nom fichero 00:47:59
vale 00:48:05
ya nos devuelve el file 00:48:07
asociado a ese fichero que acabamos de 00:48:09
escribir, este de aquí 00:48:12
vale 00:48:14
a ver, como yo no le he asociado 00:48:16
a ninguna ruta antes, no le he puesto ninguna ruta 00:48:19
antes, lo va a meter en la misma 00:48:21
raíz del proyecto 00:48:23
en la misma raíz del proyecto, porque yo estoy pasando el nombre del fichero 00:48:24
sin más, la misma raíz 00:48:27
Bueno, a menos que cuando meta aquí el nombre 00:48:28
Lo meta con otra ruta, claro 00:48:31
Entonces vamos a probarlo 00:48:33
Llamándolo desde este main 00:48:35
En este caso sí que vamos a ponerle ya un static 00:48:36
Para no andar ahí 00:48:39
A ver 00:48:41
Escribir 00:48:43
Fichero 00:48:47
Me devuelve el file 00:48:49
En realidad no hace falta 00:48:52
Porque yo veré en la carpeta que el fichero se ha creado 00:48:54
Pero bueno, vamos a comprobarlo así 00:48:57
Si escribir fichero es diferente de null 00:49:00
Esto será que ha creado el objeto file correctamente 00:49:05
Que hace este 00:49:09
Vamos a probarlo así 00:49:10
Pues entonces haríamos 00:49:14
Se ha creado archivo de nombre 00:49:18
¿Y el nombre cuál va a ser? 00:49:23
pues el nombre de 00:49:26
de este file 00:49:27
que no lo guardo en ningún sitio 00:49:30
file f 00:49:31
siendo f igual a escribir 00:49:39
fichero 00:49:42
es diferente de null 00:49:43
entonces se ha creado el archivo de nombre 00:49:49
f.getName 00:49:51
vale 00:49:56
es decir, llamo al método 00:50:02
que escribirá, guardo el file 00:50:04
de vuelta, ya de paso que lo llamo lo guardo 00:50:06
ahora todo ese file 00:50:08
que me ha devuelto si es diferente de null 00:50:10
Dime, has creado el archivo 00:50:12
De nombre, vamos a ver que nombre es 00:50:14
¿Por qué me aparece en rojo? 00:50:16
¿Eh? 00:50:22
Claro, porque escribir fichero 00:50:23
Hace un throws como una casa 00:50:25
Entonces este lo captura, lo propaga 00:50:26
Vamos a propagarlo para que el código sea más cortito 00:50:28
Y me lo manda al main ya 00:50:31
Venga, pues vamos a ejecutar esto 00:50:32
Nombre del fichero 00:50:35
Que vamos a crear 00:50:39
Pues venga, se va a llamar líneas 00:50:39
Introduzca texto 00:50:42
Pues hola Dios 00:50:44
Y fin 00:50:47
Terminó 00:50:51
Se ha creado un archivo de nombre líneas 00:50:53
Vamos a ver si se ha creado un archivo de nombre líneas 00:50:55
Tiene que estar en la raíz del proyecto 00:50:58
Nos vamos al proyecto 00:51:00
Vamos a darle un refresh 00:51:03
Botón derecho refresh para que se refresque 00:51:04
Y efectivamente 00:51:10
Nos ha aparecido 00:51:11
Nos ha aparecido aquí abajo un ficherito 00:51:12
Si lo abrimos 00:51:17
Tiene las líneas 00:51:21
Todas seguidas porque es que no he insertado 00:51:23
Saltos de línea barra n 00:51:25
Hubiera sido más bonito 00:51:26
Si hubiéramos hecho este 00:51:28
Código 00:51:31
Si hubiéramos hecho este código con 00:51:32
Cada vez que metíamos 00:51:37
Un string de estos 00:51:42
F write línea 00:51:43
Hubiéramos concatenado la línea 00:51:46
Con barra n 00:51:48
Entonces se hubiera escrito mejor 00:51:50
En el fichero 00:51:53
¿Verdad? Si lo volvemos a ejecutar 00:51:54
Introduzca nombre del fichero 00:51:58
Líneas 00:52:00
Fin 00:52:01
Se ha creado el archivo 00:52:05
Vamos a mirarlo 00:52:09
Este ya sí 00:52:10
Ya se ha creado más bonito 00:52:12
Venga, pues ahora sí que vamos a parar aquí un momentito 00:52:13
Subido por:
Raquel G.
Licencia:
Todos los derechos reservados
Visualizaciones:
10
Fecha:
25 de mayo de 2024 - 17:48
Visibilidad:
Clave
Centro:
IES ROSA CHACEL
Duración:
52′ 18″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
221.15 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid