Fiquei surpreso ao descobrir hoje que não consegui rastrear nenhuma maneira simples de escrever o conteúdo de um InputStreampara um OutputStreamem Java. Obviamente, o código do buffer de bytes não é difícil de escrever, mas suspeito que estou perdendo algo que tornaria minha vida mais fácil (e o código mais claro).

Então, dado um InputStream ine um OutputStream out, existe uma maneira mais simples de escrever o seguinte?

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

Java 9

Desde o Java 9, InputStreamfornece um método chamado transferTocom a seguinte assinatura:

public long transferTo(OutputStream out) throws IOException

Como declara a documentação , transferToirá:

Lê todos os bytes desse fluxo de entrada e grava os bytes no fluxo de saída especificado na ordem em que são lidos. No retorno, esse fluxo de entrada estará no final do fluxo. Este método não fecha nenhum fluxo.

Este método pode bloquear a leitura indefinida do fluxo de entrada ou a gravação no fluxo de saída. O comportamento do caso em que o fluxo de entrada e / ou saída é fechado de forma assíncrona ou o encadeamento interrompido durante a transferência é altamente específico do fluxo de entrada e saída e, portanto, não é especificado

Portanto, para escrever o conteúdo de um Java InputStreamem um OutputStream, você pode escrever:

input.transferTo(output);

Como o WMR mencionou, o org.apache.commons.io.IOUtilsApache possui um método chamado copy(InputStream,OutputStream)que faz exatamente o que você está procurando.

Então você tem:

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

... no seu código.

Existe uma razão para você estar evitando IOUtils?

Se você estiver usando o Java 7, o Files (na biblioteca padrão) é a melhor abordagem:

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

Editar: claro que é apenas útil quando você cria um de InputStream ou OutputStream a partir do arquivo. Usarfile.toPath() para obter o caminho do arquivo.

Para gravar em um arquivo existente (por exemplo, um criado com File.createTempFile()), você precisará passar a REPLACE_EXISTINGopção de cópia (caso contrário, FileAlreadyExistsExceptionserá lançada):

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

Eu acho que isso funcionará, mas certifique-se de testá-lo ... "pequenas melhorias", mas pode ser um pouco de custo na legibilidade.

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

Usando goiabas ByteStreams.copy():

ByteStreams.copy(inputStream, outputStream);

Função Simples

Se você só precisa disso para escrever um InputStreampara um File, pode usar esta função simples:

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

Ele JDKusa o mesmo código, então parece que não há uma maneira "mais fácil" sem bibliotecas desajeitadas de terceiros (que provavelmente não fazem nada diferente de qualquer maneira). O seguinte é copiado diretamente de 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;
}

PipedInputStreame PipedOutputStreamsó deve ser usado quando você possui vários encadeamentos, conforme observado pelo Javadoc .

Além disso, observe que os fluxos de entrada e de saída não envolvem nenhuma interrupção de encadeamento com IOExceptions ... Portanto, considere incorporar uma política de interrupção ao seu código:

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

Isso seria uma adição útil se você espera usar essa API para copiar grandes volumes de dados ou dados de fluxos que ficam presos por um tempo intoleravelmente longo.

Para quem usa o framework Spring, existe uma classe StreamUtils útil :

StreamUtils.copy(in, out);

O acima não fecha os fluxos. Se você deseja que os fluxos sejam fechados após a cópia, use a classe FileCopyUtils :

FileCopyUtils.copy(in, out);

Não há como fazer isso muito mais facilmente com os métodos JDK, mas como o Apocalisp já observou, você não é o único com essa ideia: você pode usar IOUtils do Jakarta Commons IO , mas também tem muitas outras coisas úteis, que a IMO deveria realmente fazer parte do JDK ...

Usando Java7 e try-with-resources , vem com uma versão simplificada e legível.

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

Aí vem como estou indo com o loop for mais simples.

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

Use a classe Util da Commons Net:

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

Um trecho mais mínimo da IMHO (que também escopo mais estreitamente a variável length):

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

Como uma observação lateral, não entendo por que mais pessoas não usam um forloop, em vez disso, optam por uma whilecom uma expressão de atribuição e teste que é considerada por alguns como estilo "ruim".

Esta é a minha melhor chance !!

E não use inputStream.transferTo(...)porque é muito genérico. O desempenho do seu código será melhor se você controlar sua memória buffer.

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

Eu o uso com esse método (improvável) quando conheço antecipadamente o tamanho do fluxo.

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

Eu acho que é melhor usar um buffer grande, porque a maioria dos arquivos tem mais de 1024 bytes. Também é uma boa prática verificar se o número de bytes de leitura é positivo.

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

Eu uso BufferedInputStreame BufferedOutputStreampara remover a semântica de buffer do código

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

PipedInputStream e PipedOutputStream podem ser de alguma utilidade, pois você pode conectar um ao outro.

Outro candidato possível são os utilitários de E / S do Guava:

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

Eu pensei em usá-los, pois o Guava já é imensamente útil no meu projeto, em vez de adicionar mais uma biblioteca para uma função.

Não é muito legível, mas eficaz, não possui dependências e é executado com qualquer versão 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;
}

Experimente o Cactoos :

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

Mais detalhes aqui: http://www.yegor256.com/2017/06/22/object-oriented-input-output-in-cactoos.html

você pode usar esse método

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