Tutorial de E/S de Java

El lenguaje de programación Java viene con una variedad de API que ayudan a los desarrolladores a codificar de manera más eficiente. Una de esas API es Java IO API. Java IO API ayuda a los usuarios a leer y escribir datos. En palabras simples, podemos decir que Java IO ayuda a los usuarios a tomar la entrada y producir una salida basada en esa entrada. Casi todas las aplicaciones o códigos requieren alguna entrada y salida producida en base a esa entrada. Entonces, comencemos con el Tutorial de Java IO .

Java I/O (entrada y salida) se utiliza para procesar la entrada y producir la salida . Java utiliza el concepto de flujo para acelerar las operaciones de E/S. El paquete java.io contiene todas las clases necesarias para las operaciones de entrada y salida. Podemos realizar el manejo de archivos en Java mediante la API de E/S de Java.

La API Java IO se coloca en el paquete java.io. Este paquete comprende casi todas las clases que un usuario necesita para realizar operaciones de entrada y salida (E/S) en Java. El paquete Java IO se enfoca en la entrada y salida de archivos, flujos de red, etc. Sin embargo, el paquete Java IO no incluye clases para abrir sockets de red que son esenciales para la comunicación de red. 

El paquete java.io generalmente implica leer información básica de una fuente y escribirla en un destino. La siguiente figura demuestra perfectamente el principio de un programa que toma datos de entrada de una fuente y produce una salida basada en ellos hacia algún destino. 

Flujos de E/S de Java

En el mundo de la programación, un flujo puede describirse como una serie de datos. Se le conoce como arroyo porque es similar a un chorro de agua que continúa fluyendo. Los flujos de E/S de Java son flujos de datos que un usuario puede leer o escribir. Al igual que una array, una secuencia no tiene el concepto de indexar los datos de lectura o escritura. Un flujo se adjunta a un origen de datos o un destino de datos.

Java Streams utiliza dos flujos principales para leer y escribir los datos. Estos son:

1. InputStream: se utiliza un flujo de entrada para leer los datos de una fuente en una aplicación Java. Los datos pueden ser cualquier cosa, un archivo, una array, un dispositivo periférico o un socket. En Java, la clase java.io.InputStream es la clase base para todos los flujos de entrada de Java IO.

Métodos de Java IO InputStreams

1. read(): el método read() se utiliza para leer el siguiente byte de datos del flujo de entrada. El byte de valor se pasa en una escala de 0 a 255. Si no hay ningún byte libre porque ha llegado el final del flujo, se pasa el valor -1.
    
2. mark(int arg) – El método mark(int arg) se utiliza para marcar la posición actual del flujo de entrada. Establece el límite de lectura, es decir, el número máximo de bytes que se pueden leer antes de que la posición de la marca se vuelva inválida.
    
3. reset() – El método reset() es invocado por el método mark(). Cambia la posición del flujo de entrada de nuevo a la posición marcada.
    
4. close(): el método close() se usa para cerrar el flujo de entrada y libera los recursos del sistema asociados con este flujo a Garbage Collector.
    
5. read(byte [] arg) – El método read(byte [] arg) se utiliza para leer el número de bytes de arg.length desde el flujo de entrada hasta la array de búfer arg. Los bytes leídos por el método read() se devuelven como un int. Si la longitud es cero, entonces no se leen bytes y se devuelve 0 a menos que haya un esfuerzo por leer al menos un byte.
    
6. skip(long arg) – El método skip(long arg) se usa para omitir y descartar bytes arg en el flujo de entrada.
    
7. markSupported(): el método markSupported() comprueba si inputStream es compatible con los métodos de marcar y restablecer. El método markSupported de Java IO InputStream genera falso de forma predeterminada.

Ejemplo de Java IO InputStream:

// Java program illustrates the use of
// the Java IO InputStream methods
 
import java.io.*;
   
