Java FileInputStream 原理用法源码分析

原理

Java 中的 FileInputStream 是一个输入流类，用于从文件中读取数据。以下是 FileInputStream 的原理：

1. 打开文件：
   • 在创建 FileInputStream 对象时，需要提供要读取的文件的路径。
   • FileInputStream 会尝试打开指定路径的文件，并建立与该文件的连接。
2. 读取数据：
   • 当调用 read() 方法时，FileInputStream 会从文件中读取下一个字节的数据，并返回读取到的字节值（0-255）。
   • 如果已经到达文件末尾，read() 方法将返回 -1。
3. 关闭文件：
   • 在不再需要使用 FileInputStream 对象时，应该调用 close() 方法关闭与文件的连接，释放资源。

FileInputStream 通过底层的操作系统接口来实现文件的读取功能，它直接与操作系统交互以获取文件的数据。在读取数据时，FileInputStream 会根据当前读取位置逐个字节地读取文件中的数据。

注意事项

在使用FileInputStream读取文件时，有一些注意事项需要注意：

1. 文件路径：确保提供正确的文件路径。路径可以是相对路径（相对于当前工作目录）或绝对路径,。如果使用相对路径，请确保路径相对于当前工作目录是有效的。如果使用绝对路径，请确保路径是正确的。如果只有文件名字，则该文件需要放在项目根目录下面。
2. 文件存在性：在打开FileInputStream之前，确保文件实际上存在。否则，将会抛出FileNotFoundException异常。
3. 权限问题：确保你对要读取的文件具有足够的权限。否则，可能会抛出SecurityException异常。
4. 关闭流：使用完毕后，记得调用close()方法关闭FileInputStream流，以释放相关资源。这是一个很重要的步骤，避免资源泄露。

用法示例

以下是使用FileInputStream类的示例：

import java.io.FileInputStream;
import java.io.IOException;

