Bien vamos a continuar una vez que ya hemos escrito información al archivo.
Ahora vamos a leer la información que hemos mandado a este archivo así que para ello vamos a agregar
otro método
creamos el método también va a ser Public Static de tipo Veidt y se va a llamar leer archivo también
recibe un nombre de archivo
vamos a crear nuestro objeto de tipo File
y le pasamos el nombre del archivo
aquí me faltó una R Street y ahora a diferencia de lo que hemos hecho hasta el momento vamos a utilizar
ahora la clase buffer Ridder para leer información del archivo para poder leer líneas completas y no
solamente carácter a carácter.
Así que utilizamos nuestra clase buffer Reeder
la variable se va a llamar entrada y creamos un nuevo objeto de tipo buffer Reeder y este constructor
necesita de un tipo Field Ridder así que vamos a crear un nuevo objeto de tipo Feil Rider ya que no
le podemos pasar directamente un objeto de tipo Feil y al constructor del objeto que estamos creando
de tipo fue el rider le pasamos el tipo FEIL que hemos creado anteriormente sin embargo esto puede arrojar
una excepción.
Por lo tanto la envolvemos en un bloque cazzo quitamos esta línea quitamos los importes que nos ha agregado
y mandamos a imprimir esta actuáis en dado caso de que exista y lo mandamos a la consola estándar así
que con esta línea lo que hemos hecho es crear un nuevo objeto de tipo buffer Rudder para poder leer
líneas completas y lo que vamos a hacer a continuación vamos a declarar una variable llamada lectura
utilizando nuestra variable entrada.
Vamos a utilizar el método RedLynx como hemos comentado esta clase nos permite leer líneas completas
sin embargo también este método puede arrojar otra excepción de tipo I o exception así que vamos a agregar
también este caché a nuestro bloque y caché que hayamos declarado así que damos clic y podemos ver que
ya nos agrega la excepción de tipo fue una excepción y también la excepción de tipo exception quitamos
esta línea y mandamos a imprimir esta actuáis en dado caso de cualquier error y lo mandamos a la consola
estándar quitamos estos Import y con eso ya tenemos nuestro bloque y caché completo.
Ahora con esto lo que estamos haciendo es únicamente leer una línea pero si queremos leer toda la información
del archivo entonces vamos a utilizar un ciclo cual
mientras la línea que hayamos leído del archivo sea distinto de nulo entonces vamos a continuar y lo
que vamos a hacer es mandar imprimir en la consola el contenido del archivo y volvemos a leer información
del archivo
entrada punto a Ridley y eso es lo que estamos haciendo es leer toda la información del archivo mientras
sea diferente de nulo.
Vamos a seguir imprimiendo la información del archivo hacia consola y cuando ya no tenga más información
que leer que ya sea la última línea de nuestro archivo entonces va a terminar este ciclo.
Y para terminar cerramos el flujo entrada apuntó Clowes.
Eso es todo nuestro método para leer información de un archivo.
Vamos a ponerlo a prueba
sin embargo debido a que ya creamos el archivo y ya escribimos información en el archivo vamos a poner
entre comentarios estos métodos para que ya no vuelva a realizar estas operaciones de momento únicamente
queremos leer información del archivo
así que utilizamos el método leer información guardamos cambios y ejecutamos y podemos observar todo
lo que contiene el archivo contenido a escribir en el archivo un salto de línea y posteriormente el
mensaje de fin de escritura que es exactamente la misma información que contiene el archivo así que
funcionó correctamente.
Nuestro método leer información del archivo y por último lo que vamos a hacer es anexar información
al archivo agregar información a un archivo ya existente.
Para ello vamos a crear el método siguiente tenemos el método Public Static Veidt anexar archivo
recibe un nombre de archivo creamos nuestro objeto File
creamos nuestro objeto de tipo primero either para escribir información al archivo la variable se llama
salida
y le pasamos el archivo que hemos recibido.
Esto puede arrojar una excepción la envolvemos en un bloque y.
Quitamos esta línea quitamos estos importes
imprimimos la pila decepciones
y a diferencia de los métodos que utilizamos anteriormente por ejemplo para escribir información archivo
en el cual utilizamos el constructor print Reiter y la pasamos directamente el objeto file.
En este caso vamos a hacer un cambio en lugar de pasarle directamente el objeto File lo que vamos a
hacer es crear un nuevo objeto de tipo FEUE Ritter
le pasamos el nombre del archivo que es un objeto de tipo File y además vamos a indicar que vamos a
agregar información a este archivo.
Por ello vamos a utilizar este constructor en el cual tiene otro parámetro el parámetro de APEN que
es un tipo booleano y si ponemos el valor de Tru entonces la información que agregamos este archivo
se va a anexar al archivo ya existente así que ponemos Tru para que en lugar de que se escriba la información
el archivo se anexa a la información ya existente del archivo sin embargo esto puede arrojar otra decepción.
Así que agregamos este cacho a nuestro bloque y catch ya existente.
Quitamos esta línea quitamos los Import y mandamos a imprimir la pila decepciones en dado caso de que
exista y lo mandamos a la consola estándar así que con eso ya estamos procesando a un exception y también
la acepción de tipo o Repsol.
Y entonces con esto lo que estamos haciendo es abrir un flujo pero vamos a anexar información al archivo
no se va sobreescribir la información sino que vamos a anexar información así que declaramos la variable
de tipo string contenido y agregamos lo siguiente anexando información al archivo
utilizando nuestra variable salidad usamos nuestro mismo método ln y escribimos el contenido.
Posteriormente imprimimos un salto de línea
y mandamos otro mensaje mandamos la cadena a fin de anexar y finalmente cerramos el flujo para que se
escriba esta información al archivo.
De lo contrario no se va a guardar los cambios en el archivo y mandamos el mensaje sea anexado
la información al archivo bien con eso ya tenemos todos los cambios guardamos cambios y vamos a poner
a prueba el método que hemos creado.
Ponemos entre comentarios todo lo anterior
y ahora vamos a anexar información al archivo así que mandamos a llamar el método anexar archivo le
pasamos el mismo número de archivo y para poder saber la información que hemos agregado volvemos a llamar
el método leer del archivo
así que vamos a guardar cambios y ejecutamos
y podemos observar el mensaje de que se ha anexado la información correctamente al Archivo y posteriormente
leemos el contenido del archivo contenido a escribir en el archivo y fin de escritura que era lo que
ya teníamos en el Archivo y posteriormente lo nuevo que se ha anexado anexando información archivo espacio
a fin de anexar.
Así que con esto ya se ha modificado correctamente nuestro archivo.
Vamos a cerrar este archivo para poder ver los cambios cerramos el archivo y volvemos a abrirlo.
Y podemos observar lo que ya teníamos anteriormente que ya habíamos escrito y ahora lo nuevo donde se
ha anexado información al archivo ya existente
así que con esto ya está funcionando correctamente todos los métodos que hemos programado para realizar
varias operaciones sobre un archivo en Java bien así que con este ejercicio hemos puesto en práctica
el concepto de manejo de archivos en Java.
Hemos visto varias operaciones como son crear un archivo escribir leer y anexar información a un archivo.
Con eso ya tenemos las bases para entender mejor el funcionamiento de manejo de archivos en Java eso
es todo por esta elección y nos vemos en el siguiente video.
Saludos.