Breaking

Post Top Ad

Your Ad Spot

martes, 9 de julio de 2019

Leyendo y escribiendo archivos en Java

Introducción

Al programar, ya sea que esté creando una aplicación móvil, una aplicación web o simplemente escribiendo guiones, a menudo tiene la necesidad de leer o escribir datos en un archivo en su aplicación. Estos datos podrían ser datos de caché, datos que recuperó para un conjunto de datos, una imagen o cualquier otra cosa que pueda imaginar.
En este tutorial, vamos a mostrar las formas más comunes en que puedes leer y escribir archivos en Java.
Java proporciona varias API (también conocidas como Java I / O ) para leer y escribir archivos desde sus versiones iniciales. Con versiones posteriores, Java I / O se ha mejorado, simplificado y mejorado para admitir nuevas funciones.
Antes de ver algunos ejemplos reales, sería útil comprender las clases disponibles que manejarán la lectura y escritura de datos en archivos. En las siguientes secciones, proporcionaremos una breve descripción general de las clases de E / S de Java y explicaremos lo que hacen, luego analizaremos las secuencias de Java NIO y, finalmente, mostraremos algunos ejemplos de lectura y escritura de datos para archivos.

Streams de E / S

Hay dos tipos de Streams que puedes usar para interactuar con archivos:
  1. Corrientes de caracteres
  2. Corrientes de bytes
Para cada uno de los tipos de flujo anteriores, hay varias clases de soporte enviadas con Java, que veremos rápidamente a continuación.

Corrientes de caracteres

Las secuencias de caracteres se utilizan para leer o escribir el tipo de datos de caracteres. Echemos un vistazo a las clases más utilizadas. Todas estas clases se definen en el java.iopaquete.
Aquí hay algunas clases que debe saber que se pueden usar para leer datos de personajes:
  • Lector : Una clase abstracta para leer un flujo de caracteres.
  • InputStreamReader : clase utilizada para leer el flujo de bytes y se convierte en flujo de caracteres.
  • FileReader : una clase para leer los caracteres de un archivo.
  • BufferedReader : este es un contenedor sobre la Readerclase que admite capacidades de almacenamiento en búfer. En muchos casos, esta es la clase más preferible para leer datos porque se pueden leer más datos del archivo en una read()llamada, lo que reduce el número de operaciones de E / S reales con el sistema de archivos.
Y aquí hay algunas clases que puede usar para escribirdatos de caracteres en un archivo:
  • Escritor : esta es una clase abstracta para escribir las secuencias de caracteres.
  • OutputStreamWriter : esta clase se utiliza para escribir secuencias de caracteres y también para convertirlas en secuencias de bytes.
  • FileWriter : una clase para escribir caracteres en el archivo.
  • BufferedWriter : este es un contenedor sobre la Writerclase, que también admite capacidades de almacenamiento en búfer. Esta es la clase más preferible para escribir datos en un archivo, ya que se pueden escribir más datos en el archivo en una sola write()llamada. Y como el BufferedReader, esto reduce el número de operaciones de E / S totales con el sistema de archivos.

Corrientes de bytes

Los flujos de bytes se utilizan para leer o escribir datos de bytes con archivos. Esto es diferente de antes en la forma en que tratan los datos. Aquí se trabaja con bytes sin procesar, que pueden ser caracteres, datos de imagen, datos Unicode (que requieren 2 bytes para representar un carácter), etc.
En esta sección veremos las clases más utilizadas. Todas estas clases se definen en el java.iopaquete.
Aquí están las clases usadas para leer los datos de bytes:
  • InputStream : una clase abstracta para leer los flujos de bytes.
  • FileInputStream : una clase para simplemente leer bytes de un archivo.
  • BufferedInputStream : este es un contenedor InputStreamque admite capacidades de almacenamiento en búfer. Como vimos en los flujos de caracteres, este es un método más eficiente que el FileInputStream.