public class InputStreamExample
{
    public static void main(String[] args) throws Exception
    {
        InputStream input = null;
        try {
   
            input = new FileInputStream("Text.txt");
   
            // read() method - reading and printing Characters
            // one by one
            System.out.println("Char - "+(char)input.read());
            System.out.println("Char - "+(char)input.read());
   
            // mark() - read limiting the 'input' input stream
            input.mark(0);
   
            // skip() - it results in skipping of 'e' in Ge'e'ksforGeeks
            input.skip(1);
            System.out.println("skip() method comes to play");
            System.out.println("mark() method comes to play");
            System.out.println("Char - "+(char)input.read());
            System.out.println("Char - "+(char)input.read());
   
            boolean check = input.markSupported();
            if (input.markSupported())
            {
                // reset() method - repositioning the stream to
                // marked positions.
                input.reset();
                System.out.println("reset() invoked");
                System.out.println("Char - "+(char)input.read());
                System.out.println("Char - "+(char)input.read());
            }
            else
                System.out.println("reset() method not supported.");
   
   
            System.out.println("input.markSupported() supported"+
                              " reset() - "+check);
   
        }
        catch(Exception e)
        {
            // in case of I/O error
            e.printStackTrace();
        }
        finally
        {
            if (input!=null)
            {
                // Use of close() - closing the file
                // and releasing resources
                input.close();
            }
        }
    }
}

El archivo Text.txt utilizado en el código anterior tiene el siguiente contenido: 

GeeksforGeeks

Producción:

Nota: este código no se ejecutará en un IDE en línea ya que dicho archivo no está presente allí. Puede ejecutar este código en su sistema para comprobar que funciona.

2. Flujo de salida– Se utiliza un flujo de salida para escribir datos (un archivo, una array, un dispositivo periférico o un socket) en un destino. En Java, la clase java.io.OutputStream es la clase base para todos los flujos de salida de Java IO.

Métodos de Java IO OutputStreams

1. flush(): el método flush() se utiliza para vaciar el flujo de salida. Este método fuerza la escritura de los bytes de salida almacenados en el búfer.
    
2. close(): el método close() se usa para cerrar el flujo de salida y liberar los recursos del sistema afiliados al flujo.
    
3. write(int b) – El método write(int b) se usa para escribir el byte especificado en el flujo de salida.
    
4. write(byte [] b) – El método write(byte [] b) se usa para escribir bytes de longitud b.length desde la array de bytes especificada al flujo de salida.
    

// Java program to demonstrate OutputStream
import java.io.*;
 
public class OutputStreamExample {
    public static void main(String args[]) throws Exception
    {
        OutputStream output
            = new FileOutputStream("file.txt");
        byte b[] = { 65, 66, 67, 68, 69, 70 };
 
        // illustrating write(byte[] b) method
        output.write(b);
 
        // illustrating flush() method
        output.flush();
 
        // illustrating write(int b) method
        for (int i = 71; i < 75; i++) {
            output.write(i);
        }
 
        output.flush();
 
        // close the stream
        output.close();
    }
}

Salida: Cuando ejecutamos el programa, el archivo file.txt se llena con el siguiente contenido.

ABCDEFGHIJ

Nota: este código no se ejecutará en un IDE en línea ya que dicho archivo no está presente allí. Puede ejecutar este código en su sistema para comprobar que funciona.

Tipos de flujos en Java IO 

Los Streams en Java IO son de los siguientes tipos:

1. Flujos de bytes: los flujos de bytes de Java son los que se utilizan para implementar la entrada y salida de bytes de 8 bits. Varias clases están afiliadas con flujos de bytes en Java. Sin embargo, las clases que se practican con mayor frecuencia son FileInputStream y FileOutputStream .

Diferentes clases de flujos de bytes

