Java - Archivos y E/S

El paquete java.io contiene casi todas las clases que pueda necesitar para realizar entradas y salidas (E/S) en Java. Todos estos flujos representan una fuente de entrada y un destino de salida. El flujo en el paquete java.io admite muchos datos, como primitivos, objetos, caracteres localizados, etc.

Transmisión

Un flujo se puede definir como una secuencia de datos. Hay dos tipos de Streams −

Flujo de entrada − El InputStream se utiliza para leer datos de una fuente.
Flujo de salida − El OutputStream se utiliza para escribir datos en un destino.

Java proporciona un soporte sólido pero flexible para la E/S relacionada con archivos y redes, pero este tutorial cubre una funcionalidad muy básica relacionada con los flujos y la E/S. Veremos los ejemplos más utilizados uno por uno −

Flujos de bytes

Los flujos de bytes de Java se utilizan para realizar entradas y salidas de bytes de 8 bits. Aunque hay muchas clases relacionadas con flujos de bytes, las clases más utilizadas son FileInputStream y FileOutputStream . El siguiente es un ejemplo que hace uso de estas dos clases para copiar un archivo de entrada en un archivo de salida:

Ejemplo

import java.io.*;
public class CopyFile {

   public static void main(String args[]) throws IOException {  
      FileInputStream in = null;
      FileOutputStream out = null;

      try {
         in = new FileInputStream("input.txt");
         out = new FileOutputStream("output.txt");
         
         int c;
         while ((c = in.read()) != -1) {
            out.write(c);
         }
      }finally {
         if (in != null) {
            in.close();
         }
         if (out != null) {
            out.close();
         }
      }
   }
}

Ahora tengamos un archivo input.txt con el siguiente contenido −

This is test for copy file.

Como siguiente paso, compile el programa anterior y ejecútelo, lo que dará como resultado la creación de un archivo output.txt con el mismo contenido que tenemos en input.txt. Así que pongamos el código anterior en el archivo CopyFile.java y hagamos lo siguiente −

$javac CopyFile.java
$java CopyFile

Flujos de personajes

Java Byte flujos se utilizan para realizar la entrada y salida de bytes de 8 bits, mientras que Java Character Los flujos se utilizan para realizar entradas y salidas para Unicode de 16 bits. Aunque hay muchas clases relacionadas con flujos de caracteres, las clases más utilizadas son FileReader y FileWriter . Aunque internamente FileReader usa FileInputStream y FileWriter usa FileOutputStream, aquí la principal diferencia es que FileReader lee dos bytes a la vez y FileWriter escribe dos bytes a la vez.

Podemos volver a escribir el ejemplo anterior, que utiliza estas dos clases para copiar un archivo de entrada (que tiene caracteres Unicode) en un archivo de salida −

Ejemplo

import java.io.*;
public class CopyFile {

   public static void main(String args[]) throws IOException {
      FileReader in = null;
      FileWriter out = null;

      try {
         in = new FileReader("input.txt");
         out = new FileWriter("output.txt");
         
         int c;
         while ((c = in.read()) != -1) {
            out.write(c);
         }
      }finally {
         if (in != null) {
            in.close();
         }
         if (out != null) {
            out.close();
         }
      }
   }
}

Ahora tengamos un archivo input.txt con el siguiente contenido −

This is test for copy file.

$javac CopyFile.java
$java CopyFile

Transmisiones estándar

Todos los lenguajes de programación brindan soporte para E/S estándar donde el programa del usuario puede tomar entradas desde un teclado y luego producir una salida en la pantalla de la computadora. Si conoce C o C++ lenguajes de programación, debe conocer los tres dispositivos estándar STDIN, STDOUT y STDERR. De manera similar, Java proporciona los siguientes tres flujos estándar:

Entrada estándar − Esto se usa para alimentar los datos al programa del usuario y, por lo general, se usa un teclado como flujo de entrada estándar y se representa como System.in .
Salida estándar − Esto se usa para generar los datos producidos por el programa del usuario y, por lo general, se usa una pantalla de computadora para el flujo de salida estándar y se representa como System.out .
Error estándar − Esto se usa para generar los datos de error producidos por el programa del usuario y, por lo general, se usa una pantalla de computadora para el flujo de error estándar y se representa como System.err .

