Hôm nay tôi rất ngạc nhiên khi thấy rằng tôi không thể theo dõi bất kỳ cách đơn giản nào để viết nội dung của một InputStreamthành OutputStreamJava. Rõ ràng, mã bộ đệm byte không khó viết, nhưng tôi nghi ngờ rằng tôi chỉ thiếu một cái gì đó sẽ giúp cuộc sống của tôi dễ dàng hơn (và mã rõ ràng hơn).

Vì vậy, đưa ra một InputStream invà một OutputStream out, có cách nào đơn giản hơn để viết như sau?

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

Java 9

Kể từ Java 9, InputStreamcung cấp một phương thức được gọi transferTovới chữ ký sau:

public long transferTo(OutputStream out) throws IOException

Như tài liệu nêu, transferTosẽ:

Đọc tất cả các byte từ luồng đầu vào này và ghi các byte vào luồng đầu ra đã cho theo thứ tự mà chúng được đọc. Khi trở lại, luồng đầu vào này sẽ ở cuối luồng. Phương pháp này không đóng một trong hai luồng.

Phương pháp này có thể chặn việc đọc vô thời hạn từ luồng đầu vào hoặc ghi vào luồng đầu ra. Hành vi cho trường hợp luồng đầu vào và / hoặc đầu ra bị đóng không đồng bộ hoặc luồng bị gián đoạn trong quá trình truyền, là luồng đầu vào và đầu ra rất cụ thể và do đó không được chỉ định

Vì vậy, để viết nội dung của Java InputStreamsang một OutputStream, bạn có thể viết:

input.transferTo(output);

Như WMR đã đề cập, org.apache.commons.io.IOUtilstừ Apache có một phương thức được gọi là copy(InputStream,OutputStream)chính xác những gì bạn đang tìm kiếm.

Vì vậy, bạn có:

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

... trong mã của bạn.

Có một lý do bạn đang tránh IOUtils?

Nếu bạn đang sử dụng Java 7, Tệp (trong thư viện chuẩn) là cách tiếp cận tốt nhất:

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

Chỉnh sửa: Tất nhiên nó chỉ hữu ích khi bạn tạo một trong InputStream hoặc OutputStream từ tệp. Sử dụng file.toPath()để có được đường dẫn từ tập tin.

Để ghi vào một tệp hiện có (ví dụ: tệp được tạo bằng File.createTempFile()), bạn sẽ cần phải vượt qua REPLACE_EXISTINGtùy chọn sao chép (nếu không FileAlreadyExistsExceptionsẽ bị ném):

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

Tôi nghĩ rằng điều này sẽ làm việc, nhưng đảm bảo kiểm tra nó ... "cải thiện" nhỏ, nhưng nó có thể là một chút chi phí ở mức dễ đọc.

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

Sử dụng quả ổi ByteStreams.copy():

ByteStreams.copy(inputStream, outputStream);

Chức năng đơn giản

Nếu bạn chỉ cần điều này để viết InputStreammột Filethì bạn có thể sử dụng chức năng đơn giản này:

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

Mã này JDKsử dụng cùng một mã để có vẻ như không có cách nào "dễ dàng hơn" nếu không có các thư viện bên thứ ba lộn xộn (có thể không làm gì khác đi). Sau đây được sao chép trực tiếp từ 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;
}

PipedInputStreamvà PipedOutputStreamchỉ nên được sử dụng khi bạn có nhiều luồng, như được ghi nhận bởi Javadoc .

Ngoài ra, lưu ý rằng luồng đầu vào và luồng đầu ra không bao gồm bất kỳ gián đoạn luồng nào với IOExceptions ... Vì vậy, bạn nên xem xét kết hợp chính sách gián đoạn với mã của mình:

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

Đây sẽ là một bổ sung hữu ích nếu bạn muốn sử dụng API này để sao chép khối lượng dữ liệu lớn hoặc dữ liệu từ các luồng bị kẹt trong một thời gian dài không thể chịu đựng được.

Đối với những người sử dụng Spring framework, có một lớp StreamUtils hữu ích :

StreamUtils.copy(in, out);

Ở trên không đóng luồng. Nếu bạn muốn các luồng được đóng sau khi sao chép, hãy sử dụng lớp FileCopyUtils :

FileCopyUtils.copy(in, out);

Không có cách nào để thực hiện việc này dễ dàng hơn nhiều với các phương thức JDK, nhưng như Apocalisp đã lưu ý, bạn không phải là người duy nhất có ý tưởng này: Bạn có thể sử dụng IOUtils từ Jakarta Commons IO , nó cũng có rất nhiều điều hữu ích khác, IMO thực sự nên là một phần của JDK ...

Sử dụng Java7 và dùng thử với các tài nguyên , đi kèm với một phiên bản đơn giản và dễ đọc.

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

Đây là cách tôi đang làm với vòng lặp đơn giản nhất.

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

Sử dụng lớp Util của Commons Net:

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

Một đoạn trích IMHO tối thiểu hơn (cũng thu hẹp phạm vi biến số độ dài hơn):

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

Là một lưu ý phụ, tôi không hiểu tại sao nhiều người không sử dụng forvòng lặp, thay vào đó, chọn một whilebiểu thức gán và kiểm tra được một số người coi là kiểu "nghèo".

Đây là bức ảnh đẹp nhất của tôi !!

Và không sử dụng inputStream.transferTo(...)vì quá chung chung. Hiệu suất mã của bạn sẽ tốt hơn nếu bạn kiểm soát bộ nhớ đệm của mình.

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

Tôi sử dụng nó với phương pháp (ngẫu hứng) này khi tôi biết trước kích thước của luồng.

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

Tôi nghĩ tốt hơn là sử dụng bộ đệm lớn, vì hầu hết các tệp đều lớn hơn 1024 byte. Ngoài ra, đó là một cách thực hành tốt để kiểm tra số byte đọc là dương.

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

Tôi sử dụng BufferedInputStreamvà BufferedOutputStreamđể loại bỏ ngữ nghĩa đệm từ mã

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

PipedInputStream và PipedOutputStream có thể được sử dụng, vì bạn có thể kết nối cái này với cái kia.

Một ứng cử viên khác có thể là các tiện ích I / O của Guava:

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

Tôi nghĩ rằng tôi sẽ sử dụng những thứ này vì Guava đã vô cùng hữu ích trong dự án của tôi, thay vì thêm một thư viện khác cho một chức năng.

Không dễ đọc lắm, nhưng hiệu quả, không phụ thuộc và chạy với bất kỳ phiên bản java nào

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

Hãy thử Cactoos :

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

Thêm chi tiết tại đây: http://www.yegor256.com/2017/06/22/object-oriented-input-output-in-cactoos.html

bạn có thể sử dụng phương pháp này

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