FileInputStream和FileOutputStream详解

一.引子
　　文件，作为常见的数据源。关于操作文件的字节流就是 FileInputStream & FileOutputStream。它们是Basic IO字节流中重要的实现类。
二、FileInputStream源码分析

　　FileInputStream源码如下：

/**
 * FileInputStream 从文件系统的文件中获取输入字节流。文件取决于主机系统。
 *  比如读取图片等的原始字节流。如果读取字符流，考虑使用 FiLeReader。
 */
public class FileInputStream extends InputStream{
    /* 文件描述符类---此处用于打开文件的句柄 */
    private final FileDescriptor fd;
    /* 引用文件的路径 */
    private final String path;
    /* 文件通道，NIO部分 */
    private FileChannel channel = null;
    private final Object closeLock = new Object();
    private volatile boolean closed = false;

    private static final ThreadLocal<Boolean> runningFinalize =
        new ThreadLocal<>();

    private static boolean isRunningFinalize() {
        Boolean val;
        if ((val = runningFinalize.get()) != null)
            return val.booleanValue();
        return false;
    }

    /* 通过文件路径名来创建FileInputStream */
    public FileInputStream(String name) throws FileNotFoundException {
        this(name != null ? new File(name) : null);
    }

    /* 通过文件来创建FileInputStream */
    public FileInputStream(File file) throws FileNotFoundException {
        String name = (file != null ? file.getPath() : null);
        SecurityManager security = System.getSecurityManager();
        if (security != null) {
            security.checkRead(name);
        }
        if (name == null) {
            throw new NullPointerException();
        }
        if (file.isInvalid()) {
            throw new FileNotFoundException("Invalid file path");
        }
        fd = new FileDescriptor();
        fd.incrementAndGetUseCount();
        this.path = name;
        open(name);
    }

    /* 通过文件描述符类来创建FileInputStream */
    public FileInputStream(FileDescriptor fdObj) {
        SecurityManager security = System.getSecurityManager();
        if (fdObj == null) {
            throw new NullPointerException();
        }
        if (security != null) {
            security.checkRead(fdObj);
        }
        fd = fdObj;
        path = null;
        fd.incrementAndGetUseCount();
    }

    /* 打开文件，为了下一步读取文件内容。native方法 */
    private native void open(String name) throws FileNotFoundException;

    /* 从此输入流中读取一个数据字节 */
    public int read() throws IOException {
        Object traceContext = IoTrace.fileReadBegin(path);
        int b = 0;
        try {
            b = read0();
        } finally {
            IoTrace.fileReadEnd(traceContext, b == -1 ? 0 : 1);
        }
        return b;
    }

    /* 从此输入流中读取一个数据字节。native方法 */
    private native int read0() throws IOException;

    /* 从此输入流中读取多个字节到byte数组中。native方法 */
    private native int readBytes(byte b[], int off, int len) throws IOException;

    /* 从此输入流中读取多个字节到byte数组中。 */
    public int read(byte b[]) throws IOException {
        Object traceContext = IoTrace.fileReadBegin(path);
        int bytesRead = 0;
        try {
            bytesRead = readBytes(b, 0, b.length);
        } finally {
            IoTrace.fileReadEnd(traceContext, bytesRead == -1 ? 0 : bytesRead);
        }
        return bytesRead;
    }

    /* 从此输入流中读取最多len个字节到byte数组中。 */
    public int read(byte b[], int off, int len) throws IOException {
        Object traceContext = IoTrace.fileReadBegin(path);
        int bytesRead = 0;
        try {
            bytesRead = readBytes(b, off, len);
        } finally {
            IoTrace.fileReadEnd(traceContext, bytesRead == -1 ? 0 : bytesRead);
        }
        return bytesRead;
    }

    public native long skip(long n) throws IOException;

    /* 返回下一次对此输入流调用的方法可以不受阻塞地从此输入流读取（或跳过）的估计剩余字节数。 */
    public native int available() throws IOException;

    /* 关闭此文件输入流并释放与此流有关的所有系统资源。 */
    public void close() throws IOException {
        synchronized (closeLock) {
            if (closed) {
                return;
            }
            closed = true;
        }
        if (channel != null) {
           fd.decrementAndGetUseCount();
           channel.close();
        }

        int useCount = fd.decrementAndGetUseCount();

        if ((useCount <= 0) || !isRunningFinalize()) {
            close0();
        }
    }

    public final FileDescriptor getFD() throws IOException {
        if (fd != null) return fd;
        throw new IOException();
    }

