百度360必应搜狗淘宝本站头条
vba高级教程svn连接scheduledtaskmybatis plus结构体数组
当前位置：网站首页 > 编程网 > 正文

Java IO 之 FileInputStream & FileOutputStream源码分析

yuyutoo 2024-10-12 01:31 8 浏览 0 评论

一、引子

文件，作为常见的数据源。关于操作文件的字节流就是 — FileInputStream & FileOutputStream。它们是Basic IO字节流中重要的实现类。

二、FileInputStream源码分析

FileInputStream源码如下：

 /**
 * FileInputStream 从文件系统的文件中获取输入字节流。文件取决于主机系统。
 * 	比如读取图片等的原始字节流。如果读取字符流，考虑使用 FiLeReader。
 */
public class SFileInputStream 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对象 */
    public FileChannel getChannel() {
        synchronized (this) {
            if (channel == null) {
                channel = FileChannelImpl.open(fd, path, true, false, this);
                fd.incrementAndGetUseCount();
            }
            return channel;
        }
    }

    private static native void initIDs();

    private native void close0() throws IOException;

    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() 方法，即

//java学习交流:737251827  进入可领取学习资源及对十年开发经验大佬提问，免费解答！
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中。

可是这里有个问答：
Q： 为什么 int read(byte b[]) 方法需要自己独立实现呢？ 直接调用 int read(byte b[], int off, int len) 方法，即read(b , 0 , b.length)，等价于read(b)？
A：待完善，希望路过大神回答。。。。向下兼容？？ Finally？？

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对象。


《【甘货合集】Java其实很好学，但是你需要知道在“爪哇”的世界里“你究竟在哪？”》?shimo.im/docs/WYPXYVhDVVcHWxvH/

三、FileOutputStream 源码分析

FileOutputStream 源码如下：

/**
 * FileInputStream 从文件系统的文件中获取输入字节流。文件取决于主机系统。
 * 	比如读取图片等的原始字节流。如果读取字符流，考虑使用 FiLeReader。
 */
public class SFileInputStream 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对象 */
    public FileChannel getChannel() {
        synchronized (this) {
            if (channel == null) {
                channel = FileChannelImpl.open(fd, path, true, false, this);
                fd.incrementAndGetUseCount();
            }
            return channel;
        }
    }

    private static native void initIDs();

    private native void close0() throws IOException;

    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（重写）了抽象类OutputStream的write方法。

void write(int b) 方法，即

 public void write(int b) throws IOException


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


void write(byte b[]) 方法，即

 public void write(byte b[]) 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。

相似之处：

其实到这里，该想一想。两个源码实现很相似，而且native方法也很相似。其实不能说“相似”，应该以“对应”来概括它们。
它们是一组，是一根吸管的两个孔的关系：“一个Input一个Output”。

四、使用案例

下面先看代码：

package org.javacore.io;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/*
 * Copyright [2015] [Jeff Lee]
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/**
 * @author Jeff Lee
 * @since 2015-10-8 20:06:03
 * FileInputStream&FileOutputStream使用案例
 */
public class FileIOStreamT {
	private static final String thisFilePath = 
			"src" + File.separator +
			"org" + File.separator +
			"javacore" + File.separator +
			"io" + File.separator +
			"FileIOStreamT.java";
	public static void main(String[] args) throws IOException {
		// 创建文件输入流
		FileInputStream fileInputStream = new FileInputStream(thisFilePath);
		// 创建文件输出流
		FileOutputStream fileOutputStream =  new FileOutputStream("data.txt");
		
		// 创建流的最大字节数组
		byte[] inOutBytes = new byte[fileInputStream.available()];
		// 将文件输入流读取，保存至inOutBytes数组
		fileInputStream.read(inOutBytes);
		// 将inOutBytes数组，写出到data.txt文件中
		fileOutputStream.write(inOutBytes);
		
		fileOutputStream.close();
		fileInputStream.close();
	}
}

运行后，会发现根目录中出现了一个“data.txt”文件，内容为上面的代码。

1. 简单地分析下源码：

1、创建了FileInputStream，读取该代码文件为文件输入流。
2、创建了FileOutputStream，作为文件输出流，输出至data.txt文件。
3、针对流的字节数组，一个 read ，一个write，完成读取和写入。
4、关闭流

2. 代码调用的流程如图所示：

正在上传…重新上传取消?

3. 代码虽简单，但是有点小问题：