El siguiente es un programa simple, que crea InputStreamReader para leer el flujo de entrada estándar hasta que el usuario escriba una "q" −

Ejemplo

Demostración en vivo

import java.io.*;
public class ReadConsole {

   public static void main(String args[]) throws IOException {
      InputStreamReader cin = null;

      try {
         cin = new InputStreamReader(System.in);
         System.out.println("Enter characters, 'q' to quit.");
         char c;
         do {
            c = (char) cin.read();
            System.out.print(c);
         } while(c != 'q');
      }finally {
         if (cin != null) {
            cin.close();
         }
      }
   }
}

Mantengamos el código anterior en el archivo ReadConsole.java e intentemos compilarlo y ejecutarlo como se muestra en el siguiente programa. Este programa continúa leyendo y generando el mismo carácter hasta que presionamos 'q' −

$javac ReadConsole.java
$java ReadConsole
Enter characters, 'q' to quit.
1
1
e
e
q
q

Lectura y escritura de archivos

Como se describió anteriormente, un flujo se puede definir como una secuencia de datos. El Flujo de entrada se utiliza para leer datos de una fuente y el OutputStream se utiliza para escribir datos en un destino.

Aquí hay una jerarquía de clases para manejar flujos de entrada y salida.

Los dos flujos importantes son FileInputStream y FileOutputStream , que se tratará en este tutorial.

Flujo de entrada de archivos

Esta secuencia se utiliza para leer datos de los archivos. Los objetos se pueden crear usando la palabra clave nuevo y hay varios tipos de constructores disponibles.

El siguiente constructor toma un nombre de archivo como una cadena para crear un objeto de flujo de entrada para leer el archivo −

InputStream f = new FileInputStream("C:/java/hello");

El siguiente constructor toma un objeto de archivo para crear un objeto de flujo de entrada para leer el archivo. Primero creamos un objeto de archivo usando el método File() de la siguiente manera −

File f = new File("C:/java/hello");
InputStream f = new FileInputStream(f);

Una vez que tenga InputStream objeto en la mano, hay una lista de métodos auxiliares que se pueden usar para leer en la transmisión o para realizar otras operaciones en la transmisión.

Sr.No.	Método y descripción
1	public void close() lanza IOException{} Este método cierra el flujo de salida del archivo. Libera cualquier recurso del sistema asociado con el archivo. Lanza una IOException.
2	protected void finalize() lanza IOException {} Este método limpia la conexión con el archivo. Garantiza que se llame al método de cierre de este flujo de salida de archivo cuando no haya más referencias a este flujo. Lanza una IOException.
3	public int read(int r) lanza IOException{} Este método lee el byte de datos especificado de InputStream. Devuelve un int. Devuelve el siguiente byte de datos y se devolverá -1 si es el final del archivo.
4	public int read(byte[] r) lanza IOException{} Este método lee r.length bytes del flujo de entrada en una matriz. Devuelve el número total de bytes leídos. Si es el final del archivo, se devolverá -1.
5	public int available() lanza IOException{} Proporciona el número de bytes que se pueden leer de este flujo de entrada de archivos. Devuelve un int.

Hay otros flujos de entrada importantes disponibles, para obtener más detalles, puede consultar los siguientes enlaces −

ByteArrayInputStream
Flujo de entrada de datos

Flujo de salida de archivo

FileOutputStream se utiliza para crear un archivo y escribir datos en él. La secuencia crearía un archivo, si aún no existe, antes de abrirlo para la salida.

Aquí hay dos constructores que se pueden usar para crear un objeto FileOutputStream.

El siguiente constructor toma un nombre de archivo como una cadena para crear un objeto de flujo de entrada para escribir el archivo −

OutputStream f = new FileOutputStream("C:/java/hello")

El siguiente constructor toma un objeto de archivo para crear un objeto de flujo de salida para escribir el archivo. Primero, creamos un objeto de archivo usando el método File() de la siguiente manera −

File f = new File("C:/java/hello");
OutputStream f = new FileOutputStream(f);