2. Secuencias de caracteres: las secuencias de caracteres de Java son las que se utilizan para implementar la entrada y salida para Unicode de 16 bits. Varias clases están asociadas con flujos de caracteres en Java, pero las clases más utilizadas son FileReader y FileWriter . Internamente, la clase FileReader usa FileInputStream y la clase FileWriter usa FileOutputStream. Sin embargo, el contraste significativo es que FileReader y FileWriter leen y escriben dos bytes, respectivamente.

Diferentes clases de flujos de caracteres:

3. Secuencias estándar: todos los lenguajes de programación admiten E/S estándar, donde el programa del usuario puede recibir entradas de un teclado y luego producir una salida en la pantalla de la computadora. Al igual que C y C++ tienen tres flujos estándar, STDIN, STDOUT y STDERR, Java también proporciona los siguientes tres flujos estándar:
 

• Entrada estándar: la clase Entrada estándar se utiliza para aceptar datos de entrada en el programa del usuario. Por lo general, se utiliza un teclado como flujo de entrada estándar y se describe como System.in .
   
• Salida estándar: esta clase se usa para generar los datos generados por el programa del usuario y, por lo general, se usa una pantalla de computadora para el flujo de salida estándar y se describe como System.out .
   
• Error estándar: la clase de error estándar se utiliza para generar los datos que tienen un error generado por el programa del usuario. Normalmente, una pantalla de computadora se utiliza para el flujo de error estándar y se describe como System.err .
   

Ejemplo de flujos estándar en Java IO

// Java program to illustrate
// the Standard Java IO Streams
 
import java.io.*;
import java.util.*;
 
public class StandardStreamsExample {
    public static void main(String[] args)
    {
        try {
 
            // using System.in class to import the Scanner
            // that helps in taking input from the user
            Scanner s = new Scanner(System.in);
 
            // using System.out class print the output on
            // the screen using .print() ans .println()
            // methods
            System.out.print("Enter the value of A : ");
            int a = s.nextInt();
            System.out.println("Value of A is : " + a);
 
            System.out.print("Enter the value of B : ");
            int b = s.nextInt();
            System.out.println("Value of B is : " + b);
 
            System.out.println(
                "Result of division A/B is : " + (a / b));
        }
        catch (Exception ex) {
 
            // using System.err class to print the error
            // message
            System.err.print("Exception message : "
                             + ex.getMessage());
        }
    }
}

Producción

Consola Java IO

La clase Java.io.Console implementa programas para recibir el dispositivo de consola basado en caracteres, si lo hay, afiliado a la máquina virtual Java predominante. La clase Console se agregó al paquete java.io en Java Development Kit 6 (JDK 6).

La clase Java Console se utiliza para recibir entradas de la consola. Presenta métodos para leer textos y contraseñas. Si un usuario lee la contraseña usando la clase Console, no se le revelará al usuario. La clase java.io.Console está conectada internamente a la consola del sistema. 

Características de la consola Java IO

• Java IO Console se usa para leer y escribir en la consola, si existe.
• La consola es fundamentalmente una clase de soporte porque la mayor parte de su funcionalidad se puede lograr a través de System.in y System.out . Sin embargo, su efectividad puede aclarar algunas interacciones de la consola, particularmente al leer strings desde la consola.
• La consola no tiene constructores. En cambio, si un usuario desea obtener un objeto Consola, puede hacerlo llamando a System.console().
• Si hay una consola disponible, se devuelve una referencia de esa consola. De lo contrario, se devuelve nulo. Una clase de consola no es factible en todos los casos. Por lo tanto, en caso de que no haya consola, se devuelve nulo.

Métodos de la consola Java IO

Lector y escritor Java IO

