Saya terkejut menemukan hari ini bahwa saya tidak dapat melacak cara sederhana untuk menulis konten InputStreamke OutputStreamdi Jawa. Jelas, kode buffer byte tidak sulit untuk ditulis, tetapi saya curiga saya hanya melewatkan sesuatu yang akan membuat hidup saya lebih mudah (dan kode lebih jelas).

Jadi, mengingat InputStream indan OutputStream out, apakah ada cara yang lebih sederhana untuk menulis yang berikut ini?

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

Jawa 9

Sejak Java 9, InputStreamberikan metode yang disebut transferTodengan tanda tangan berikut:

public long transferTo(OutputStream out) throws IOException

Seperti yang dinyatakan dalam dokumentasi , transferToakan:

Membaca semua byte dari aliran input ini dan menulis byte ke aliran output yang diberikan dalam urutan yang dibaca. Saat kembali, aliran input ini akan berada di ujung aliran. Metode ini tidak menutup aliran mana pun.

Metode ini dapat memblokir pembacaan tanpa batas dari aliran input, atau menulis ke aliran output. Perilaku untuk kasus di mana aliran input dan / atau output secara asinkron tertutup, atau utas terputus selama transfer, sangat spesifik input dan output stream, dan karenanya tidak ditentukan

Jadi untuk menulis konten Java InputStreamke OutputStream, Anda dapat menulis:

input.transferTo(output);

Seperti disebutkan WMR, org.apache.commons.io.IOUtilsdari Apache memiliki metode yang disebut copy(InputStream,OutputStream)yang tidak persis apa yang Anda cari.

Jadi kamu punya:

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

... dalam kode Anda.

Apakah ada alasan Anda menghindarinya IOUtils?

Jika Anda menggunakan Java 7, File (di perpustakaan standar) adalah pendekatan terbaik:

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

Sunting: Tentu saja itu hanya berguna ketika Anda membuat salah satu dari InputStream atau OutputStream dari file. Gunakan file.toPath()untuk mendapatkan jalur dari file.

Untuk menulis ke file yang sudah ada (misalnya yang dibuat dengan File.createTempFile()), Anda harus melewati REPLACE_EXISTINGopsi salin (jika FileAlreadyExistsExceptiontidak dilempar):

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

Saya pikir ini akan berhasil, tetapi pastikan untuk mengujinya ... "perbaikan" kecil, tetapi mungkin sedikit biaya pada keterbacaan.

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

Menggunakan Jambu Biji ByteStreams.copy():

ByteStreams.copy(inputStream, outputStream);

Fungsi sederhana

Jika Anda hanya memerlukan ini untuk menulis InputStreamke Filemaka Anda dapat menggunakan fungsi sederhana ini:

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

The JDKpenggunaan kode yang sama sehingga tampak seperti tidak ada "lebih mudah" cara tanpa pihak ketiga perpustakaan kikuk (yang mungkin tidak melakukan apa-apa pula yang berbeda). Yang berikut disalin langsung dari 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;
}

PipedInputStreamdan PipedOutputStreamseharusnya hanya digunakan ketika Anda memiliki banyak utas, seperti dicatat oleh Javadoc .

Juga, perhatikan bahwa aliran input dan aliran output tidak membungkus gangguan utas dengan IOException... Jadi, Anda harus mempertimbangkan untuk memasukkan kebijakan gangguan ke kode Anda:

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

Ini akan menjadi tambahan yang berguna jika Anda berharap untuk menggunakan API ini untuk menyalin data dalam volume besar, atau data dari stream yang macet untuk waktu yang lama.

Bagi mereka yang menggunakan kerangka kerja Spring ada kelas StreamUtils yang berguna :

StreamUtils.copy(in, out);

Di atas tidak menutup aliran. Jika Anda ingin stream ditutup setelah penyalinan, gunakan kelas FileCopyUtils sebagai gantinya:

FileCopyUtils.copy(in, out);

Tidak ada cara untuk melakukan ini lebih mudah dengan metode JDK, tetapi seperti yang telah dicatat Apocalisp, Anda bukan satu-satunya yang memiliki gagasan ini: Anda dapat menggunakan IOUtils dari Jakarta Commons IO , ini juga memiliki banyak hal berguna lainnya, bahwa IMO harus benar-benar menjadi bagian dari JDK ...

Menggunakan Java7 dan coba-dengan-sumber daya , hadir dengan versi yang disederhanakan dan dapat dibaca.

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

Inilah yang saya lakukan dengan loop paling sederhana.

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

Gunakan kelas Util Commons Net:

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

Cuplikan IMHO lebih minimal (yang juga lebih sempit lingkup variabel panjang):

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

Sebagai catatan tambahan, saya tidak mengerti mengapa lebih banyak orang tidak menggunakan forloop, sebagai gantinya memilih untuk whiledengan ekspresi assign-and-test yang dianggap oleh beberapa orang sebagai gaya "buruk".

Ini tembakan terbaik saya !!

Dan jangan gunakan inputStream.transferTo(...)karena terlalu generik. Kinerja kode Anda akan lebih baik jika Anda mengontrol memori buffer Anda.

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

Saya menggunakannya dengan metode (improvisasi) ini ketika saya tahu sebelumnya ukuran stream.

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

Saya pikir lebih baik menggunakan buffer besar, karena sebagian besar file lebih besar dari 1024 byte. Juga merupakan praktik yang baik untuk memeriksa jumlah byte yang dibaca menjadi positif.

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

Saya menggunakan BufferedInputStreamdan BufferedOutputStreammenghapus semantik buffering dari kode

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

PipedInputStream dan PipedOutputStream mungkin berguna, karena Anda dapat menghubungkan satu ke yang lain.

Kandidat lain yang mungkin adalah utilitas Jambu I / O:

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

Saya pikir saya akan menggunakan ini karena Guava sudah sangat berguna dalam proyek saya, daripada menambahkan perpustakaan lain untuk satu fungsi.

Tidak terlalu mudah dibaca, tetapi efektif, tidak memiliki dependensi dan berjalan dengan versi java apa pun

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

Coba Cactoos :

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

Lebih detail di sini: http://www.yegor256.com/2017/06/22/object-oriented-input-output-in-cactoos.html

Anda dapat menggunakan metode ini

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