Ich war überrascht, heute festzustellen, dass ich keine einfache Möglichkeit finden konnte, den Inhalt eines zu schreiben InputStream eines OutputStreamin Java . Natürlich ist der Byte-Puffer-Code nicht schwer zu schreiben, aber ich vermute, ich vermisse nur etwas, das mein Leben einfacher machen würde (und den Code klarer macht).

Gibt es also angesichts von InputStream inund OutputStream outeine einfachere Möglichkeit, Folgendes zu schreiben?

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

Java 9

InputStreamBietet seit Java 9 eine Methode transferTomit der folgenden Signatur:

public long transferTo(OutputStream out) throws IOException

Wie in der Dokumentation angegeben , transferTowird:

Liest alle Bytes aus diesem Eingabestream und schreibt die Bytes in der angegebenen Reihenfolge in den angegebenen Ausgabestream. Bei der Rückkehr befindet sich dieser Eingabestream am Ende des Streams. Diese Methode schließt keinen Stream.

Diese Methode kann das unbegrenzte Lesen aus dem Eingabestream oder das Schreiben in den Ausgabestream blockieren. Das Verhalten für den Fall, dass der Eingabe- und / oder Ausgabestream asynchron geschlossen oder der Thread während der Übertragung unterbrochen wird, ist stark spezifisch für den Eingabe- und Ausgabestream und daher nicht angegeben

Um also den Inhalt eines Java InputStreamin einen zu schreiben OutputStream, können Sie schreiben:

input.transferTo(output);

Wie WMR erwähnt hat, hat org.apache.commons.io.IOUtilsApache eine Methode namens, copy(InputStream,OutputStream)die genau das tut, wonach Sie suchen.

Also hast du:

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

... in Ihrem Code.

Gibt es einen Grund, den Sie vermeiden IOUtils?

Wenn Sie Java 7 verwenden, ist Dateien (in der Standardbibliothek) der beste Ansatz:

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

Bearbeiten: Natürlich ist es nur nützlich, wenn Sie einen InputStream oder OutputStream aus einer Datei erstellen. Verwenden Sie file.toPath()diese Option , um den Pfad aus der Datei abzurufen.

Um in eine vorhandene Datei zu schreiben (z. B. eine, die mit erstellt wurde File.createTempFile()), müssen Sie die REPLACE_EXISTINGKopieroption übergeben (andernfalls FileAlreadyExistsExceptionwird sie ausgelöst):

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

Ich denke, das wird funktionieren, aber stellen Sie sicher, dass Sie es testen ... geringfügige "Verbesserung", aber es könnte ein bisschen teuer für die Lesbarkeit sein.

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

Verwenden von Guaven ByteStreams.copy():

ByteStreams.copy(inputStream, outputStream);

Einfache Funktion

Wenn Sie dies nur zum Schreiben eines InputStreaman a benötigen File, können Sie diese einfache Funktion verwenden:

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

Das JDKverwendet den gleichen Code, so dass es den Anschein hat, als gäbe es keinen "einfacheren" Weg ohne klobige Bibliotheken von Drittanbietern (die wahrscheinlich sowieso nichts anderes machen). Folgendes wird direkt kopiert von 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;
}

PipedInputStreamund PipedOutputStreamsollte nur verwendet werden, wenn Sie mehrere Threads haben, wie vom Javadoc angegeben .

Beachten Sie außerdem, dass Eingabestreams und Ausgabestreams keine Thread-Unterbrechungen mit IOExceptions umschließen. Sie sollten daher in Betracht ziehen, eine Unterbrechungsrichtlinie in Ihren Code aufzunehmen:

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

Dies ist eine nützliche Ergänzung, wenn Sie diese API zum Kopieren großer Datenmengen oder von Daten aus Streams verwenden möchten, die unerträglich lange hängen bleiben.

Für diejenigen, die das Spring Framework verwenden, gibt es eine nützliche StreamUtils- Klasse:

StreamUtils.copy(in, out);

Das Obige schließt die Streams nicht. Wenn Sie möchten, dass die Streams nach dem Kopieren geschlossen werden, verwenden Sie stattdessen die FileCopyUtils- Klasse:

FileCopyUtils.copy(in, out);

Es gibt keine Möglichkeit, dies mit JDK-Methoden viel einfacher zu machen, aber wie Apocalisp bereits bemerkt hat, sind Sie nicht der einzige mit dieser Idee: Sie könnten IOUtils von Jakarta Commons IO verwenden , es hat auch viele andere nützliche Dinge, dass IMO eigentlich Teil des JDK sein sollte ...

Mit Java7 und Try-with-Resources wird eine vereinfachte und lesbare Version geliefert .

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

Hier kommt, wie ich es mit der einfachsten for-Schleife mache.

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

Verwenden Sie die Util-Klasse von Commons Net:

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

Ein meiner Meinung nach minimaleres Snippet (das auch die Längenvariable enger zusammenfasst):

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

Als Randnotiz verstehe ich nicht, warum mehr Leute keine forSchleife verwenden, sondern sich für einen whilemit einem Zuweisungs- und Testausdruck entscheiden, der von einigen als "schlechter" Stil angesehen wird.

Das ist mein bester Schuss !!

Und nicht verwenden, inputStream.transferTo(...)weil es zu allgemein ist. Ihre Codeleistung ist besser, wenn Sie Ihren Pufferspeicher steuern.

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

Ich benutze es mit dieser (verbesserungsfähigen) Methode, wenn ich die Größe des Streams im Voraus kenne.

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

Ich denke, es ist besser, einen großen Puffer zu verwenden, da die meisten Dateien größer als 1024 Bytes sind. Es ist auch eine gute Praxis, die Anzahl der gelesenen Bytes zu überprüfen, um positiv zu sein.

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

Ich benutze BufferedInputStreamund BufferedOutputStream, um die Puffersemantik aus dem Code zu entfernen

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

PipedInputStream und PipedOutputStream können von Nutzen sein, da Sie eine Verbindung miteinander herstellen können.

Ein weiterer möglicher Kandidat sind die Guava I / O-Dienstprogramme:

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

Ich dachte, ich würde diese verwenden, da Guava in meinem Projekt bereits sehr nützlich ist, anstatt eine weitere Bibliothek für eine Funktion hinzuzufügen.

Nicht sehr lesbar, aber effektiv, hat keine Abhängigkeiten und läuft mit jeder Java-Version

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

Probieren Sie Kakteen :

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

Weitere Details hier: http://www.yegor256.com/2017/06/22/object-oriented-input-output-in-cactoos.html

Sie können diese Methode verwenden

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