Свързване на входен поток към изходен поток

Това, че използвате буфер, не означава, че потокът трябва да запълни този буфер. С други думи, това трябва да е наред:

public static void copyStream(InputStream input, OutputStream output)
    throws IOException
{
    byte[] buffer = new byte[1024]; // Adjust if you want
    int bytesRead;
    while ((bytesRead = input.read(buffer)) != -1)
    {
        output.write(buffer, 0, bytesRead);
    }
}

Това трябва да работи добре - по принцип read повикването ще блокира, докато има някои налични данни, но няма да изчака, докато всички са налични, за да запълни буфера. (Предполагам, че може и вярвам, че FileInputStream обикновено ще запълни буфера, но потокът, прикачен към сокет, е по-вероятно да ви даде данните веднага.)

Мисля, че си струва първо да опитате това просто решение.

Какво ще кажете просто да използвате

void feedInputToOutput(InputStream in, OutputStream out) {
   IOUtils.copy(in, out);
}

и да приключим с това?

от jakarta apache commons i/o библиотека, която вече се използва от огромно количество проекти, така че вероятно вече имате буркана във вашия classpath.

За пълнота guava също има удобна помощна програма за това

ByteStreams.copy(input, output);

JDK 9 добави InputStream#transferTo(OutputStream out) за тази функционалност.

Можете да използвате кръгъл буфер:

Код

// buffer all data in a circular buffer of infinite size
CircularByteBuffer cbb = new CircularByteBuffer(CircularByteBuffer.INFINITE_SIZE);
class1.putDataOnOutputStream(cbb.getOutputStream());
class2.processDataFromInputStream(cbb.getInputStream());

Зависимост от Maven

<dependency>
    <groupId>org.ostermiller</groupId>
    <artifactId>utils</artifactId>
    <version>1.07.00</version>
</dependency>

Подробности за режима

http://ostermiller.org/utils/CircularBuffer.html

Асинхронен начин за постигане.

void inputStreamToOutputStream(final InputStream inputStream, final OutputStream out) {
    Thread t = new Thread(new Runnable() {

        public void run() {
            try {
                int d;
                while ((d = inputStream.read()) != -1) {
                    out.write(d);
                }
            } catch (IOException ex) {
                //TODO make a callback on exception.
            }
        }
    });
    t.setDaemon(true);
    t.start();
}

BUFFER_SIZE е размерът на патронниците за четене. Трябва да бъде > 1 kb и ‹ 10 MB.

private static final int BUFFER_SIZE = 2 * 1024 * 1024;
private void copy(InputStream input, OutputStream output) throws IOException {
    try {
        byte[] buffer = new byte[BUFFER_SIZE];
        int bytesRead = input.read(buffer);
        while (bytesRead != -1) {
            output.write(buffer, 0, bytesRead);
            bytesRead = input.read(buffer);
        }
    //If needed, close streams.
    } finally {
        input.close();
        output.close();
    }
}

Използвайте org.apache.commons.io.IOUtils

InputStream inStream = new ...
OutputStream outStream = new ...
IOUtils.copy(inStream, outStream);

или copyLarge за размер >2 GB

Това е версия на Scala, която е чиста и бърза (без stackoverflow):

  import scala.annotation.tailrec
  import java.io._

  implicit class InputStreamOps(in: InputStream) {
    def >(out: OutputStream): Unit = pipeTo(out)

    def pipeTo(out: OutputStream, bufferSize: Int = 1<<10): Unit = pipeTo(out, Array.ofDim[Byte](bufferSize))

    @tailrec final def pipeTo(out: OutputStream, buffer: Array[Byte]): Unit = in.read(buffer) match {
      case n if n > 0 =>
        out.write(buffer, 0, n)
        pipeTo(out, buffer)
      case _ =>
        in.close()
        out.close()
    }
  }

Това позволява да се използва символ >, напр. inputstream > outputstream и също така предава персонализирани буфери/размери.

В случай, че се интересувате от функционалност, това е функция, написана на Scala, показваща как можете да копирате входен поток в изходен поток, като използвате само vals (а не vars).

def copyInputToOutputFunctional(inputStream: InputStream, outputStream: OutputStream,bufferSize: Int) {
  val buffer = new Array[Byte](bufferSize);
  def recurse() {
    val len = inputStream.read(buffer);
    if (len > 0) {
      outputStream.write(buffer.take(len));
      recurse();
    }
  }
  recurse();
}

Имайте предвид, че това не се препоръчва да се използва в Java приложение с малко налична памет, защото с рекурсивна функция можете лесно да получите грешка при препълване на стека