IO

读/写文件

流复制

    try {
        InputStream is = new FileInputStream(fromPath);
        OutputStream os = new FileOutputStream(toPath);
        int bufferSize = Math.min(is.available(), 1024);
        byte[] data = new byte[bufferSize];
        int bytesRead;
        while ((bytesRead = is.read(data)) != -1) {
            os.write(data, 0, bytesRead);
            count++;
        }
        is.close();
        os.close();
    } catch (IOException e) {
        e.printStackTrace();
    }

InputStream.java：

    /**
     * Reads some number of bytes from the input stream and stores them into
     * the buffer array <code>b</code>. The number of bytes actually read is
     * returned as an integer.  This method blocks until input data is
     * available, end of file is detected, or an exception is thrown.
     *
     * <p> If the length of <code>b</code> is zero, then no bytes are read and
     * <code>0</code> is returned; otherwise, there is an attempt to read at
     * least one byte. If no byte is available because the stream is at the
     * end of the file, the value <code>-1</code> is returned; otherwise, at
     * least one byte is read and stored into <code>b</code>.
     *
     * <p> The first byte read is stored into element <code>b[0]</code>, the
     * next one into <code>b[1]</code>, and so on. The number of bytes read is,
     * at most, equal to the length of <code>b</code>. Let <i>k</i> be the
     * number of bytes actually read; these bytes will be stored in elements
     * <code>b[0]</code> through <code>b[</code><i>k</i><code>-1]</code>,
     * leaving elements <code>b[</code><i>k</i><code>]</code> through
     * <code>b[b.length-1]</code> unaffected.
     *
     * <p> The <code>read(b)</code> method for class <code>InputStream</code>
     * has the same effect as: <pre><code> read(b, 0, b.length) </code></pre>
     *
     * @param      b   the buffer into which the data is read.
     * @return     the total number of bytes read into the buffer, or
     *             <code>-1</code> if there is no more data because the end of
     *             the stream has been reached.
     * @exception  IOException  If the first byte cannot be read for any reason
     * other than the end of the file, if the input stream has been closed, or
     * if some other I/O error occurs.
     * @exception  NullPointerException  if <code>b</code> is <code>null</code>.
     * @see        java.io.InputStream#read(byte[], int, int)
     */
    public int read(byte b[]) throws IOException {
        return read(b, 0, b.length);
    }

Channel复制

    FileChannel inputChannel = null;
    FileChannel outputChannel = null;
    try {
        inputChannel = new FileInputStream(fromPath).getChannel();
        outputChannel = new FileOutputStream(toPath).getChannel();
        outputChannel.transferFrom(inputChannel, 0, inputChannel.size());
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            if (inputChannel != null) {
                inputChannel.close();
            }
            if (outputChannel != null) {
                outputChannel.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

复制6M的文件，流复制耗时100-300ms之间，Channel复制耗时100ms以下。