    /* 获取此文件输入流的唯一FileChannel对象 */
    publicFileChannel getChannel() {
        synchronized(this) {
            if(channel == null) {
                channel = FileChannelImpl.open(fd, path, true, false, this);
                fd.incrementAndGetUseCount();
            }
            returnchannel;
        }
    }

    privatestaticnativevoidinitIDs();

    privatenativevoidclose0() throwsIOException;

    static{
        initIDs();
    }

    protected void finalize() throws IOException {
        if((fd != null) &&  (fd != FileDescriptor.in)) {
            runningFinalize.set(Boolean.TRUE);
            try{
                close();
            } finally{
                runningFinalize.set(Boolean.FALSE);
            }
        }
    }
}

1. 三个核心方法

　　三个核心方法，也就是Override（重写）了抽象类InputStream的read方法。int read() 方法，即

　　　　public int read() throws IOException

　　代码实现中很简单，一个try中调用本地native的read0()方法，直接从文件输入流中读取一个字节。IoTrace.fileReadEnd(),字面意思是防止文件没有关闭读的通道，导致读文件失败，一直开着读的通道，会造成内存泄露。

　　int read(byte b[]) 方法，即

　　　　public int read(byte b[]) throws IOException

　　代码实现也是比较简单的，也是一个try中调用本地native的readBytes()方法，直接从文件输入流中读取最多b.length个字节到byte数组b中。

　　int read(byte b[], int off, int len) 方法，即

　　　　public int read(byte b[], int off, int len) throws IOException

　　代码实现和 int read(byte b[])方法 一样，直接从文件输入流中读取最多len个字节到byte数组b中。
2. 值得一提的native方法
　　上面核心方法中为什么实现简单，因为工作量都在native方法里面，即JVM里面实现了。native倒是不少一一列举吧：

　　　　native void open(String name) // 打开文件，为了下一步读取文件内容

　　　　native int read0() // 从文件输入流中读取一个字节

　　　　native int readBytes(byte b[], int off, int len) // 从文件输入流中读取，从off句柄开始的len个字节，并存储至b字节数组内。

　　　　native void close0() // 关闭该文件输入流及涉及的资源，比如说如果该文件输入流的FileChannel对被获取后，需要对FileChannel进行close。

　　其他还有值得一提的就是，在jdk1.4中，新增了NIO包，优化了一些IO处理的速度，所以在FileInputStream和FileOutputStream中新增了FileChannel getChannel()的方法。即获取与该文件输入流相关的 java.nio.channels.FileChannel对象。

FileOutputStream 源码如下：

/**
 * 文件输入流是用于将数据写入文件或者文件描述符类
 *  比如写入图片等的原始字节流。如果写入字符流，考虑使用 FiLeWriter。
 */