Los flujos de entrada y salida se basan fundamentalmente en bytes. Java IO Reader y Writer depende de los caracteres, que pueden tener amplitudes variables según el conjunto de caracteres. Por ejemplo, ASCII e ISO Latin-1 manejan caracteres de un byte. Unicode utiliza caracteres de dos bytes. UTF-8 maneja caracteres de diferentes amplitudes (entre uno y tres bytes). Como los caracteres finalmente se componen de bytes, los lectores practican su entrada de secuencias. Sin embargo, transforman esos bytes en caracteres de acuerdo con una configuración de codificación particular antes de capturarlos. Además, los escritores transforman los caracteres en bytes de acuerdo con una codificación particularizada antes de escribirlos en cualquier flujo subyacente.

Las clases java.io.Reader y java.io.Writer son superclases abstractas. Estas superclases ayudan a leer y escribir datos basados ​​en caracteres. Estas subclases son importantes para administrar la transformación entre varios conjuntos de caracteres. En la API Java IO, hay nueve clases de lector y ocho de escritor , todas en el paquete java.io.

Lector de E/S de Java

Un lector se utiliza cuando un usuario desea leer datos basados ​​en caracteres de una fuente de datos. La clase Java IO Reader es una clase abstracta que se utiliza para expresar flujos de caracteres. Los únicos programas que una subclase necesita implementar son los métodos read(char[], int, int) y close(). Muchas subclases de la clase Reader anularán algunos de los métodos que se muestran a continuación. Sin embargo, la mayoría de las subclases producen una enorme eficiencia, funcionalidad adicional o ambas.

Métodos de Java IO Reader

1. close(): este método se utiliza para cerrar la transmisión y liberar los recursos del sistema asociados. Una vez que se ha cerrado la secuencia, las invocaciones de métodos adicionales como read(), mark() o skip() arrojarán una IOException. En Java IO, cerrar una transmisión que finalizó antes no tiene ningún efecto.
    
2. mark (int readAheadLimit): este método se utiliza para verificar el lugar actual en la transmisión. Las siguientes llamadas al método reset() intentarán cambiar la posición de la transmisión a este punto. En Java IO Reader, todos los flujos de entrada de caracteres no admiten la operación mark().
    
3. markSupported(): este proceso determina si este flujo admite la operación mark() o no. La implementación predeterminada siempre devuelve falso. Todas las subclases de Java IO Reader deberían llamar a este método.
    
4. read(): este método se utiliza para leer un solo carácter. El método read() está obstruido hasta que un carácter es factible, ocurre un error de E/S o finaliza la transmisión. Todas las subclases de la clase Java IO Reader que tienen la intención de mantener una entrada adecuada de un solo carácter deben anular este método.
    
5. read(char[] cbuf) – Este método se usa para leer caracteres en una array. Este método está obstruido hasta que es posible obtener cierta información, se produce un error de E/S o se alcanza el final de la secuencia.
    
6. read(char[] cbuf, int off, int len) – Este método se usa para leer los caracteres en una parte de una array. Este método está obstruido hasta que un carácter es factible, ocurre un error de E/S o finaliza la transmisión. 
    
7. read (objetivo de CharBuffer): este método se esfuerza por leer caracteres dentro del búfer de caracteres particularizado. El destino del búfer se utiliza como un contenedor de caracteres.
    
8.  ready(): este método se usa para saber si esta transmisión está lista para ser leída.
    
9. reset(): este método se utiliza para restablecer la transmisión. Si se ha marcado el flujo, este método intenta reposicionar el flujo en la marca. Si la transmisión no se ha verificado, intente restablecerla de alguna manera relevante para la transmisión adecuada, por ejemplo, generalmente utilizada reposicionándola en su punto de inicio. No todos los flujos de entrada de caracteres soportan el proceso reset(), y algunos ayudan al reset() sin mantener mark().
    
10. skip(long n) – Este método se usa para saltar caracteres. Este método está bloqueado hasta que haya información disponible, se produzca un error de E/S o se alcance el final de la secuencia.

Diferentes clases de Java IO Reader

Ejemplo de Java IO Reader

// Java Program to illustrate the
// use of Java IO Reader methods
import java.io.*;
 
