Jak wspomniano WMR, org.apache.commons.io.IOUtils z Apache ma metodę zwaną copy(InputStream,OutputStream) co robi dokładnie to, czego szukasz.

Więc masz:

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

...w Twoim kodzie.

Czy jest jakiś powód, dla którego unikasz IOUtils?

Myślę, że to zadziała, ale upewnij się, że przetestujesz... niewielka "poprawa", ale może to być trochę koszt czytelności.

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

Java 9

Od wersji Java 9, InputStream dostarcza metodę o nazwie transferTo z następującym podpisem:

public long transferTo(OutputStream out) throws IOException

Jak stwierdza dokumentacja, transferTo będzie:

Odczytuje wszystkie bajty z tego strumienia wejściowego i zapisuje bajty do podany strumień wyjściowy w kolejności, w jakiej są odczytywane. Po powrocie, to strumień wejściowy będzie na końcu strumienia. Ta metoda nie zamyka albo strumień.

Ta metoda może blokować w nieskończoność odczyt z wejście stream lub zapis do strumienia wyjściowego. Zachowanie dla przypadek, w którym strumień wejściowy lub wyjściowy jest asynchronicznie zamknięty, lub wątek przerwany podczas transferu, jest wysoce wejściowy i wyjściowy strumień specyficzny, a zatem nie określony

Więc aby napisać zawartość Javy InputStream do OutputStream, możesz napisać:

input.transferTo(output);

Używanie guawy ByteStreams.copy():

ByteStreams.copy(inputStream, outputStream);

Prosta Funkcja

Jeśli potrzebujesz tego tylko do napisania InputStream do File, możesz użyć tej prostej funkcji:

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

PipedInputStream i PipedOutputStream powinny być używane tylko wtedy, gdy masz wiele wątków, jak zauważył Javadoc .

Należy również pamiętać, że strumienie wejściowe i wyjściowe nie zawierają przerw w wątku za pomocą IOExceptions... Dlatego powinieneś rozważyć włączenie polityki przerwania do swojego kodu:

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

Byłoby to przydatne, jeśli spodziewasz się używać tego API do kopiowania dużych ilości danych lub danych ze strumieni, które utkną przez nietolerancyjnie długi czas.

JDK używa tego samego kodu, więc wydaje się, że nie ma "łatwiejszego" sposobu bez niezgrabnych bibliotek stron trzecich (które i tak pewnie nic nie robią inaczej). Poniżej jest bezpośrednio skopiowane z 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;
    }

Nie ma sposobu, aby zrobić to dużo łatwiej z metodami JDK, ale jak Apocalisp już zauważył, nie jesteś jedynym z tym pomysłem: możesz użyć IOUtils z Jakarta Commons IO, ma również wiele innych przydatnych rzeczy, które IMO powinny być częścią JDK...

Korzystanie z Java7 i try-with-resources , pochodzi z uproszczoną i czytelną wersją.

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

Dla tych, którzy używają Spring framework istnieje przydatna StreamUtils klasa:

StreamUtils.copy(in, out);

Powyższe nie zamyka strumieni. Jeśli chcesz, aby strumienie były zamknięte po skopiowaniu, Użyj klasy FileCopyUtils :

FileCopyUtils.copy(in, out);

Użyj klasy Util Commons Net:

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

Oto jak sobie radzę z najprostszą pętlą for.

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

Myślę, że lepiej jest użyć dużego bufora, ponieważ większość plików jest większa niż 1024 bajty. Dobrą praktyką jest również sprawdzanie, czy liczba odczytanych bajtów jest dodatnia.

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

IMHO bardziej minimalistyczny snippet (który również wąsko zakreśla zmienną długości):

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

Na marginesie, nie rozumiem, dlaczego więcej osób nie używa pętli for, zamiast tego decyduje się na while z wyrażeniem assign-and-test, które jest uważane przez niektórych za "kiepski" styl.

PipedInputStream i PipedOutputStream mogą być przydatne, ponieważ można je połączyć z innymi.

Innym możliwym kandydatem są narzędzia I/O Guava:

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

Pomyślałem, że skorzystam z nich, ponieważ Guava jest już niezwykle przydatna w moim projekcie, zamiast dodawać kolejną bibliotekę dla jednej funkcji.

Try Cactoos :

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

Więcej szczegółów tutaj: http://www.yegor256.com/2017/06/22/object-oriented-input-output-in-cactoos.html

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

Możesz użyć tej metody

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