Me sorprendió encontrar hoy que no podía rastrear ninguna forma simple de escribir el contenido de una InputStreama una OutputStreamen Java. Obviamente, el código de búfer de bytes no es difícil de escribir, pero sospecho que me falta algo que me facilitaría la vida (y el código más claro).

Entonces, dada una InputStream iny una OutputStream out, ¿hay una manera más simple de escribir lo siguiente?

byte[] buffer = new byte[1024];
int len = in.read(buffer);
while (len != -1) {
    out.write(buffer, 0, len);
    len = in.read(buffer);
}

Java 9

Desde Java 9, InputStreamproporciona un método llamado transferTocon la siguiente firma:

public long transferTo(OutputStream out) throws IOException

Como lo indica la documentacióntransferTo :

Lee todos los bytes de esta secuencia de entrada y los escribe en la secuencia de salida dada en el orden en que se leen. Al regresar, esta secuencia de entrada estará al final de la secuencia. Este método no cierra ninguna secuencia.

Este método puede bloquear la lectura indefinida de la secuencia de entrada o la escritura en la secuencia de salida. El comportamiento para el caso donde el flujo de entrada y / o salida se cierra asincrónicamente, o el hilo se interrumpe durante la transferencia, es altamente específico de flujo de entrada y salida, y por lo tanto no se especifica

Entonces, para escribir el contenido de un Java InputStreamen un OutputStream, puede escribir:

input.transferTo(output);

Como mencionó WMR, org.apache.commons.io.IOUtilsdesde Apache tiene un método llamado copy(InputStream,OutputStream)que hace exactamente lo que estás buscando.

Así que tienes:

InputStream in;
OutputStream out;
IOUtils.copy(in,out);
in.close();
out.close();

... en tu código.

¿Hay alguna razón por la que estás evitando IOUtils ?

Si está utilizando Java 7, los archivos (en la biblioteca estándar) son el mejor enfoque:

/* You can get Path from file also: file.toPath() */
Files.copy(InputStream in, Path target)
Files.copy(Path source, OutputStream out)

Editar: Por supuesto, es útil cuando crea uno de InputStream o OutputStream desde el archivo. Use file.toPath()para obtener la ruta del archivo.

Para escribir en un archivo existente (por ejemplo, uno creado con File.createTempFile()), deberá pasar la REPLACE_EXISTINGopción de copia (de lo contrario, FileAlreadyExistsExceptionse arroja):

Files.copy(in, target, StandardCopyOption.REPLACE_EXISTING)

Creo que esto funcionará, pero asegúrese de probarlo ... una "mejora" menor, pero podría ser un poco costoso en la legibilidad.

byte[] buffer = new byte[1024];
int len;
while ((len = in.read(buffer)) != -1) {
    out.write(buffer, 0, len);
}

Usando guayaba ByteStreams.copy():

ByteStreams.copy(inputStream, outputStream);

Función simple

Si solo necesita esto para escribir un InputStreama, Fileentonces puede usar esta función simple:

private void copyInputStreamToFile( InputStream in, File file ) {
    try {
        OutputStream out = new FileOutputStream(file);
        byte[] buf = new byte[1024];
        int len;
        while((len=in.read(buf))>0){
            out.write(buf,0,len);
        }
        out.close();
        in.close();
    } catch (Exception e) {
        e.printStackTrace();
    }
}

Los JDKutiliza el mismo código por lo que parece que no hay manera "fácil", sin bibliotecas torpe de terceros (que probablemente no hacer nada diferente de todos modos). Lo siguiente se copia directamente de java.nio.file.Files.java:

// buffer size used for reading and writing
private static final int BUFFER_SIZE = 8192;

/**
  * Reads all bytes from an input stream and writes them to an output stream.
  */
private static long copy(InputStream source, OutputStream sink) throws IOException {
    long nread = 0L;
    byte[] buf = new byte[BUFFER_SIZE];
    int n;
    while ((n = source.read(buf)) > 0) {
        sink.write(buf, 0, n);
        nread += n;
    }
    return nread;
}

PipedInputStreamy PipedOutputStreamsolo debe usarse cuando tiene varios subprocesos, como lo señala el Javadoc .

Además, tenga en cuenta que las secuencias de entrada y las secuencias de salida no envuelven las interrupciones de subprocesos con IOExceptions ... Por lo tanto, debe considerar incorporar una política de interrupción a su código:

byte[] buffer = new byte[1024];
int len = in.read(buffer);
while (len != -1) {
    out.write(buffer, 0, len);
    len = in.read(buffer);
    if (Thread.interrupted()) {
        throw new InterruptedException();
    }
}

Esta sería una adición útil si espera utilizar esta API para copiar grandes volúmenes de datos o datos de secuencias que se atascan durante un tiempo intolerablemente largo.

Para aquellos que usan Spring Framework, hay una clase útil de StreamUtils :

StreamUtils.copy(in, out);

Lo anterior no cierra las transmisiones. Si desea que las secuencias se cierren después de la copia, use la clase FileCopyUtils en su lugar:

FileCopyUtils.copy(in, out);

No hay manera de hacer esto mucho más fácil con los métodos JDK, pero como Apocalisp ya lo ha notado, no eres el único con esta idea: podrías usar IOUtils de Jakarta Commons IO , también tiene muchas otras cosas útiles, que la OMI debería ser parte del JDK ...

Usando Java7 y prueba con recursos , viene con una versión simplificada y legible.

try(InputStream inputStream = new FileInputStream("C:\\mov.mp4");
    OutputStream outputStream = new FileOutputStream("D:\\mov.mp4")) {

    byte[] buffer = new byte[10*1024];

    for (int length; (length = inputStream.read(buffer)) != -1; ) {
        outputStream.write(buffer, 0, length);
    }
} catch (FileNotFoundException exception) {
    exception.printStackTrace();
} catch (IOException ioException) {
    ioException.printStackTrace();
}

Aquí viene cómo lo estoy haciendo con el bucle más simple.

private void copy(final InputStream in, final OutputStream out)
    throws IOException {
    final byte[] b = new byte[8192];
    for (int r; (r = in.read(b)) != -1;) {
        out.write(b, 0, r);
    }
}

Use la clase Util de Commons Net:

import org.apache.commons.net.io.Util;
...
Util.copyStream(in, out);

Un fragmento de IMHO más mínimo (que también abarca de forma más estrecha la variable de longitud):

byte[] buffer = new byte[2048];
for (int n = in.read(buffer); n >= 0; n = in.read(buffer))
    out.write(buffer, 0, n);

Como nota al margen, no entiendo por qué más personas no utilizan un forbucle, sino que optan por una whileexpresión de asignación y prueba que algunos consideran un estilo "pobre".

Esta es mi mejor oportunidad !!

Y no lo use inputStream.transferTo(...)porque es demasiado genérico. El rendimiento de su código será mejor si controla su memoria de búfer.

public static void transfer(InputStream in, OutputStream out, int buffer) throws IOException {
    byte[] read = new byte[buffer]; // Your buffer size.
    while (0 < (buffer = in.read(read)))
        out.write(read, 0, buffer);
}

Lo uso con este método (mejorable) cuando sé de antemano el tamaño de la transmisión.

public static void transfer(int size, InputStream in, OutputStream out) throws IOException {
    transfer(in, out,
            size > 0xFFFF ? 0xFFFF // 16bits 65,536
                    : size > 0xFFF ? 0xFFF// 12bits 4096
                            : size < 0xFF ? 0xFF // 8bits 256
                                    : size
    );
}

Creo que es mejor usar un búfer grande, porque la mayoría de los archivos tienen más de 1024 bytes. También es una buena práctica verificar que el número de bytes leídos sea positivo.

byte[] buffer = new byte[4096];
int n;
while ((n = in.read(buffer)) > 0) {
    out.write(buffer, 0, n);
}
out.close();

Yo uso BufferedInputStreamy BufferedOutputStreampara eliminar la semántica del búfer del código

try (OutputStream out = new BufferedOutputStream(...);
     InputStream in   = new BufferedInputStream(...))) {
  int ch;
  while ((ch = in.read()) != -1) {
    out.write(ch);
  }
}

PipedInputStream y PipedOutputStream pueden ser de alguna utilidad, ya que puede conectar uno con el otro.

Otro posible candidato son las utilidades de E / S de guayaba:

http://code.google.com/p/guava-libraries/wiki/IOExplained

Pensé en usarlos, ya que Guava ya es inmensamente útil en mi proyecto, en lugar de agregar otra biblioteca para una función.

No es muy legible, pero efectivo, no tiene dependencias y se ejecuta con cualquier versión de Java

byte[] buffer = new byte[1024];
for (int n; (n = inputStream.read(buffer)) != -1; outputStream.write(buffer, 0, n));

public static boolean copyFile(InputStream inputStream, OutputStream out) {
    byte buf[] = new byte[1024];
    int len;
    long startTime=System.currentTimeMillis();

    try {
        while ((len = inputStream.read(buf)) != -1) {
            out.write(buf, 0, len);
        }

        long endTime=System.currentTimeMillis()-startTime;
        Log.v("","Time taken to transfer all bytes is : "+endTime);
        out.close();
        inputStream.close();

    } catch (IOException e) {

        return false;
    }
    return true;
}

Prueba Cactoos :

new LengthOf(new TeeInput(input, output)).value();

Más detalles aquí: http://www.yegor256.com/2017/06/22/object-oriented-input-output-in-cactoos.html

puedes usar este método

public static void copyStream(InputStream is, OutputStream os)
 {
     final int buffer_size=1024;
     try
     {
         byte[] bytes=new byte[buffer_size];
         for(;;)
         {
           int count=is.read(bytes, 0, buffer_size);
           if(count==-1)
               break;
           os.write(bytes, 0, count);
         }
     }
     catch(Exception ex){}
 }