Y aquí están las clases usadas para escribir los datos de bytes:
  • OutputStream : una clase abstracta para escribir flujos de bytes.
  • FileOutputStream : una clase para escribir bytes en bruto en el archivo.
  • ByteOutputStream : esta clase es un contenedor OutputStreampara admitir capacidades de almacenamiento en búfer. Y nuevamente, como vimos en los flujos de caracteres, este es un método más eficiente que FileOutputStreamgracias al almacenamiento en búfer.

Transmisiones de Java NIO

Java NIO es una API de E / S sin bloqueo que se introdujo en Java 4 y se puede encontrar en el java.niopaquete. En términos de rendimiento, esta es una gran mejora en la API para las operaciones de E / S. Los buffers, selectores y canales son los tres componentes principales de Java NIO, aunque en este artículo nos enfocaremos estrictamente en el uso de las clases NIO para interactuar con archivos, y no necesariamente los conceptos detrás de la API.
Como este tutorial es sobre leer y escribir archivos, analizaremos solo las clases relacionadas en esta breve sección:
  • Ruta : Esta es una estructura jerárquica de una ubicación de archivo real y generalmente se utiliza para localizar el archivo con el que desea interactuar.
  • Rutas : esta es una clase que proporciona varios métodos de utilidad para crear un PathURI de cadena dado.
  • Archivos : esta es otra clase de utilidad que tiene varios métodos para leer y escribir archivos sin bloquear la ejecución en subprocesos.
Usando estas pocas clases, puede interactuar fácilmente con archivos de una manera más eficiente.

La diferencia entre Java I / O y NIO

La principal diferencia entre estos dos paquetes es que las read()write()los métodos de Java IO son un bloqueo de las llamadas. Con esto queremos decir que el hilo que llama a uno de estos métodos se bloqueará hasta que los datos se hayan leído o escrito en el archivo.
Por otro lado, en el caso de NIO, los métodos son no bloqueantes. Esto significa que los subprocesos de llamada pueden realizar otras tareas (como leer / escribir datos de otra fuente o actualizar la interfaz de usuario) mientras los métodos readwriteesperan que se complete su operación. Esto puede resultar en un aumento significativo en el rendimiento si está tratando con muchas solicitudes de IO o con una gran cantidad de datos.

Ejemplos de leer y escribir archivos de texto

En las secciones anteriores, hemos hablado de las diferentes APIs proporcionadas por Java y ahora es finalmente tiempo para utilizar estas clases de API en algún código.
El código de ejemplo a continuación maneja la lectura y escritura de archivos de texto usando las diversas clases que detallamos anteriormente. Para simplificar las cosas, y proporcionar una mejor comparación de los métodos reales que se utilizan, la entrada y la salida se mantendrán iguales entre los ejemplos.
Nota : Para evitar confusiones en la ruta del archivo, el código de ejemplo leerá y escribirá desde un archivo en el directorio principal del usuario. El directorio de inicio del usuario se puede encontrar usando System.getProperty("user.home");, que es lo que usamos en nuestros ejemplos.
Ejemplo 1
Uso FileReaderFileWriterclases:
String directory = System.getProperty("user.home");  
String fileName = "sample.txt";  
String absolutePath = directory + File.separator + fileName;

// write the content in file 
try(FileWriter fileWriter = new FileWriter(absolutePath)) {  
    String fileContent = "This is a sample text.";
    fileWriter.write(fileContent);
} catch (IOException e) {
    // exception handling
}

// read the content from file
try(FileReader fileReader = new FileReader(absolutePath)) {  
    int ch = fileReader.read();
    while(ch != -1) {
        System.out.print((char)ch);
        ch = fileReader.read();
    }
} catch (FileNotFoundException e) {
    // exception handling
} catch (IOException e) {
    // exception handling
}
Ejemplo 2
Uso BufferedReaderBufferedWriterclases:
String directory = System.getProperty("user.home");  
String fileName = "sample.txt";  
String absolutePath = directory + File.separator + fileName;

