JDK 1.7 java.io 源码学习之FileInputStream和FileOutputStream

最新推荐文章于 2022-05-25 11:29:47 发布

Rickesy

最新推荐文章于 2022-05-25 11:29:47 发布

阅读量891

点赞数

分类专栏： Java IO 文章标签： java

本文链接：https://blog.csdn.net/Rickesy/article/details/56291088

版权

Java IO 专栏收录该内容

8 篇文章

订阅专栏

本文探讨了Java IO中的FileInputStream和FileOutputStream类，详细分析了它们的构造函数、核心方法，包括read()和write()的实现，并提到了与FileChannel的交互。通过对native方法的讨论，揭示了这两个类在操作文件时的工作原理。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

文件，应该是开发中较常见的数据源了，故操作文件的字节输入/输出流FileInputStream和FileOutputStream 是 Java IO 字节流中重要的实现类之一。

在说FileInputStream和FileOutputStream之前不得不提一下File类。
File也是java.io 包中的一个类，主要用于描述文件及文件目录路径，具体这里不展开，在FileInputStream和FileOutputStream中主要就是在构造FileInputStream和FileOutputStream时，告知其数据源。

FileInputStream有两个较常见的构造函数：

public FileInputStream(String name) throws FileNotFoundException {
    this(name != null ? new File(name) : null);
}

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);
}

从上述两个构造函数大致可以看出，前面一些都是控制和属性赋值相关的语句，核心的就是最后一句open(String name)方法

而且也引出了另一个构造函数：

public FileInputStream(FileDescriptor fdObj) {
    SecurityManager security = System.getSecurityManager();
    if(fdObj == null) {
        throw new NullPointException();
    }
    if(security != null) {
        security.checkRead(fdObj);
    }
    fd = fdObj;
    path = null;
    fd.incrementAndGetUseCount();
}

但是open(String name) 其实是一个native方法，由JVM自身实现：

private native void open(String name) throws FileNotFouondException;

最重要的三个方法即InputStream三个read()方法的重写：

public ind read() throws IOException

public ind read() throws IOException {
   Object traceContext = IoTrace.fileReadBegin(path);
   int b = 0;
   try {
       b = read0();
   } finally {
       IoTrace.fileReadEnd(traceContext, b == -1 ? 0 : 1);
   }
   return b;
}

private native int read0() throws IOException;

实际只是调用了native read0()方法

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

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;
}

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;
}

private native int readBytes(byte b[], int off, int len) throws IOException;

实际只是调用了native readBytes(byte b[], int off, int len)方法

其他好几个也都是native 方法，像skip()， available()，open(String name) 等等

值得一提的就是，增加了一个获取NIO对象FileChannel的方法：

public FileChannel getChannel() {
    synchronized (this) {
        if(channel == null) {
             channel = FileChannelImpl.open(fd, path, true, false, this);
             fd.incrementAndGetUseCount();
        }
        return channel;
    }
}

具体等后面看了NIO相关内容再补充吧！这个方法和单例模式还是非常相像的。

对应的FileOutputStream也是类似的结构：

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);
}

publid 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();
    }

FileOutputStream的构造函数相比FileInputStream的多了一个boolean append的参数，所以构造函数多了一个重载的构造函数。
boolean append 参数表示是否从文件内容末尾进行追加，默认是不追加的，采用覆盖模式，即如果文件原本是有内容的，一旦创建了针对这个文件的FileOutputStream，该文件的内容就被覆盖了，因为一旦通过构造函数实例化了FileOutputStream对象，其已经调用了open方法：

private native void open(String name, boolean append) throws FileNotFoundException;

较重要的三个方法也是对OutputStream重写的三个write方法：

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 write(int b, boolean append) throws IOException;

private native void writeBytes(byte b[], int off, int len, boolean append) throws IOException;

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);
    }
}

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);
    }
}

相应的都是调用相关的native方法

也增加了一个获取NIO对象FileChannel的方法：

public FileChannel getChannel() {
    synchronized (this) {
        if (channel == null) {
            channel = FileChannelImpl.open(fd, path, false, true, append, this);
            fd.incrementAndGetUseCount();
        }
        return channel;
    }
}

其他的像close()方法最终也是调用的natvie close0() 方法

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();
    }
}

private native void close0() throws IOException;

这两个类暂时看到这里了。