Сегодня я с удивлением обнаружил, что не могу отследить какой-либо простой способ записи содержимого объекта InputStreama OutputStreamв Java. Очевидно, что код байтового буфера не сложно написать, но я подозреваю, что мне просто не хватает чего-то, что сделало бы мою жизнь проще (и код понятнее).

Итак, учитывая 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.IOUtilsу Apache есть метод, 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_EXISTINGкопирования (в противном случае 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в a, 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 Framework, есть полезный класс StreamUtils :

StreamUtils.copy(in, out);

Вышеуказанное не закрывает потоки. Если вы хотите, чтобы потоки были закрыты после копирования, используйте класс FileCopyUtils :

FileCopyUtils.copy(in, out);

Нет никакого способа сделать это намного проще с помощью методов JDK, но, как уже отмечал Apocalisp , вы не единственные с этой идеей: вы можете использовать IOUtils из Jakarta Commons IO , у него также есть много других полезных вещей, что ИМО на самом деле должна быть частью 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();
}

Вот как я делаю с простейшим для цикла.

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

Используйте класс Util Commons Net:

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:

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

Попробуйте Cactoos :

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

Более подробная информация здесь: http://www.yegor256.com/2017/06/22/object-oriented-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){}
 }