java - 写入具有容量限制的 OutputStream

Question

关注 question我之前问过:我正在实现 ByteArrayOutputStream有容量限制。我的主要限制是可用内存量。所以有这样的流os :

当我写的不止是 1MB到我需要“停止”的输出流。
我不喜欢抛出异常，而是写os的完整内容
输出流到指定的其他输出流参数。
OutputStream out;
os.writeTo(out);
然后继续写到os从一开始

为了防止1.中描述的情况，我宁愿排os ,
尽可能频繁。我的意思是从它复制数据到out大块
512KB
可行吗？如果是的话，有什么建议怎么做？或者可能有一个内置类可以满足我的要求

编辑:写入 out 的字节数也是有限的。我最多可以写1GB。如果我有更多，我需要创建其他输出流以便从 os 中排出。那里。
写入os的过程。可以这样。 500MB 被写在那里 - 我立即将它转移到外面。几秒钟后，那里写入了 700MB - 我只需要将 500MB 耗尽到 out和其他 200MB 到其他输出流( out2)，我需要在这种情况下创建

Answer 1

您所描述的是一个 BufferedOutputStream，您可以像这样构造它:

new BufferedOutputStream(out, 512000)

第一个 arg 是您拥有的另一个输出流，第二个是 BufferedOutputStream 内部缓冲区的大小

编辑:

好的，一开始我并没有完全理解您的需求。您确实需要扩展 OutputStream 来实现这一点。这是一个示例代码:

以下是如何使用以下代码:

    public static void main(String[] args) throws IOException {
        AtomicLong idx = new AtomicLong(0);
        try (
            OutputStream out = new OutputStreamMultiVolume(10, () -> new FileOutputStream(getNextFilename(idx)));
            ) {

            out.write("01234567890123456789012345678901234567890123456789".getBytes("UTF-8"));
        }
    }

    private static File getNextFilename(AtomicLong idx) {
        return new File("sample.file." + idx.incrementAndGet() + ".txt");
    }

OutputStreamMultiVolume 的第一个构造函数 arg 是卷的最大大小。如果达到这个大小，我们将关闭当前的 outputStream，并调用 OutputStreamSupplier 来获取下一个。

此处的示例代码会将字符串 01234567890123456789012345678901234567890123456789(0123456789 的 5 倍)写入名为“sample.file.idx.txt”的文件中，其中 idx 每次达到外流最大大小时都会增加(因此您将获得 5 个文件)。

和类(class)本身:

public class OutputStreamMultiVolume extends OutputStream {

    private final long maxBytePerVolume;
    private long bytesInCurrentVolume = 0;
    private OutputStream out;
    private OutputStreamSupplier outputStreamSupplier;

    static interface OutputStreamSupplier {
        OutputStream get() throws IOException;
    }

    public OutputStreamMultiVolume(long maxBytePerOutput, OutputStreamSupplier outputStreamSupplier) throws IOException {
        this.outputStreamSupplier = outputStreamSupplier;
        this.maxBytePerVolume = maxBytePerOutput;
        this.out = outputStreamSupplier.get();
    }

    @Override
    public synchronized void write(byte[] bytes) throws IOException {
        final int remainingBytesInVol = (int) (maxBytePerVolume - bytesInCurrentVolume);
        if (remainingBytesInVol >= bytes.length) {
            out.write(bytes);
            bytesInCurrentVolume += bytes.length;
            return;
        }

        out.write(bytes, 0, remainingBytesInVol);
        switchOutput();

        this.write(bytes, remainingBytesInVol, bytes.length - remainingBytesInVol);
    }

    @Override
    public synchronized void write(int b) throws IOException {
        if (bytesInCurrentVolume + 1 <= maxBytePerVolume) {
            out.write(b);
            bytesInCurrentVolume += 1;
            return;
        }

        switchOutput();
        out.write(b);
        bytesInCurrentVolume += 1;
    }

    @Override
    public synchronized void write(byte[] b, int off, int len) throws IOException {
        final int remainingBytesInVol = (int) (maxBytePerVolume - bytesInCurrentVolume);
        if (remainingBytesInVol >= len) {
            out.write(b, off, len);
            bytesInCurrentVolume += len;
            return;
        }

        out.write(b, off, remainingBytesInVol);
        switchOutput();
        this.write(b, off + remainingBytesInVol, len - remainingBytesInVol);
        bytesInCurrentVolume += len - remainingBytesInVol;
    }

    private void switchOutput() throws IOException {
        out.flush();
        out.close();

        out = outputStreamSupplier.get();
        bytesInCurrentVolume = 0;
    }

    @Override
    public synchronized void close() throws IOException {
        out.close();
    }

    @Override
    public synchronized void flush() throws IOException {
        out.flush();
    }
}