public class FileInputStreamExample {
    public static void main(String[] args) {
        FileInputStream fis = null;
        try {
            // 创建FileInputStream对象，打开文件进行读取
            fis = new FileInputStream("example.txt");

            int data;
            // 读取文件中的字节数据
            while ((data = fis.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fis != null) {
                    fis.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

在上述示例中，我们创建了一个FileInputStream对象来读取名为"example.txt"的文件。然后，使用read()方法逐个字节地读取文件中的数据，并将其转换为字符并输出到控制台。最后，在finally块中关闭输入流以释放系统资源。

方法总结

这是一个FileInputStream类，它从文件系统中的文件获取输入字节。可以获得哪些文件取决于主机环境。

FileInputStream适用于读取原始字节流，例如图像数据。对于读取字符流，请考虑使用FileReader。

• fd：表示打开文件的文件描述符。

• path：所引用文件的路径（如果使用文件描述符创建流，则为null）。

• channel：与该文件输入流关联的文件通道。

• closeLock：用于同步关闭操作的锁对象。

• closed：指示流是否已关闭的标志。

• FileInputStream(String name)：通过打开到实际文件的连接来创建FileInputStream，文件由路径名name指定。创建一个新的FileDescriptor对象来表示此文件连接。

• FileInputStream(File file)：通过打开到实际文件的连接来创建FileInputStream，文件由File对象file指定。创建一个新的FileDescriptor对象来表示此文件连接。

• FileInputStream(FileDescriptor fdObj)：使用表示到实际文件的现有连接的文件描述符fdObj创建FileInputStream。

• open(String name)：打开指定的文件以进行读取。

• read()：从输入流中读取下一个字节的数据。

• read(byte b[])：将最多b.length字节的数据从输入流读入到字节数组中。

• read(byte b[], int off, int len)：将最多len字节的数据从输入流读入到字节数组的指定位置。

• skip(long n)：跳过并丢弃输入流中的n个字节。

• available()：返回估计的从输入流中可读取（或跳过）的字节数，而不会被阻塞。

• close()：关闭文件输入流并释放与之关联的系统资源。

需要注意的是，FileInputStream继承自InputStream类，并提供了对文件的读取功能。

中文源码

/**
 * FileInputStream 从文件系统中获取输入字节流。
 * 可用的文件取决于主机环境。
 *
 * FileInputStream 适用于读取原始字节流，如图像数据。
 * 如果需要读取字符流，请考虑使用 FileReader。
 *
 * @author Arthur van Hoff
 * @see java.io.File
 * @see java.io.FileDescriptor
 * @see java.io.FileOutputStream
 * @see java.nio.file.Files#newInputStream
 * @since JDK1.0
 */
public class FileInputStream extends InputStream {

    /* 文件描述符 - 打开文件的句柄 */
    private final FileDescriptor fd;

    /**
     * 引用文件的路径（如果使用文件描述符创建流，则为 null）
     */
    private final String path;

    private FileChannel channel = null;

    private final Object closeLock = new Object();
    private volatile boolean closed = false;

    /**
     * 通过打开与实际文件的连接来创建 FileInputStream，
     * 连接的文件由路径名 name 指定。创建一个新的 FileDescriptor 对象以表示此文件连接。
     * 首先，如果存在 SecurityManager，则使用 name 参数调用其 checkRead 方法。
     * 如果指定的文件不存在、是目录而不是常规文件，或者由于其他原因无法打开进行读取，则抛出 FileNotFoundException。
     *
     * @param name 系统相关的文件名
     * @exception FileNotFoundException 如果文件不存在、是目录而不是常规文件，或者由于其他原因无法打开进行读取
     * @exception SecurityException 如果存在 SecurityManager 并且其 checkRead 方法拒绝读取文件的访问权限
     * @see java.lang.SecurityManager#checkRead(java.lang.String)
     */
    public FileInputStream(String name) throws FileNotFoundException {
        this(name != null ? new File(name) : null);
    }

    /**
     * 通过打开与实际文件的连接来创建 FileInputStream，
     * 连接的文件由 File 对象 file 指定。创建一个新的 FileDescriptor 对象以表示此文件连接。
     * 首先，如果存在 SecurityManager，则使用 file 参数表示的路径调用其 checkRead 方法。
     * 如果指定的文件不存在、是目录而不是常规文件，或者由于其他原因无法打开进行读取，则抛出 FileNotFoundException。
     *
     * @param file 要打开进行读取的文件
     * @exception FileNotFoundException 如果文件不存在、是目录而不是常规文件，或者由于其他原因无法打开进行读取
     * @exception SecurityException 如果存在 SecurityManager 并且其 checkRead 方法拒绝读取文件的访问权限
     * @see java.io.File#getPath()
     * @see java.lang.SecurityManager#checkRead(java.lang.String)
     */
    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.attach(this);
        path = name;
        open(name);
    }

    /**
     * 通过使用表示现有与实际文件的连接的文件描述符 fdObj 来创建 FileInputStream。
     * 如果存在 SecurityManager，则以 file descriptor fdObj 作为其参数调用其 checkRead 方法，
     * 以查看是否可以读取文件描述符。如果对文件描述符的读访问被拒绝，将抛出 SecurityException。
     * 如果 fdObj 为 null，则抛出 NullPointerException。
     * 此构造函数不会在 fdObj 是无效的情况下抛出异常。
     * 但是，如果对生成的流调用方法以尝试对流进行 I/O 操作，则会抛出 IOException。
     *
     * @param fdObj 要打开进行读取的文件描述符
     * @throws SecurityException 如果存在 SecurityManager 并且其 checkRead 方法拒绝读取文件描述符的访问权限
     * @see SecurityManager#checkRead(java.io.FileDescriptor)
     */
    public FileInputStream(FileDescriptor fdObj) {
        SecurityManager security = System.getSecurityManager();
        if (fdObj == null) {
            throw new NullPointerException();
        }
        if (security != null) {
            security.checkRead(fdObj);
        }
        fd = fdObj;
        path = null;

        /*
         * FileDescriptor 被流共享。
         * 将此流注册到 FileDescriptor 追踪器。
         */
        fd.attach(this);
    }

    /**
     * 打开指定的文件进行读取。
     * @param name 文件名
     */
    private native void open0(String name) throws FileNotFoundException;

    // 包装本地调用以允许插桩
    /**
     * 打开指定的文件进行读取。
     * @param name 文件名
     */
    private void open(String name) throws FileNotFoundException {
        open0(name);
    }

    /**
     * 从该输入流中读取一个字节的数据。如果没有可用的输入，则此方法将阻塞。
     *
     * @return 下一个字节的数据，如果到达文件末尾则返回 -1。
     * @exception IOException 如果发生 I/O 错误。
     */
    public int read() throws IOException {
        return read0();
    }

    private native int read0() throws IOException;

    /**
     * 以字节数组的形式读取子数组。
     * @param b 要写入的数据
     * @param off 数据中的起始偏移量
     * @param len 要写入的字节数
     * @exception IOException 如果发生 I/O 错误。
     */
    private native int readBytes(byte b[], int off, int len) throws IOException;

    /**
     * 将最多 b.length 个字节的数据从此输入流读入到字节数组中。
     * 此方法会阻塞，直到有一些输入可用。
     *
     * @param b 要读入数据的缓冲区。
     * @return 读入缓冲区的总字节数；如果因为已达到文件末尾而没有更多数据，则返回 -1。
     * @exception IOException 如果发生 I/O 错误。
     */
    public int read(byte b[]) throws IOException {
        return readBytes(b, 0, b.length);
    }

    /**
     * 将最多 len 个字节的数据从此输入流读入到字节数组中。
     * 如果 len 不为零，则该方法会阻塞，直到有一些输入可用；
     * 否则，不会读取任何字节，并返回 0。
     *
     * @param b 要读入数据的缓冲区。
     * @param off 目标数组 b 中的起始偏移量
     * @param len 最多读取的字节数。
     * @return 读入缓冲区的总字节数；如果因为已达到文件末尾而没有更多数据，则返回 -1。
     * @exception NullPointerException 如果 b 为 null。
     * @exception IndexOutOfBoundsException 如果 off 为负数，len 为负数或 len 大于 b.length - off。
     * @exception IOException 如果发生 I/O 错误。
     */
    public int read(byte b[], int off, int len) throws IOException {
        return readBytes(b, off, len);
    }

    /**
     * 跳过并丢弃输入流中的 n 个字节的数据。
     *
     * <p>skip 方法可能由于各种原因跳过一些较小数量的字节，可能为 0。
     * 如果 n 为负数，则该方法将尝试向后跳过。如果备份文件在其当前位置不支持向后跳过，
     * 则抛出 IOException。返回实际跳过的字节数。如果前进跳过，则返回正值。
     * 如果向后跳过，则返回负值。
     *
     * <p>此方法可能会跳过比文件中剩余的字节数更多的字节。
     * 这不会产生异常，并且跳过的字节数可能包括超出备份文件 EOF 的一些字节。
     * 在跳过结束后尝试从流中读取将导致返回 -1，表示文件结束。
     *
     * @param n 要跳过的字节数。
     * @return 实际跳过的字节数。
     * @exception IOException 如果 n 为负数，如果流不支持寻址，或者发生 I/O 错误。
     */
    public long skip(long n) throws IOException {
        return skip0(n);
    }

    private native long skip0(long n) throws IOException;

    /**
     * 返回可以在下一次调用此输入流的方法时读取（或跳过）的剩余字节数的估计值，
     * 而不会阻塞。到达文件末尾时返回 0。下一次调用可能是相同的线程或另一个线程。
     * 单个读取或跳过这么多字节不会阻塞，但可能读取或跳过较少的字节。
     *
     * <p>在某些情况下，非阻塞读取（或跳过）可能会出现阻塞的情况，当然也可能很慢，
     * 例如在通过缓慢的网络读取大文件时。
     *
     * @return 可以在不阻塞的情况下从此输入流中读取（或跳过）的剩余字节数的估计值。
     * @exception IOException 如果该文件输入流已由调用 close 或发生 I/O 错误关闭
     */
    public int available() throws IOException {
        return available0();
    }

    private native int available0() throws IOException;

    /**
     * 关闭此文件输入流并释放与该流关联的所有系统资源。
     *
     * <p>如果该流有关联的通道，则也将关闭该通道。
     *
     * @exception IOException 如果发生 I/O 错误。
     *
     * @revised 1.4
     * @spec JSR-51
     */
    public void close() throws IOException {
        synchronized (closeLock) {
            if (closed) {
                return;
            }
            closed = true;
        }
        if (channel != null) {
           channel.close();
        }

        fd.closeAll(new Closeable() {
            public void close() throws IOException {
               close0();
           }
        });
    }

    /**
     * 返回表示由该 FileInputStream 使用的实际文件连接的 FileDescriptor 对象。
     *
     * @return 与此流关联的文件描述符对象。
     * @exception IOException 如果发生 I/O 错误。
     * @see java.io.FileDescriptor
     */
    public final FileDescriptor getFD() throws IOException {
        if (fd != null) {
            return fd;
        }
        throw new IOException();
    }

    /**
     * 返回与此文件输入流关联的唯一 FileChannel 对象。
     *
     * <p>返回的通道的初始位置将等于到目前为止从文件中读取的字节数。
     * 从该流中读取字节将增加通道的位置。更改通道的位置（无论是显式还是通过读取）将更改此流的文件位置。
     *
     * @return 与此文件输入流关联的文件通道。
     *
     * @since 1.4
     * @spec JSR-51
     */
    public FileChannel getChannel() {
        synchronized (this) {
            if (channel == null) {
                channel = FileChannelImpl.open(fd, path, true, false, this);
            }
            return channel;
        }
    }

    private static native void initIDs();

    private native void close0() throws IOException;

    static {
        initIDs();
    }

    /**
     * 确保在没有对其进行引用时调用此文件输入流的 close 方法。
     *
     * @exception IOException 如果发生 I/O 错误。
     * @see java.io.FileInputStream#close()
     */
    protected void finalize() throws IOException {
        if ((fd != null) &&  (fd != FileDescriptor.in)) {
            /* 如果 fd 是共享的，FileDescriptor 中的引用将确保只有在安全的情况下才调用 finalizer。
             * 使用 fd 的所有引用都已变得不可访问。我们可以调用 close()。
             */
            close();
        }
    }
}