Convierta InputStream al objeto de archivo en Java

1. Use Java simple para convertir InputStream en el objeto File
2. Utilice el método Files.copy() para convertir InputStream en el objeto File en Java
3. Utilice el método InputStream.transferTo() para convertir InputStream en el objeto File en Java
4. Use Apache Commons IO API para convertir InputStream en el objeto File en Java

Frecuentemente tenemos que hacer archivos y agregarles contenido. Por ejemplo, necesitamos guardar los bytes recibidos a través de la red o los elementos String en un archivo.

En cada caso, los datos están presentes como InputStream y deben escribirse en un archivo. El tutorial de hoy trata sobre cómo convertir InputStream en el objeto File en Java.

Para eso, escribiremos diferentes códigos de ejemplo utilizando diferentes formas de convertir InputStream en el objeto File, dependiendo de nuestra versión de Java. Algunos de los enfoques se dan a continuación:

Use Java simple para convertir InputStream en el objeto File

Código de ejemplo:

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class plainJava {
  public static void main(String[] args) {
    try {
      InputStream inputStream = new FileInputStream(new File("./files/test.txt"));

      byte[] buffer = new byte[inputStream.available()];
      inputStream.read(buffer);

      File destinationFile = new File("./files/test-plainJava-output.txt");

      OutputStream outputStream = new FileOutputStream(destinationFile);
      outputStream.write(buffer);

    } catch (FileNotFoundException exception) {
      exception.printStackTrace();
    } catch (IOException exception) {
      exception.printStackTrace();
    }
  }
}

Instanciamos el FileInputStream en el programa Java anterior especificando la ruta del archivo. Generará una excepción FileNotFoundException si el archivo no existe o lo hemos escrito mal.

Estamos usando FileInputStream para recuperar los bytes de entrada del archivo dado. Luego, creamos una matriz llamada buffer de tipo byte donde el método inputStream.available() indica la cantidad de bytes que podemos leer hasta que la llamada read() bloquee el flujo de ejecución del programa.

Después de eso, instanciamos la clase File para crear el archivo test-plainJava-output.txt y guardamos su referencia en la variable destinationFile. A continuación, creamos un objeto de FileOutputStream, pasamos la referencia del archivo de destino que creamos en el paso anterior y escribimos el código byte.

Ahora, abra los archivos test.txt y test-plainJava-output.txt y vea que ambos tienen el mismo contenido. Recuerde, podemos obtener la IOException si tenemos algún problema al leer o escribir información.

Utilice el método Files.copy() para convertir InputStream en el objeto File en Java

Código de ejemplo:

import java.io.IOException;
import java.io.InputStream;
import java.net.URI;
import java.nio.file.Files;
import java.nio.file.Paths;

public class filesCopy {
  private static final String OUTPUT_FILE = "./files/test_filesCopy-output.txt";

  public static void main(String[] args) {
    URI u = URI.create("https://www.google.com/");

    try (InputStream inputStream = u.toURL().openStream()) {
      // Java 1.7 onwards
      Files.copy(inputStream, Paths.get(OUTPUT_FILE));
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

Podemos usar este enfoque en Java 7 o superior. En la cerca de código anterior, estamos usando Files.copy() de Java NIO API que se usa para copiar el objeto InputStream al objeto File como se demostró anteriormente.

En el programa filesCopy, primero creamos un objeto de tipo String para contener la ruta del archivo de salida.

En el método main(), creamos un objeto URI utilizando el método create() y guardamos su referencia en la variable u, que se utilizará en el siguiente paso. Recuerde, usamos create() cuando estamos seguros de que el valor de cadena especificado se analizará como un objeto URI; de lo contrario, se consideraría culpa del programador.

A continuación, usamos el objeto URI u para llamar al método toURL() para construir una URL a partir de este URI y usamos el método openStream() para obtener el objeto java.io.InputSteam. Después de eso, usamos el método Files.copy(), que toma dos parámetros, el objeto inputStream y una Ruta del archivo, donde queremos copiar los datos.

Ahora, veremos los datos analizados en nuestro archivo de salida, test_filesCopy-output.txt en nuestro caso. Usamos el bloque try-catch para manejar la excepción si ocurre alguna; de lo contrario, el programa terminará la ejecución.

Utilice el método InputStream.transferTo() para convertir InputStream en el objeto File en Java

Código de ejemplo:

import java.io.*;
import java.net.URI;

public class inputStreamTransferTo {
  public static void main(String[] args) {
    URI u = URI.create("https://www.google.com/");

    try (InputStream inputStream = u.toURL().openStream()) {
      File outputFile = new File("./files/test_transferTo-output.txt");
      OutputStream outputStream = new FileOutputStream(outputFile, false);
      inputStream.transferTo(outputStream); // Java 9

    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

Podemos usar este enfoque si tenemos Java 9 o posterior. Este ejemplo de código es similar al anterior donde usamos el método Files.copy() excepto por algunas diferencias en el bloque try.

Aquí, creamos un objeto de la clase Archivo especificando el archivo de salida, test_transferTo-output.txt en nuestro caso. Luego, usamos este objeto File para instanciar la clase FileOutputStream, que usaremos para escribir datos en nuestro archivo de salida (test_transferTo_output.txt).

Finalmente, usamos el método inputStream.transferTo(), que toma un flujo de salida como parámetro y copia directamente inputStream al outputSteam especificado. Ahora, tendrá los datos analizados en el archivo de salida, test_transferTo_output.txt.

También encerramos este código dentro del bloque try-catch para evitar la terminación del programa.

Use Apache Commons IO API para convertir InputStream en el objeto File en Java

Código de ejemplo:

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.URI;
import org.apache.commons.io.FileUtils;

public class apacheCommons {
  public static void main(String[] args) throws IOException {
    URI u = URI.create("https://www.google.com/");
    try (InputStream inputStream = u.toURL().openStream()) {
      File outputFile = new File("./files/test_apache_output.txt");
      // commons-io
      FileUtils.copyInputStreamToFile(inputStream, outputFile);
    }
  }
}

Este código de ejemplo es similar a los anteriores. Creamos un objeto URI para llamar a toURL, que creará una URL a través de este objeto URI, obtendrá el objeto java.io.InputStream usando el método openStream() e instanciará el Archivo class que apunta a una ruta para nuestro archivo de salida que es test_apache_output.txt aquí.

Pero estamos usando la API Apache Commons IO para convertir el flujo de entrada al objeto de archivo en Java. Esta API es muy útil y proporciona varias funcionalidades para realizar diferentes operaciones de entrada/salida de archivos.

Para usar esta biblioteca, primero debemos agregar la dependencia commons-io en el archivo pom.xml de la siguiente manera:

<dependency>
      <groupId>commons-io</groupId>
      <artifactId>commons-io</artifactId>
      <version>2.7</version>
</dependency>

Luego, podemos usar el método copyInputStreamToFile() para leer bytes de un flujo de entrada y copiarlos en el archivo especificado. Ahora, puede ver los datos analizados en el archivo test_apache_output.txt, que es un archivo de salida.