public class ReaderExample {
    public static void main(String[] args) {
 
        // Creates a character array of size 100.
        char[] array = new char[100];
 
        try {
            // Creating a reader object using the class FileReader
            Reader input = new FileReader("file.txt");
 
            // Checks if reader is ready
            System.out.println("Is there data in the stream?  " + input.ready());
 
            // Reads characters
            input.read(array);
            System.out.println("Data in the stream -");
            System.out.println(array);
 
            // Closes the reader
            input.close();
        }
 
        catch(Exception e) {
            e.getStackTrace();
        }
    }
}

El archivo file.txt utilizado en el código anterior tiene el siguiente contenido:

Hello Geeks.

Producción

Nota: este código no se ejecutará en un IDE en línea ya que dicho archivo no está presente allí. Puede ejecutar este código en su sistema para comprobar que funciona.

Escritor de E/S de Java

Java IO Writer es una clase abstracta utilizada para escribir en los flujos de caracteres. Los únicos métodos en Java IO Writer que una subclase debe implementar son write(char[], int, int), flush() y close(). Sin embargo, la mayoría de las subclases anularán varios métodos explicados aquí para implementar una mayor eficiencia, funcionalidad adicional o ambos.

Métodos de Java IO Writer:

1. append(char c) – Este método se usa para agregar el carácter particularizado al escritor. Una invocación de este proceso de la forma out.append(c) funciona de la misma manera que la invocación – out.write(c). 
    
2. append(CharSequence csq): este método se usa para agregar la secuencia de caracteres designada al escritor. Una invocación de este proceso de la forma out.append(csq) funciona exactamente con el mismo estilo que la invocación – out.write(csq.toString()).
    
3. append(CharSequence csq, int start, int end): este método se usa para agregar una subsecuencia de la secuencia de caracteres particularizada al escritor. Agrega una subsecuencia de la secuencia de caracteres detallada al escritor.
    
4. close(): este método se usa para cerrar la transmisión, vaciándola primero. Una vez que se ha detenido la transmisión, los métodos adicionales write() o flush() provocarán que se lance una IOException. En Java IO Writer, cerrar un flujo cerrado anterior no tiene ningún efecto.
    
5. flush(): este método se usa para vaciar la transmisión. Si la secuencia ha conservado algún carácter de los múltiples métodos write() en un búfer, deben escribirse inmediatamente en el destino propuesto. Después de eso, si ese destino es un carácter diferente o un flujo de bytes, debe vaciarse. Por lo tanto, un método de invocación flush() eliminará todas las barreras o búferes en una serie de Writers y OutputStreams.
    
6. write(char[] cbuf) – Este método se usa para escribir una array de caracteres.
    
7. write(char[] cbuf, int off, int len): este método se utiliza para escribir una parte de una array de caracteres.
    
8. write(int c) – Este método se usa para imprimir un carácter individual. El carácter que se va a reescribir se muestra en los 16 bits de orden inferior del valor entero proporcionado. Significa que se ignoran los 16 bits de orden superior. Las subclases que pretenden admitir una salida eficiente de un solo carácter deben anular este método.
    
9. write(String str, int off, int len) – Este método se usa para escribir una parte de una string.

Diferentes clases de Java IO Writer

La lista de diferentes clases de Java IO Writer se proporciona a continuación:

Ejemplo de Java IO Writer

// Java Program to illustrate the
// use of Java IO Writer methods
import java.io.*;
 
public class WriterExample {
 
    public static void main(String args[]) {
 
        String data = "Hello Geeks.";
 
        try {
            // Creates a Writer using FileWriter
            Writer output = new FileWriter("file.txt");
 
 
            // Writes string to the file
            output.write(data);
 
            // Closes the writer
            output.close();
        }
 
        catch (Exception e) {
            e.getStackTrace();
        }
    }
}

Producción

Cuando ejecutamos el programa, el archivo file.txt se llena con el siguiente contenido.

