Byłem zaskoczony, gdy dowiedziałem się dzisiaj, że nie mogę wyśledzić żadnego prostego sposobu zapisania zawartości InputStreaman OutputStreamw Javie. Oczywiście bajtowy kod bufora nie jest trudny do napisania, ale podejrzewam, że po prostu brakuje mi czegoś, co ułatwiłoby mi życie (i kod byłby wyraźniejszy).

Tak, podać InputStream ini OutputStream outczy istnieje prostszy sposób napisać co następuje?

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

Java 9

Od wersji Java 9 InputStreamudostępnia metodę wywoływaną transferToz następującym podpisem:

public long transferTo(OutputStream out) throws IOException

Jak dokumentacji stanów, transferTobędzie:

Odczytuje wszystkie bajty z tego strumienia wejściowego i zapisuje bajty do podanego strumienia wyjściowego w kolejności, w jakiej zostały odczytane. Po powrocie ten strumień wejściowy będzie na końcu strumienia. Ta metoda nie zamyka żadnego strumienia.

Ta metoda może blokować nieokreślony odczyt ze strumienia wejściowego lub zapis do strumienia wyjściowego. Zachowanie w przypadku, gdy strumień wejściowy i / lub wyjściowy jest asynchronicznie zamknięty lub wątek przerwany podczas przesyłania, jest wysoce specyficzny dla strumienia wejściowego i wyjściowego, a zatem nie jest określony

Aby więc zapisać zawartość Javy InputStreamna an OutputStream, możesz napisać:

input.transferTo(output);

Jak wspomniano WMR, org.apache.commons.io.IOUtilsApache ma metodę o nazwie, copy(InputStream,OutputStream)która 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 istnieje powód, dla którego unikasz IOUtils?

Jeśli używasz Java 7, najlepszym rozwiązaniem jest Pliki (w standardowej bibliotece):

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

Edycja: Oczywiście jest to przydatne, gdy tworzysz jeden z InputStream lub OutputStream z pliku. Użyj, file.toPath()aby uzyskać ścieżkę z pliku.

Aby zapisać do istniejącego pliku (np. Utworzonego za pomocą File.createTempFile()), musisz przekazać REPLACE_EXISTINGopcję kopiowania (w przeciwnym razie FileAlreadyExistsExceptionzostanie wyrzucone):

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

Myślę, że to zadziała, ale upewnij się, że to przetestujesz ... drobna „poprawa”, ale może to być trochę kosztowne pod względem czytelności.

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

Korzystanie z Guawy ByteStreams.copy():

ByteStreams.copy(inputStream, outputStream);

Prosta funkcja

Jeśli tylko trzeba to na pisanie InputStreamDo Filenastępnie można 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();
    }
}

Do JDKzastosowania tego samego kodu, więc wydaje się, że nie ma „łatwiejszy” sposób bez przylegający bibliotek strony trzeciej (która prawdopodobnie nic nie różni się w każdym razie zrobić). Poniższe dane są kopiowane bezpośrednio 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;
}

PipedInputStreami PipedOutputStreampowinien być używany tylko wtedy, gdy masz wiele wątków, jak zauważył Javadoc .

Zauważ też, że strumienie wejściowe i wyjściowe nie zawijają żadnych przerw wątków za pomocą IOExceptions ... Więc 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łby to użyteczny dodatek, jeśli spodziewasz się użyć tego interfejsu API do kopiowania dużych ilości danych lub danych ze strumieni, które utknęły na niedopuszczalnie długim czasie.

Dla tych, którzy korzystają z frameworka Spring, przydatna jest klasa StreamUtils :

StreamUtils.copy(in, out);

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

FileCopyUtils.copy(in, out);

Nie ma sposobu, aby zrobić to o wiele łatwiej dzięki metodom JDK, ale jak już zauważył Apocalisp, nie jesteś jedyny z tym pomysłem: możesz użyć IOUtils z Jakarta Commons IO , ma również wiele innych przydatnych rzeczy, że IMO powinna faktycznie być częścią JDK ...

Korzystanie z Java7 i try-with-resources zawiera 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();
}

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

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

Użyj klasy Util Commons Net:

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

Bardziej minimalny fragment kodu IMHO (który również zawęża zakres zmiennej 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 forpętli, zamiast tego wybiera whilewyrażenie z przypisywaniem i testowaniem, które przez niektórych jest uważane za „zły” styl.

To mój najlepszy strzał !!

I nie używaj, inputStream.transferTo(...)ponieważ jest zbyt ogólny. Wydajność kodu będzie lepsza, jeśli kontrolujesz pamięć bufora.

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

Używam go z tą (poprawialną) metodą, gdy wiem z góry rozmiar strumienia.

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

Myślę, że lepiej jest użyć dużego bufora, ponieważ większość plików ma ponad 1024 bajty. Dobrą praktyką jest również sprawdzanie liczby odczytanych bajtów, aby były dodatnie.

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

Używam BufferedInputStreami BufferedOutputStreamdo usunięcia semantyki buforowania z kodu

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

PipedInputStream i PipedOutputStream mogą się przydać, ponieważ możesz łączyć się ze sobą.

Innym możliwym kandydatem są narzędzia we / wy Guava:

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

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

Niezbyt czytelny, ale skuteczny, nie ma zależności i działa z każdą wersją 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;
}

Wypróbuj Cactoos :

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

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

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