// write the content in file 
try(BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(absolutePath))) {  
    String fileContent = "This is a sample text.";
    bufferedWriter.write(fileContent);
} catch (IOException e) {
    // exception handling
}

// read the content from file
try(BufferedReader bufferedReader = new BufferedReader(new FileReader(absolutePath))) {  
    String line = bufferedReader.readLine();
    while(line != null) {
        System.out.println(line);
        line = bufferedReader.readLine();
    }
} catch (FileNotFoundException e) {
    // exception handling
} catch (IOException e) {
    // exception handling
}
Ejemplo 3
Uso FileInputStreamFileOutputStreamclases:
String directory = System.getProperty("user.home");  
String fileName = "sample.txt";  
String absolutePath = directory + File.separator + fileName;

// write the content in file 
try(FileOutputStream fileOutputStream = new FileOutputStream(absolutePath)) {  
    String fileContent = "This is a sample text.";
    fileOutputStream.write(fileContent.getBytes());
} catch (FileNotFoundException e) {
    // exception handling
} catch (IOException e) {
    // exception handling
}

// reading the content of file
try(FileInputStream fileInputStream = new FileInputStream(absolutePath)) {  
    int ch = fileInputStream.read();
    while(ch != -1) {
        System.out.print((char)ch);
        ch = fileInputStream.read();
    }
} catch (FileNotFoundException e) {
    // exception handling
} catch (IOException e) {
    // exception handling
}
Ejemplo 4
Uso BufferedInputStreamBufferedOutputStreamclases:
String directory = System.getProperty("user.home");  
String fileName = "sample.txt";  
String absolutePath = directory + File.separator + fileName;

// write the content in file 
try(BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(absolutePath))) {  
    String fileContent = "This is a sample text.";
    bufferedOutputStream.write(fileContent.getBytes());
} catch (IOException e) {
    // exception handling
}

// read the content from file
try(BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(absolutePath))) {  
    int ch = bufferedInputStream.read();
    while(ch != -1) {
        System.out.print((char)ch);
        ch = bufferedInputStream.read();
    }
} catch (FileNotFoundException e) {
    // exception handling
} catch (IOException e) {
    // exception handling
}
Ejemplo 5
Usando las java.nioclases:
String directory = System.getProperty("user.home");  
String fileName = "sample.txt";

String content = "This is a sample text.";  
Path path = Paths.get(directory, fileName);

try {  
    Files.write(path, content.getBytes(), StandardOpenOption.CREATE);
} catch (IOException e) {
    // exception handling
}

try {  
    List<String> list = Files.readAllLines(path);
    list.forEach(line -> System.out.println(line));
} catch (IOException e) {
    // exception handling
}
Otra forma de recuperar el contenido a través de la Filesclase, que es más importante si no está leyendo datos de texto, es usar el readAllBytesmétodo para leer los datos en una matriz de bytes:
try {  
    byte[] data = Files.readAllBytes(path);
    System.out.println(new String(data));
} catch (IOException e) {
    // exception handling
}
En caso de que esté interesado en usar transmisiones con java.nio, también puede usar los siguientes métodos proporcionados por la Filesclase, que funcionan igual que las transmisiones que cubrimos anteriormente en el artículo:
Files.newBufferedReader(path)  
Files.newBufferedWriter(path, options)  
Files.newInputStream(path, options)  
Files.newOutputStream(path, options)  

Conclusión

En este artículo hemos cubierto las formas más comunes de leer y escribir datos en un archivo utilizando el paquete de E / S de Java y el paquete más nuevo de Java NIO. Siempre que sea posible, recomendamos utilizar las clases de Java NIO para las operaciones de archivos debido a su API no bloqueante, y además, el código es un poco más fácil de mantener y leer.

No hay comentarios.:

Publicar un comentario

Dejanos tu comentario para seguir mejorando!

Post Top Ad

Your Ad Spot

Páginas