Qfyilyi

I have a function which writes the given input stream to a given output stream. Code below.

static void copyStream(InputStream is, OutputStream os) throws IOException {

    byte buffer = new byte[4096];

    int len;

    try {

        while ((len = is.read(buffer)) != -1) {

            os.write(buffer, 0, len);

        }

    }

}    

The above function is called from this function

public static void copyFile(File srcFile, File destFile) throws IOException {

    FileInputStream fis = new FileInputStream(srcFile);

    try {

        FileOutputStream fos = new FileOutputStream(destFile);

        try {

            **copyStream**(fis, fos);

        } finally {

            if (fos != null)

                fos.close();

        }

    } finally {

        if (fis != null)

            fis.close();

    }

}

In this function, I am writing 4 MB at once. I use this function to copy images. Occasionally I see that the destination file is not created due to which an exception occurs while trying to read that file for future processing. I am guessing the culprit to be not closing the resources. Is my hypothesis good? What are the reasons why my function might fail? Please help

I believe, that given InputStream and OutputStream installed correctly.
Add os.flush(); at the end. Sure, both streams should be closed in the caller as well.

As alternative, you could use Apache IO utils org.apache.commons.io.IOUtils.copy(InputStream input, OutputStream output).

Yes you absolutely must close your destination file to ensure that all caches from the JVM through to the OS are flushed and the file is ready for a reader to consume.

Copying large files the way that you are doing is concise in code but inefficient in operation. Consider upgrading your code to use the more efficient NIO methods, documented here in a blog post. In case that blog disappears, here's the code:

Utility class:

public final class ChannelTools {

  public static void fastChannelCopy(final ReadableByteChannel src, final WritableByteChannel dest) throws IOException {

    final ByteBuffer buffer = ByteBuffer.allocateDirect(16 * 1024);

    while (src.read(buffer) != -1) {

      // prepare the buffer to be drained

      buffer.flip();

      // write to the channel, may block

      dest.write(buffer);

      // If partial transfer, shift remainder down

      // If buffer is empty, same as doing clear()

      buffer.compact();

    }

    // EOF will leave buffer in fill state

    buffer.flip();

    // make sure the buffer is fully drained.

    while (buffer.hasRemaining()) {

      dest.write(buffer);

    }

  }

}

Usage example with your InputStream and OutputStream:

// allocate the stream ... only for example

final InputStream input = new FileInputStream(inputFile);

final OutputStream output = new FileOutputStream(outputFile);

// get an channel from the stream

final ReadableByteChannel inputChannel = Channels.newChannel(input);

final WriteableByteChannel outputChannel = Channels.newChannel(output);

// copy the channels

ChannelTools.fastChannelCopy(inputChannel, outputChannel);

// closing the channels

inputChannel.close();

outputChannel.close()

There is also a more concise method documented in Wikipedia that achieves the same thing with less code:

// Getting file channels

FileChannel in = new FileInputStream(source).getChannel();

FileChannel out = new FileOutputStream(target).getChannel();



// JavaVM does its best to do this as native I/O operations.

in.transferTo(0, in.size(), out);



// Closing file channels will close corresponding stream objects as well.

out.close();

in.close();