Una vez que tenga OutputStream objeto en la mano, luego hay una lista de métodos auxiliares, que se pueden usar para escribir en la transmisión o para realizar otras operaciones en la transmisión.

Sr.No.	Método y descripción
1	public void close() lanza IOException{} Este método cierra el flujo de salida del archivo. Libera cualquier recurso del sistema asociado con el archivo. Lanza una IOException.
2	protected void finalize() lanza IOException {} Este método limpia la conexión con el archivo. Garantiza que se llame al método de cierre de este flujo de salida de archivo cuando no haya más referencias a este flujo. Lanza una IOException.
3	public void write(int w) lanza IOException{} Este método escribe el byte especificado en el flujo de salida.
4	escritura pública nula (byte[] w) Escribe w.length bytes de la matriz de bytes mencionada en OutputStream.

Hay otros flujos de salida importantes disponibles, para obtener más detalles, puede consultar los siguientes enlaces −

ByteArrayOutputStream
Flujo de salida de datos

Ejemplo

El siguiente es el ejemplo para demostrar InputStream y OutputStream −

import java.io.*;
public class fileStreamTest {

   public static void main(String args[]) {
   
      try {
         byte bWrite [] = {11,21,3,40,5};
         OutputStream os = new FileOutputStream("test.txt");
         for(int x = 0; x < bWrite.length ; x++) {
            os.write( bWrite[x] );   // writes the bytes
         }
         os.close();
     
         InputStream is = new FileInputStream("test.txt");
         int size = is.available();

         for(int i = 0; i < size; i++) {
            System.out.print((char)is.read() + "  ");
         }
         is.close();
      } catch (IOException e) {
         System.out.print("Exception");
      }	
   }
}

El código anterior crearía el archivo test.txt y escribiría los números dados en formato binario. Lo mismo sería la salida en la pantalla de salida estándar.

Navegación de archivos y E/S

Hay varias otras clases por las que estaríamos pasando para conocer los conceptos básicos de navegación de archivos y E/S.

Clase de archivo
Clase de lector de archivos
Clase FileWriter

Directorios en Java

Un directorio es un archivo que puede contener una lista de otros archivos y directorios. Usas Archivo objeto para crear directorios, para enumerar los archivos disponibles en un directorio. Para obtener detalles completos, consulte una lista de todos los métodos a los que puede llamar en el objeto Archivo y lo que está relacionado con los directorios.

Creación de directorios

Hay dos útiles Archivo métodos de utilidad, que se pueden utilizar para crear directorios −

El mkdir() El método crea un directorio, devolviendo verdadero en caso de éxito y falso en caso de falla. El error indica que la ruta especificada en el objeto Archivo ya existe o que el directorio no se puede crear porque la ruta completa aún no existe.
Los mkdirs() El método crea tanto un directorio como todos los padres del directorio.

El siguiente ejemplo crea el directorio "/tmp/user/java/bin" −

Ejemplo

import java.io.File;
public class CreateDir {

   public static void main(String args[]) {
      String dirname = "/tmp/user/java/bin";
      File d = new File(dirname);
      
      // Create directory now.
      d.mkdirs();
   }
}

Compile y ejecute el código anterior para crear "/tmp/user/java/bin".

Nota − Java se ocupa automáticamente de los separadores de ruta en UNIX y Windows según las convenciones. Si usa una barra inclinada (/) en una versión de Windows de Java, la ruta aún se resolverá correctamente.

Listado de directorios

Puede usar lista() método proporcionado por File objeto para enumerar todos los archivos y directorios disponibles en un directorio de la siguiente manera −

Ejemplo

import java.io.File;
public class ReadDir {

   public static void main(String[] args) {
      File file = null;
      String[] paths;
  
      try {      
         // create new file object
         file = new File("/tmp");

         // array of files and directory
         paths = file.list();

         // for each name in the path array
         for(String path:paths) {
            // prints filename and directory name
            System.out.println(path);
         }
      } catch (Exception e) {
         // if any error occurs
         e.printStackTrace();
      }
   }
}

Esto producirá el siguiente resultado basado en los directorios y archivos disponibles en su /tmp directorio −

Salida

test1.txt
test2.txt
ReadDir.java
ReadDir.class

Java - Métodos Java - Excepciones

Java