Hello Geeks.

Nota: este código no se ejecutará en un IDE en línea ya que dicho archivo no está presente allí. Puede ejecutar este código en su sistema para comprobar que funciona.

Archivo E/S de Java

La clase Java IO File es la descripción de Java de un archivo o nombre de ruta de un directorio. Dado que los nombres de archivos y directorios tienen arreglos distintivos en varias plataformas, una string ingenua no es suficiente para describirlos. La clase File comprende varios enfoques para operar con el nombre de ruta, eliminar y renombrar archivos, generar nuevos directorios, organizar el contenido de una lista y administrar numerosas propiedades generales de archivos y directorios.

Características del archivo Java IO

• Java IO File es una ilustración ideal de archivos y nombres de ruta de directorios.
• Un nombre de ruta, ya sea general o en un patrón de string, puede ser fijo o contingente. El origen de un nombre de ruta ideal puede lograrse invocando el proceso getParent() de la clase Java IO File.
• En primer lugar, un usuario debe crear un objeto de la clase File dándole el nombre del archivo o del directorio. Un método de archivo puede ejecutar limitaciones a acciones específicas en el objeto real del sistema de archivos, como lectura y escritura. Estas restricciones se identifican colectivamente como permisos de acceso.
• Las instancias de la clase File son inmutables. Es decir, una vez creado, la ruta de acceso abstracta denotada por un objeto File nunca más cambiará.

Métodos del archivo Java IO

1. canExecute(): este método se utiliza para examinar si la aplicación puede ejecutar el archivo expresado por el nombre de ruta abstracto.
    
2. canWrite(): este método se utiliza para probar si la aplicación puede transformar el archivo expresado por el nombre de ruta abstracto o no.
    
3. canRead(): este método se utiliza para examinar si la aplicación puede leer el archivo indicado por el nombre de ruta abstracto.
    
4. getName(): este método se utiliza para devolver el nombre del archivo o directorio indicado por la ruta de acceso abstracta.
    
5. getPath(): este método se utiliza para convertir el nombre de ruta abstracto en una string de nombre de ruta.
    
6. getAbsolutePath(): este método se utiliza para devolver la string de nombre de ruta absoluto del nombre de ruta abstracto.
    
7. getParent(): este método se utiliza para devolver la string de nombre de ruta del padre del nombre de ruta abstracto.
    
8. existe(): este método se utiliza para probar si el archivo o directorio expresado por el nombre de ruta abstracto existe o no.
    
9. length(): este método se utiliza para devolver la longitud del archivo indicada por la ruta de acceso abstracta.
    
10. isDirectory(): este método se utiliza para comprobar si el archivo indicado por la ruta de acceso es un directorio.

Ejemplo de archivo Java IO

// Java program to illustrate the use
// of Java IO File methods
 
import java.io.File;
 
public class FileExample
{
    public static void main(String[] args) {
 
        // taking the file or directory as a input
        // from the command line argument (args)
        String fname =args[0];
   
        // passing the file or directory name to File object
        File f = new File(fname);
   
        // applying the methods of the File
        // class on the File object
        System.out.println("File name - "+f.getName());
        System.out.println("Path - "+f.getPath());
        System.out.println("Absolute path - " +f.getAbsolutePath());
        System.out.println("Parent - "+f.getParent());
        System.out.println("Exists - "+f.exists());
         
    if(f.exists())
        {
            System.out.println("Is writable - "+f.canWrite());
            System.out.println("Is readable - "+f.canRead());
            System.out.println("Is a directory - "+f.isDirectory());
            System.out.println("File Size in bytes "+f.length());
        }
    }
}

Producción

El archivo Geeks.txt utilizado en el código anterior tiene el siguiente contenido:

Hello Geeks

Nota: este código no se ejecutará en un IDE en línea ya que dicho archivo no está presente allí. Puede ejecutar este código en su sistema para comprobar que funciona.