FileInputStream.available() 是返回流中的估计剩余字节数。所以一般不会用此方法。
一般做法，比如创建一个 byte数组，大小1K。然后read至其返回值不为-1，一直读取即可。边读边写。

五、思考与小结

FileInputStream & FileOutputStream 是一对来自 InputStream和OutputStream的实现类。用于本地文件读写（二进制格式按顺序读写）。

本文小结：

1、FileInputStream 源码分析
2、FileOutputStream 资源分析
3、FileInputStream & FileOutputStream 使用案例
4、其源码调用过程

相关推荐

Python操作Word文档神器:python-docx库从入门到精通

Python操作Word文档神器：python-docx库从入门到精通动动小手，点击关注...

Python 函数调用从入门到精通:超详细定义解析与实战指南 附案例

一、函数基础：定义与调用的核心逻辑定义：函数是将重复或相关的代码块封装成可复用的单元，通过函数名和参数实现特定功能。它是Python模块化编程的基础，能提高代码复用性和可读性。定义语法：...

等这么长时间Python背记手册终于来了，入门到精通(视频400集)

本文毫无套路！真诚分享！前言：无论是学习任何一门语言，基础知识一定要扎实，基础功非常的重要，找一个有丰富编程经验的老师或者师兄带着你会少走很多弯路，你的进步速度也会快很多，无论我们学习的目的是什么，...

图解Python编程:从入门到精通系列教程(附全套速查表)

引言本系列教程展开讲解Python编程语言，Python是一门开源免费、通用型的脚本编程语言，它上手简单，功能强大，它也是互联网最热门的编程语言之一。Python生态丰富，库（模块）极其丰富，这使...

Python入门教程(非常详细)从零基础入门到精通，看完这一篇就够

本书是Python经典实例解析，采用基于实例的方法编写，每个实例都会解决具体的问题和难题。主要内容有：数字、字符串和元组，语句与语法，函数定义，列表、集、字典，用户输入和输出等内置数据结构，类和对象，...

Python函数全解析:从入门到精通，一文搞定!

1.为什么要用函数？函数的作用：封装代码，提高复用性，减少重复，提高可读性。...

Python中的单例模式:从入门到精通

Python中的单例模式：从入门到精通引言单例模式是一种常用的软件设计模式，它保证了一个类只有一个实例，并提供一个全局访问点。这种模式通常用于那些需要频繁创建和销毁的对象，比如日志对象、线程池、缓存等...

【Python王者归来】手把手教你，Python从入门到精通!

用800个程序实例、5万行代码手把手教你，Python从入门到精通！...

Python从零基础入门到精通:一个月就够了

如果想从零基础到入门，能够全职学习（自学），那么一个月足够了。...

Python 从入门到精通:一个月就够了

要知道，一个月是一段很长的时间。如果每天坚持用6-7小时来做一件事，你会有意想不到的收获。作为初学者，第一个月的月目标应该是这样的：熟悉基本概念（变量，条件，列表，循环，函数）练习超过30个编...

Python零基础到精通，这8个入门技巧让你少走弯路，7天速通编程!

Python学习就像玩积木，从最基础的块开始，一步步搭建出复杂的作品。我记得刚开始学Python时也是一头雾水，走了不少弯路。现在回头看，其实掌握几个核心概念，就能快速入门这门编程语言。来聊聊怎么用最...

神仙级python入门教程(非常详细)，从0到精通，从看这篇开始!

python入门虽然简单，很多新手依然卡在基础安装阶段，大部分教程对一些基础内容都是一带而过，好多新手朋友，对一些基础知识常常一知半解，需要在网上查询很久。...

Python类从入门到精通，一篇就够!

一、Python类是什么？大家在生活中应该都见过汽车吧，每一辆真实存在、能在路上跑的汽车，都可以看作是一个“对象”。那这些汽车是怎么生产出来的呢？其实，在生产之前，汽车公司都会先设计一个详细的蓝图...

学习Python从入门到精通:30天足够了，这才是python基础的天花板

当年2w买的全套python教程用不着了，现在送给有缘人，不要钱，一个月教你从入门到精通1、本套视频共487集,本套视频共分4季...

30天Python 入门到精通（3天学会python）

以下是一个为期30天的Python入门到精通学习课程，专为零基础新手设计。课程从基础语法开始，逐步深入到面向对象编程、数据处理，最后实现运行简单的大语言模型（如基于HuggingFace...

取消回复欢迎 你 发表评论:

一周热门
最近发表
标签列表