¿Cómo convertir InputStream a Byte Array en Java?

En Java, el flujo de entrada se refiere a un flujo ordenado de datos en forma de bytes. Este flujo de datos puede provenir de varios recursos, como archivos, programas de red, dispositivos de entrada, etc. Para leer dichos datos, tenemos una clase Java InputStream en la API Java IO. Hay varios métodos para convertir este flujo de entrada en una array de bytes (o byte []) que se puede usar cuando sea necesario. Ahora veremos algunos métodos para hacer lo mismo que se enumeran a continuación:

Métodos:

1. Usando read(byte[]) o readAllBytes()
2. Uso de la clase ByteArrayOutputStream
3. Uso de la clase de utilidad ByteStreams
4. Uso de la biblioteca Apache Commons IO

Ahora discutiremos todos y cada uno de los métodos para detallar en orden y comprender la implementación del mismo a través de programas java limpios de la siguiente manera:

Método 1: Usando read(byte[]) o readAllBytes()

En la clase InputStream , tenemos un método read() en el que se puede pasar una array de bytes como parámetro para obtener los datos del flujo de entrada en forma de array de bytes. Pero este método tiene la desventaja de que puede leer los datos como máximo del tamaño de la array pasada como parámetro. Funciona bien solo si conocemos el tamaño de los datos entrantes de antemano. El método devuelve un valor int igual al número de bytes leídos en la array o -1 si se alcanza el final del flujo.

Sintaxis: 

Lectura de declaración (byte [])

public int read​(byte[] byteArray)
throws IOException

Para superar el inconveniente de tener que conocer el tamaño de entrada de antemano, tenemos otro método llamado readAllBytes() desde Java 9. Este método puede leer todos los bytes disponibles en el flujo de entrada. El método es mucho más rápido y eficiente al convertir el flujo de entrada en una array de bytes.

Sintaxis: readAllBytes()

public byte[] readAllBytes()
throws IOException

Ejemplo

// Java Program to Convert InputStream to Byte Array
// Using read(byte[]) or readAllBytes()
  
// Importing required classes
import java.io.*;
import java.nio.charset.StandardCharsets;
  
// Main class
class GFG {
  
    // Main driver method
    public static void main(String[] args)
    {
        // Creating a Input Stream here
        // Usually it comes from files, programs
        InputStream inputStream = new ByteArrayInputStream(
            "GeeksForGeeks".getBytes(
                StandardCharsets.UTF_8));
  
        // Taking the InputStream data into a byte array
        byte[] byteArray = null;
  
        // Try block to check for exceptions
        try {
            byteArray = inputStream.readAllBytes();
        }
  
        // Catch block to handle the exceptions
        catch (IOException e) {
  
            // Print and dispal ythe exceptions
            System.out.println(e);
        }
  
        // Iterating over using for each loop
        for (byte b : byteArray)
  
            // Printing the content of byte array
            System.out.print((char)b + " ");
    }
}

G e e k s F o r G e e k s 

Ejemplo 2: uso de la clase ByteArrayOutputStream

Este es un método indirecto de conversión de datos de flujo de entrada en una array de bytes. Aquí usaremos un objeto de la clase ByteArrayOutputStream como búfer. Para esto, leemos cada byte de una clase InputStream y lo escribimos en una clase ByteArrayOutputStream. Luego llamamos a ByteArray() que devuelve el flujo de salida en forma de una array de bytes.

Ejemplo 

// Java Program to Convert InputStream to Byte Array
// Using ByteArrayOutputStream Class
  
// Importing required classes
import java.io.*;
import java.nio.charset.StandardCharsets;
  
// Main class
class GFG {
  
    // Main driver method
    public static void main(String[] args)
    {
        // Creating a Input Stream here (usually it comes
        // from files, programs, etc.)
        InputStream inputStream = new ByteArrayInputStream(
            "GeeksForGeeks".getBytes(
                StandardCharsets.UTF_8));
  
        // Taking the InputStream data into a byte array
        // output stream
  
        // Buffer size taken to be 1000 say.
        byte[] buffer = new byte[1000];
  
        // Creating an object of ByteArrayOutputStream class
        ByteArrayOutputStream byteArrayOutputStream
            = new ByteArrayOutputStream();
  
        // Try block to check for exceptions
        try {
            int temp;
  
            while ((temp = inputStream.read(buffer))
                   != -1) {
                byteArrayOutputStream.write(buffer, 0,
                                            temp);
            }
        }
  
        // Catch block to handle the exceptions
        catch (IOException e) {
  
            // Display the exception/s on the console
            System.out.println(e);
        }
  
        // Mow converting byte array output stream to byte
        // array
        byte[] byteArray
            = byteArrayOutputStream.toByteArray();
  
        // Iterating over using for each loop
        for (byte b : byteArray)
  
            // Printing the content of byte array
            System.out.print((char)b + " ");
    }
}

G e e k s F o r G e e k s 

Método 3: usar la clase de utilidad ByteStreams

La clase de utilidad ByteStreams de Guava Library tiene un método directo para convertir el flujo de entrada en una array de bytes.

Java de código abierto

Ejemplo

// Java Program to Convert InputStream to Byte Array
// Using ByteArrayOutputStream Class
  
// Importing required classes, here additionally
// We are importing from Guava Library
import com.google.common.io.ByteStreams;
import java.io.*;
import java.nio.charset.StandardCharsets;
  
// Main class
class GFG {
  
    // Main driver method
    public static void main(String[] args)
    {
        // Creating a Input Stream here
        // usually it comes from files, programs
        InputStream inputStream = new ByteArrayInputStream(
            "GeeksForGeeks".getBytes(
                StandardCharsets.UTF_8));
  
        // Taking the InputStream data into a byte array
        // using ByteStreams
        byte[] byteArray = null;
  
        // Try block to check for exceptions
        try {
            byteArray
                = ByteStreams.toByteArray(inputStream);
        }
  
        // Catch block to handle the exceptions
        catch (IOException e) {
  
            // Display the exceptions on the console window
            System.out.println(e);
        }
  
        // Iterating over using for each loop
        for (byte b : byteArray)
  
            // Printing the content of byte array
            System.out.print((char)b + " ");
    }
}

Método 4: Uso de la biblioteca Apache Commons IO

Este método es muy similar al uso de la clase ByteStreams. Aquí hacemos uso de la clase IOUtils que tiene un método similar con el mismo nombre a ByteArray() que devuelve los datos del flujo de entrada como una array de bytes. El mismo uso, solo necesitamos usar import org.apache.commons.io.IOUtils en lugar de ByteStreams of Guava Library.

Sintaxis: 

byte[] byteArray = IOUtils.toByteArray(inputStream); 

Nota: Sin embargo, este método a menudo necesita la adición de dependencia al editor.