今天我很惊讶地发现我找不到任何简单的方法来编写内容 InputStream使用OutputStreamJava 将an。显然，字节缓冲区代码并不难编写，但是我怀疑我只是缺少了一些可以使我的生活更轻松的东西（并且代码更清晰）。

那么，给定an InputStream in和an OutputStream out，是否有更简单的方法编写以下内容？

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开始，InputStream提供了一种transferTo带有以下签名的方法：

public long transferTo(OutputStream out) throws IOException

如文档所述，transferTo将：

从此输入流中读取所有字节，然后按读取顺序将字节写入给定的输出流。返回时，此输入流将在流的末尾。此方法不会关闭任何一个流。

此方法可能会无限期阻止从输入流读取或写入输出流。输入和/或输出流异步关闭或线程在传输期间中断的情况下的行为是特定于输入和输出流的，因此未指定

因此，为了编写Java内容的InputStream一个OutputStream，你可以这样写：

input.transferTo(output);

正如WMR所述，org.apache.commons.io.IOUtilsApache提供了一种名为的方法copy(InputStream,OutputStream)，该方法可以完全满足您的需求。

所以你有了：

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

...在您的代码中。

您有避免的理由IOUtils吗？

如果您使用的是Java 7，则文件（在标准库中）是最佳方法：

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

编辑：当然，当您从文件创建InputStream或OutputStream之一时，它只是有用的。用于file.toPath()从文件获取路径。

要写入现有文件（例如使用创建的文件File.createTempFile()），您需要传递REPLACE_EXISTINGcopy选项（否则FileAlreadyExistsException抛出）：

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

我认为这会奏效，但请确保对其进行测试...较小的“改进”，但在可读性方面可能会有所付出。

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

使用番石榴的ByteStreams.copy()：

ByteStreams.copy(inputStream, outputStream);

简单功能

如果只需要使用此函数将写入InputStream到，File则可以使用以下简单函数：

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使用相同的代码，因此，如果没有笨拙的第三方库，这似乎是没有“更轻松”的方式的（反正它们可能不会做任何不同的事情）。以下是直接从复制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;
}

PipedInputStream并且PipedOutputStream应该只当你有多个线程使用，通过的Javadoc指出。

另外，请注意，输入流和输出流不会用IOExceptions 包装任何线程中断。因此，您应考虑将中断策略合并到代码中：

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

如果您希望使用此API复制大量数据或流中无法忍受长时间卡住的数据，这将是一个有用的补充。

对于那些使用Spring框架的人来说，有一个有用的StreamUtils类：

StreamUtils.copy(in, out);

上面没有关闭流。如果要在复制后关闭流，请使用FileCopyUtils类：

FileCopyUtils.copy(in, out);

有没有办法与JDK的方法来做到这一点轻松了许多，但Apocalisp已经指出的那样，你不是唯一一个有这样的想法：你可以使用IOUtils从Jakarta Commons的IO，它也有很多其他有用的东西， IMO实际上应该成为JDK的一部分...

使用Java7和try-with-resources附带一个简化的可读版本。

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

这就是我使用最简单的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);
    }
}

使用Commons Net的Util类：

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

一个恕我直言，更小的代码段（也更狭窄地限制长度变量）：

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

顺便提一句，我不明白为什么更多的人不使用for循环，而是选择了while带有赋值和测试表达式的表达式，这种表达式被某些人认为是“不良”样式。

这是我最好的镜头！

并且不要使用，inputStream.transferTo(...)因为太通用了。 如果控制缓冲区内存，则代码性能会更好。

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

当我事先知道流的大小时，我将其与这种（可改进的）方法一起使用。

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

我认为最好使用大缓冲区，因为大多数文件都大于1024字节。另外，检查读取的字节数是否为正也是一个好习惯。

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

我使用BufferedInputStream和BufferedOutputStream从代码中删除了缓冲语义

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

PipedInputStream和PipedOutputStream可能有用，因为您可以将它们彼此连接。

另一个可能的选择是Guava I / O实用程序：

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

我以为我会使用它们，因为Guava在我的项目中已经非常有用，而不是为一个功能添加另一个库。

可读性不强，但是有效，没有依赖关系并且可以与任何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;
}

尝试仙人掌：

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

此处有更多详细信息：http : //www.yegor256.com/2017/06/22/object-directional-input-output-in-cactoos.html

你可以用这种方法

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