publicclassSFileOutputStream extendsOutputStream{
    /* 文件描述符类---此处用于打开文件的句柄 */
    private final FileDescriptor fd;
    /* 引用文件的路径 */
    private final String path;
    /* 如果为 true，则将字节写入文件末尾处，而不是写入文件开始处 */
    private final boolean append;
    /* 关联的FileChannel类，懒加载 */
    private FileChannel channel;
    private final Object closeLock = new Object();
    private volatile boolean closed = false;
    private static final ThreadLocal<Boolean> runningFinalize =
        new ThreadLocal<>();

    private static boolean isRunningFinalize() {
        Boolean val;
        if ((val = runningFinalize.get()) != null)
            return val.booleanValue();
        return false;
    }

    /* 通过文件名创建文件输入流 */
    public FileOutputStream(String name) throws FileNotFoundException {
        this(name != null ? new File(name) : null, false);
    }

    /* 通过文件名创建文件输入流，并确定文件写入起始处模式 */
    public FileOutputStream(String name, boolean append)
        throws FileNotFoundException
    {
        this(name != null ? new File(name) : null, append);
    }

    /* 通过文件创建文件输入流，默认写入文件的开始处 */
    public FileOutputStream(File file) throws FileNotFoundException {
        this(file, false);
    }

    /* 通过文件创建文件输入流，并确定文件写入起始处  */
    public FileOutputStream(File file, boolean append)
        throws FileNotFoundException
    {
        String name = (file != null ? file.getPath() : null);
        SecurityManager security = System.getSecurityManager();
        if (security != null) {
            security.checkWrite(name);
        }
        if (name == null) {
            throw new NullPointerException();
        }
        if (file.isInvalid()) {
            throw new FileNotFoundException("Invalid file path");
        }
        this.fd = new FileDescriptor();
        this.append = append;
        this.path = name;
        fd.incrementAndGetUseCount();
        open(name, append);
    }

    /* 通过文件描述符类创建文件输入流 */
    public FileOutputStream(FileDescriptor fdObj) {
        SecurityManager security = System.getSecurityManager();
        if (fdObj == null) {
            throw new NullPointerException();
        }
        if (security != null) {
            security.checkWrite(fdObj);
        }
        this.fd = fdObj;
        this.path = null;
        this.append = false;

        fd.incrementAndGetUseCount();
    }

    /* 打开文件，并确定文件写入起始处模式 */
    private native void open(String name, boolean append)
        throws FileNotFoundException;

    /* 将指定的字节b写入到该文件输入流，并指定文件写入起始处模式 */
    private native void write(int b, boolean append) throws IOException;

    /* 将指定的字节b写入到该文件输入流 */
    public void write(int b) throws IOException {
        Object traceContext = IoTrace.fileWriteBegin(path);
        int bytesWritten = 0;
        try {
            write(b, append);
            bytesWritten = 1;
        } finally {
            IoTrace.fileWriteEnd(traceContext, bytesWritten);
        }
    }

    /* 将指定的字节数组写入该文件输入流，并指定文件写入起始处模式 */
    private native void writeBytes(byte b[], int off, int len, boolean append)
        throws IOException;

    /* 将指定的字节数组b写入该文件输入流 */
    public void write(byte b[]) throws IOException {
        Object traceContext = IoTrace.fileWriteBegin(path);
        int bytesWritten = 0;
        try {
            writeBytes(b, 0, b.length, append);
            bytesWritten = b.length;
        } finally {
            IoTrace.fileWriteEnd(traceContext, bytesWritten);
        }
    }

    /* 将指定len长度的字节数组b写入该文件输入流 */
    public void write(byte b[], int off, int len) throws IOException {
        Object traceContext = IoTrace.fileWriteBegin(path);
        int bytesWritten = 0;
        try {
            writeBytes(b, off, len, append);
            bytesWritten = len;
        } finally {
            IoTrace.fileWriteEnd(traceContext, bytesWritten);
        }
    }

    /* 关闭此文件输出流并释放与此流有关的所有系统资源 */
    publicvoidclose() throwsIOException {
        synchronized(closeLock) {
            if(closed) {
                return;
            }
            closed = true;
        }

        if(channel != null) {
            fd.decrementAndGetUseCount();
            channel.close();
        }

        intuseCount = fd.decrementAndGetUseCount();

        if((useCount <= 0) || !isRunningFinalize()) {
            close0();
        }
    }

     public final FileDescriptor getFD()  throws IOException {
        if(fd != null) returnfd;
        thrownewIOException();
     }

    publicFile Channel getChannel() {
        synchronized(this) {
            if(channel == null) {
                channel = FileChannelImpl.open(fd, path, false, true, append, this);

                fd.incrementAndGetUseCount();
            }
            returnchannel;
        }
    }

    protected void finalize() throws IOException {
        if(fd != null) {
            if(fd == FileDescriptor.out || fd == FileDescriptor.err) {
                flush();
            } else{

                runningFinalize.set(Boolean.TRUE);
                try{
                    close();
                } finally{
                    runningFinalize.set(Boolean.FALSE);
                }
            }
        }
    }

    private native void close0() throws IOException;

    private static native void initIDs();

    static{
        initIDs();
    }

}

1. 三个核心方法

　　三个核心方法，也就是Override（重写）了抽象类OutputStream的write方法。void write(int b) 方法，即

　　　　public void write(intb) throws IOException

　　代码实现中很简单，一个try中调用本地native的write()方法，直接将指定的字节b写入文件输出流。IoTrace.fileReadEnd()的意思和上面FileInputStream意思一致。
　　void write(byte b[]) 方法，即

　　　　public void write(byteb[]) throws IOException

　　代码实现也是比较简单的，也是一个try中调用本地native的writeBytes()方法，直接将指定的字节数组写入该文件输入流。

　　void write(byte b[], int off, int len) 方法，即

　　　　public void write(byte b[], int off, int len) throws IOException
　　代码实现和 void write(byte b[]) 方法 一样，直接将指定的字节数组写入该文件输入流。
2. 值得一提的native方法

　　上面核心方法中为什么实现简单，因为工作量都在native方法里面，即JVM里面实现了。native倒是不少一一列举吧：

　　　　native void open(String name) // 打开文件，为了下一步读取文件内容

　　　　native void write(int b, boolean append) // 直接将指定的字节b写入文件输出流

　　　　native native void writeBytes(byte b[], int off, int len, boolean append) // 直接将指定的字节数组写入该文件输入流。

　　　　native void close0() // 关闭该文件输入流及涉及的资源，比如说如果该文件输入流的FileChannel对被获取后，需要对FileChannel进行close。