Sono stato sorpreso di scoprire oggi che non sono riuscito a rintracciare un modo semplice per scrivere il contenuto di an InputStreamin an OutputStreamin Java. Ovviamente, il codice del buffer di byte non è difficile da scrivere, ma sospetto che mi manchi qualcosa che mi renderebbe la vita più semplice (e il codice più chiaro).

Quindi, dati un InputStream ine un OutputStream out, c'è un modo più semplice per scrivere quanto segue?

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

Java 9

Da Java 9, InputStreamfornisce un metodo chiamato transferTocon la seguente firma:

public long transferTo(OutputStream out) throws IOException

Come indica la documentazionetransferTo :

Legge tutti i byte da questo flusso di input e li scrive nel flusso di output specificato nell'ordine in cui sono letti. Al ritorno, questo flusso di input sarà alla fine del flusso. Questo metodo non chiude nessuno dei flussi.

Questo metodo può bloccare la lettura indefinita dal flusso di input o la scrittura nel flusso di output. Il comportamento nel caso in cui il flusso di input e / o output sia chiuso in modo asincrono, o il thread interrotto durante il trasferimento, è altamente specifico del flusso di input e output, e quindi non specificato

Quindi, per scrivere i contenuti di un Java InputStreamsu un OutputStream, è possibile scrivere:

input.transferTo(output);

Come menzionato WMR, org.apache.commons.io.IOUtilsda Apache ha un metodo chiamato copy(InputStream,OutputStream)che fa esattamente quello che stai cercando.

Quindi hai:

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

... nel tuo codice.

C'è un motivo che stai evitando IOUtils?

Se si utilizza Java 7, File (nella libreria standard) è l'approccio migliore:

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

Modifica: ovviamente è utile solo quando si crea uno di InputStream o OutputStream da un file. Utilizzare file.toPath()per ottenere il percorso dal file.

Per scrivere in un file esistente (ad esempio uno creato con File.createTempFile()), devi passare l' REPLACE_EXISTINGopzione di copia (altrimenti FileAlreadyExistsExceptionviene generata):

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

Penso che funzionerà, ma assicurati di testarlo ... "miglioramento" minore, ma potrebbe essere un po 'un costo in leggibilità.

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

Utilizzando Guava ByteStreams.copy():

ByteStreams.copy(inputStream, outputStream);

Funzione semplice

Se hai solo bisogno di questo per scrivere un InputStreamin Fileallora puoi usare questa semplice funzione:

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();
    }
}

Gli JDKusi lo stesso codice così sembra che non v'è alcun modo "facile" senza librerie di terze parti goffo (che probabilmente non fa nulla di diverso in ogni caso). Quanto segue viene copiato direttamente da 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;
}

PipedInputStreame PipedOutputStreamdovrebbe essere usato solo quando hai più thread, come notato da Javadoc .

Inoltre, tieni presente che i flussi di input e di output non racchiudono alcuna interruzione di thread con IOExceptions ... Quindi, dovresti considerare di incorporare una politica di interruzione nel tuo codice:

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();
    }
}

Questa sarebbe un'aggiunta utile se si prevede di utilizzare questa API per copiare grandi volumi di dati o dati da flussi che rimangono bloccati per un periodo intollerabilmente lungo.

Per coloro che usano il framework Spring c'è un'utile classe StreamUtils :

StreamUtils.copy(in, out);

Quanto sopra non chiude i flussi. Se vuoi che gli stream vengano chiusi dopo la copia, utilizza invece la classe FileCopyUtils :

FileCopyUtils.copy(in, out);

Non c'è modo di farlo molto più facilmente con i metodi JDK, ma come ha già notato Apocalisp, non sei l'unico con questa idea: potresti usare IOUtils di Jakarta Commons IO , ma ha anche molte altre cose utili, che l'IMO dovrebbe effettivamente far parte del JDK ...

Utilizzando Java7 e provare con le risorse , viene fornita una versione semplificata e leggibile.

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();
}

Ecco come sto andando con il più semplice per loop.

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);
    }
}

Usa la classe Util di Commons Net:

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

Uno snippet più minimale di IMHO (che ha anche una portata più stretta della variabile lunghezza):

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

Come nota a margine, non capisco perché più persone non usano un forciclo, invece optando per un whilecon un'espressione di assegnazione e prova che è considerata da alcuni come uno stile "povero".

Questo è il mio miglior scatto !!

E non usare inputStream.transferTo(...)perché è troppo generico. Le prestazioni del codice saranno migliori se controlli la memoria buffer.

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 questo metodo (migliorabile) quando conosco in anticipo le dimensioni del flusso.

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
    );
}

Penso che sia meglio usare un buffer di grandi dimensioni, perché la maggior parte dei file è superiore a 1024 byte. Inoltre è buona norma verificare che il numero di byte letti sia positivo.

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

Uso BufferedInputStreame BufferedOutputStreamper rimuovere la semantica di buffering dal codice

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

PipedInputStream e PipedOutputStream possono essere di qualche utilità, in quanto è possibile connettersi l'uno all'altro.

Un altro possibile candidato sono le utility di I / O di Guava:

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

Ho pensato di usarli poiché Guava è già immensamente utile nel mio progetto, piuttosto che aggiungere un'altra libreria per una funzione.

Non molto leggibile, ma efficace, non ha dipendenze e funziona con qualsiasi versione di 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;
}

Prova Cactoos :

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

Maggiori dettagli qui: http://www.yegor256.com/2017/06/22/object-oriented-input-output-in-cactoos.html

puoi usare questo metodo

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){}
 }