Ben bir içeriğini yazmak için herhangi basit bir yol izini olamayacağını bugün bulmak için şaşırdı InputStreambir etmek OutputStreamJava. Açıkçası, bayt arabellek kodu yazmak zor değil, ama sadece hayatımı kolaylaştıracak bir şey (ve kod daha net) eksik olduğundan şüpheleniyorum.

Öyleyse, a InputStream inve a verildiğinde OutputStream out, aşağıdakileri yazmanın daha basit bir yolu var mı?

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

Java 9

Java 9'dan beri , aşağıdaki imzayla InputStreamçağrılan bir yöntem sağlar transferTo:

public long transferTo(OutputStream out) throws IOException

Gibi belgeler devletler, transferToyapacaktır:

Bu giriş akışındaki tüm baytları okur ve baytları okudukları sıraya göre verilen çıkış akışına yazar. Dönüşte, bu giriş akışı akışın sonunda olacaktır. Bu yöntem her iki akışı da kapatmaz.

Bu yöntem, giriş akışından süresiz olarak okumayı veya çıkış akışına yazmayı engelleyebilir. Giriş ve / veya çıkış akışının eşzamansız olarak kapatıldığı veya aktarım sırasında iş parçacığının kesildiği durumun davranışı, yüksek oranda giriş ve çıkış akışına özgüdür ve bu nedenle belirtilmez

Yani bir Java içeriğini yazmak için InputStreambir karşı OutputStreamyazabilirsiniz:

input.transferTo(output);

WMR'nin belirttiği gibi org.apache.commons.io.IOUtils, Apache'den copy(InputStream,OutputStream)tam olarak aradığınızı yapan bir yöntem var .

Yani, var:

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

... kodunuzda.

Kaçınılması için bir neden var mı IOUtils?

Java 7 kullanıyorsanız, Dosyalar (standart kitaplıkta) en iyi yaklaşımdır:

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

Düzenleme: Tabii ki sadece dosyadan InputStream veya OutputStream birini oluşturduğunuzda yararlıdır. file.toPath()Dosyadan yol almak için kullanın .

Mevcut bir dosyaya yazmak için (örn. İle oluşturulmuş bir dosya File.createTempFile()), REPLACE_EXISTINGkopyalama seçeneğini (aksi takdirde FileAlreadyExistsExceptionatılır) geçmeniz gerekir :

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

Bu işe yarayacağını düşünüyorum, ama test etmek için emin olun ... küçük "iyileştirme", ama okunabilirlik biraz maliyet olabilir.

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

Guava'ları kullanma ByteStreams.copy():

ByteStreams.copy(inputStream, outputStream);

Basit İşlev

Yalnızca bir yazmak için bu gerekiyorsa InputStreambir karşı Fileo zaman bu basit işlevi kullanabilirsiniz:

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

JDK(Muhtemelen bir şey farklı zaten yapmayın) aksak üçüncü parti kütüphaneler olmadan hayır "kolay" yolu yoktur gibi kullandığı aynı kod görünüyor böylece. Aşağıdakiler doğrudan şuradan kopyalanır 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;
}

PipedInputStreamve PipedOutputStreamyalnızca Javadoc tarafından belirtildiği gibi birden çok iş parçanız olduğunda kullanılmalıdır .

Ayrıca, giriş akışlarının ve çıkış akışlarının IOExceptions ile herhangi bir iş parçacığı kesintisi olmadığını unutmayın ... Bu nedenle, kodunuza bir kesinti ilkesi eklemeyi düşünmelisiniz:

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

Bu API'yı, büyük hacimli verileri veya dayanılmaz uzun bir süre boyunca takılan akışlardan gelen verileri kopyalamak için kullanmayı düşünüyorsanız yararlı bir ek olacaktır.

Spring çerçevesini kullananlar için yararlı bir StreamUtils sınıfı vardır:

StreamUtils.copy(in, out);

Yukarıdaki akışları kapatmaz. Kopyalama işleminden sonra akışların kapatılmasını istiyorsanız, bunun yerine FileCopyUtils sınıfını kullanın:

FileCopyUtils.copy(in, out);

Orada JDK yöntemlerle çok daha kolay bunu yapmak için hiçbir yol, ama Apocalisp daha önce belirtildiği gibi, bu fikir tek değiliz: Şunları kullanabilirsiniz IOUtils gelen Cakarta Commons IO , aynı zamanda diğer yararlı bir çok şey vardır, IMO aslında JDK'nın bir parçası olmalı ...

Java7 ve kaynaklarla deneme , basitleştirilmiş ve okunabilir bir sürümle birlikte gelir.

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

İşte en basit for döngüsü ile yaptığım şey.

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

Commons Net'in Util sınıfını kullanın:

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

Bir IMHO daha minimal snippet'i (uzunluk değişkenini daha da dar kapsamlıdır):

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

Bir yan not olarak, neden daha fazla insanın bir fordöngü kullanmadığını anlamıyorum , bunun yerine whilebazıları tarafından "zayıf" stil olarak kabul edilen bir ata ve test ifadesi kullanmayı tercih ediyorum .

Bu benim en iyi atışım !!

Ve kullanmayın inputStream.transferTo(...)çünkü çok genel. Arabellek belleğinizi kontrol ederseniz, kod performansınız daha iyi olacaktır.

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

Akışın boyutunu önceden bildiğimde bu (geliştirilebilir) yöntemle kullanıyorum.

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

Dosyaların çoğu 1024 bayttan büyük olduğu için büyük bir arabellek kullanmak daha iyi olduğunu düşünüyorum. Ayrıca, okunan bayt sayısını pozitif olarak kontrol etmek de iyi bir uygulamadır.

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

Ben kullanmak BufferedInputStreamve BufferedOutputStreamkoddan arabelleğe alma semantik kaldırmak için

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

PipedInputStream ve PipedOutputStream, birini diğerine bağlayabileceğiniz için bazı yararlı olabilir.

Başka bir olası aday Guava I / O yardımcı programlarıdır:

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

Bunları kullanacağımı sanıyordum, çünkü Guava bir işlev için başka bir kütüphane eklemek yerine projemde son derece yararlı.

Çok okunabilir değil, etkili, bağımlılığı yok ve herhangi bir java sürümü ile çalışıyor

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

Cactoos'u deneyin :

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

Daha fazla ayrıntı burada: http://www.yegor256.com/2017/06/22/object-oriented-input-output-in-cactoos.html

bu yöntemi kullanabilirsiniz

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