简介

说明：FileInputStream流被称为文件字节输入流，继承了InputStream抽象类，用于对文件数据以字节的形式进行读取操作，如读取图片视频等

源码分析

  1. package java.io;
  3. import java.nio.channels.FileChannel;
  4. import sun.nio.ch.FileChannelImpl;
  7. /**
  8.  * A <code>FileInputStream</code> obtains input bytes
  9.  * from a file in a file system. What files
  10.  * are  available depends on the host environment.
  11.  *
  12.  * <p><code>FileInputStream</code> is meant for reading streams of raw bytes
  13.  * such as image data. For reading streams of characters, consider using
  14.  * <code>FileReader</code>.
  15.  *
  16.  * @author  Arthur van Hoff
  17.  * @see     java.io.File
  18.  * @see     java.io.FileDescriptor
  19.  * @see     java.io.FileOutputStream
  20.  * @see     java.nio.file.Files#newInputStream
  21.  * @since   JDK1.0
  22.  */
  23. public class FileInputStream extends InputStream
  24. {
  25.     /* File Descriptor - handle to the open file */
  26.     // 用于打开文件的文件描述符
  27.     private final FileDescriptor fd;
  29.     // 文件路径
  30.     private final String path;
  32.     // 文件通道
  33.     private FileChannel channel = null;
  35.     // 关闭文件输入流时用于同步锁机制的对象，保证线程安全
  36.     private final Object closeLock = new Object();
  38.     // 可见变量，标识当前输入流是否已经关闭
  39.     private volatile boolean closed = false;
  41.     /**
  42.      * 构造函数，传入文件路径名称
  43.      * @param      name   the system-dependent file name.
  44.      * @see        java.lang.SecurityManager#checkRead(java.lang.String)
  45.      */
  46.     public FileInputStream(String name) throws FileNotFoundException {
  47.         this(name != null ? new File(name) : null);
  48.     }
  50.     /**
  51.      * 构造函数，传入文件对象
  52.      * @param      file   the file to be opened for reading.
  53.      * @see        java.io.File#getPath()
  54.      * @see        java.lang.SecurityManager#checkRead(java.lang.String)
  55.      */
  56.     public FileInputStream(File file) throws FileNotFoundException {
  57.         String name = (file != null ? file.getPath() : null);
  59.         // 验证系统权限
  60.         SecurityManager security = System.getSecurityManager();
  61.         if (security != null) {
  62.             security.checkRead(name); // 验证路径是否合法且权限允许
  63.         }
  64.         if (name == null) {
  65.             throw new NullPointerException();
  66.         }
  68.         // 验证文件是否有效
  69.         if (file.isInvalid()) {
  70.             throw new FileNotFoundException("Invalid file path");
  71.         }
  73.         // 描述符赋值
  74.         fd = new FileDescriptor();
  75.         fd.attach(this);
  77.         // 文件路径赋值
  78.         path = name;
  80.         // 调用open方法打开文件，内部调用一个native方法
  81.         open(name);
  82.     }
  84.     /**
  85.      * 构造方法，传入文件描述符类
  86.      * @param      fdObj   the file descriptor to be opened for reading.
  87.      * @see        SecurityManager#checkRead(java.io.FileDescriptor)
  88.      */
  89.     public FileInputStream(FileDescriptor fdObj) {
  90.         SecurityManager security = System.getSecurityManager();
  91.         if (fdObj == null) {
  92.             throw new NullPointerException();
  93.         }
  94.         if (security != null) {
  95.             security.checkRead(fdObj);
  96.         }
  97.         fd = fdObj;
  98.         path = null;
  100.         /*
  101.          * 
  102.          */
  103.         fd.attach(this);
  104.     }
  106.     /**
  107.      * native方法，打开目标路径的文件，以读取其内容
  108.      * @param name the name of the file
  109.      */
  110.     private native void open0(String name) throws FileNotFoundException;
  112.     // wrap native call to allow instrumentation
  113.     /**
  114.      * 打开目标路径的文件
  115.      * @param name the name of the file
  116.      */
  117.     private void open(String name) throws FileNotFoundException {
  118.         open0(name);
  119.     }
  121.     /**
  122.      * 从此输入流中读取一个数据字节。如果没有输入可用，则此方法将阻塞
  123.      * 返回-1表示已经到了文件末尾，无数据可读
  124.      * @return     the next byte of data, or <code>-1</code> if the end of the
  125.      *             file is reached.
  126.      */
  127.     public int read() throws IOException {
  128.         return read0();
  129.     }
  131.     /**
  132.      *  native方法，从目标文件读取一个字节
  133.      */
  134.     private native int read0() throws IOException;
  136.     /**
  137.      * native方法，用于将数据读入字节数组
  138.      * @param b the data to be written
  139.      * @param off the start offset in the data
  140.      * @param len the number of bytes that are written
  141.      */
  142.     private native int readBytes(byte b[], int off, int len) throws IOException;
  144.     /**
  145.      * 从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中,底层调用native方法
  146.      * @param      b   the buffer into which the data is read.
  147.      * @return     the total number of bytes read into the buffer, or
  148.      *             <code>-1</code> if there is no more data because the end of
  149.      *             the file has been reached.
  150.      */
  151.     public int read(byte b[]) throws IOException {
  152.         return readBytes(b, 0, b.length);
  153.     }
  155.     /**
  156.      * 从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。
  157.      * @param      b     the buffer into which the data is read.
  158.      * @param      off   the start offset in the destination array <code>b</code>
  159.      * @param      len   the maximum number of bytes read.
  160.      * @return     the total number of bytes read into the buffer, or
  161.      *             <code>-1</code> if there is no more data because the end of
  162.      *             the file has been reached.
  163.      */
  164.     public int read(byte b[], int off, int len) throws IOException {
  165.         return readBytes(b, off, len);
  166.     }
  168.     /**
  169.      * 实现父类方法，跳过指定字节数
  170.      * @param      n   the number of bytes to be skipped.
  171.      * @return     the actual number of bytes skipped.
  172.      */
  173.     public long skip(long n) throws IOException {
  174.         return skip0(n);
  175.     }
  177.     /**
  178.      * 本地方法，越过指定字节数
  179.      * @param      n   the number of bytes to be skipped.
  180.      * @return     the actual number of bytes skipped.
  181.      */
  182.     private native long skip0(long n) throws IOException;
  184.     /**
  185.      * 返回估计的剩余可读取字节数。
  186.      * @return     an estimate of the number of remaining bytes that can be read
  187.      *             (or skipped over) from this input stream without blocking.
  188.      */
  189.     public int available() throws IOException {
  190.         return available0();
  191.     }
  193.     private native int available0() throws IOException;
  195.     /**
  196.      * 关闭字节流
  197.      * @revised 1.4
  198.      * @spec JSR-51
  199.      */
  200.     public void close() throws IOException {
  201.         // 同步锁机制
  202.         synchronized (closeLock) {
  203.             if (closed) {
  204.                 return;
  205.             }
  206.             closed = true;
  207.         }
  209.         // 关闭通道
  210.         if (channel != null) {
  211.            channel.close();
  212.         }
  214.         // 关闭所有与描述符相关的资源
  215.         fd.closeAll(new Closeable() {
  216.             public void close() throws IOException {
  217.                close0();
  218.            }
  219.         });
  220.     }
  222.     /**
  223.      * 获取当前输入流的文件描述符
  224.      * @return     the file descriptor object associated with this stream.
  225.      * @see        java.io.FileDescriptor
  226.      */
  227.     public final FileDescriptor getFD() throws IOException {
  228.         if (fd != null) {
  229.             return fd;
  230.         }
  231.         throw new IOException();
  232.     }
  234.     /**
  235.      * 通过当前输入流打开通道并返回
  236.      * @return  the file channel associated with this file input stream
  237.      * @since 1.4
  238.      * @spec JSR-51
  239.      */
  240.     public FileChannel getChannel() {
  242.         // 同步方法 
  243.         synchronized (this) {
  244.             if (channel == null) {
  245.                 channel = FileChannelImpl.open(fd, path, true, false, this);
  246.             }
  247.             return channel;
  248.         }
  249.     }
  251.     // 设置类中（也就是FileInputStream）的属性的内存地址偏移量
  252.     private static native void initIDs();
  254.     // 本地方法，关闭输入流
  255.     private native void close0() throws IOException;
  257.     static {
  258.         initIDs();
  259.     }
  261.     /**
  262.      * 确保不再引用文件输入流时调用其 close 方法
  263.      * @see  java.io.FileInputStream#close()
  264.      */
  265.     protected void finalize() throws IOException {
  266.         if ((fd != null) &&  (fd != FileDescriptor.in)) {
  267.             /* if fd is shared, the references in FileDescriptor
  268.              * will ensure that finalizer is only called when
  269.              * safe to do so. All references using the fd have
  270.              * become unreachable. We can call close()
  271.              */
  272.             close();
  273.         }
  274.     }
  275. }

简单使用

现有一文件file.txt，内容如下：
图片.png

package com.java.io;

import java.io.*;

/**
 * @description InputStream 示例
 * @date: 2021-01-17 15:01
 */
public class InputStreamExample {
    public static void main(String[] args) {
        commonExample();
    }

    public static void commonExample() {
        // 文件路径
        String filePath = "D:\\IDEAWorkSpace\\JAVALearn\\io\\src\\resource\\file.txt";
        FileInputStream inputStream = null;
        try {

            // 根据文件路径构建文件输入流对象
            inputStream = new FileInputStream(filePath);
            byte[] bytes = new byte[1024];
            int read = inputStream.read(bytes,0,10); // 读取10个字节并放入byte数组
            int available = inputStream.available(); // 允许读取的剩余字节数

            System.out.println("读取到了"+read+"个字节，还剩"+available+"个字节可读");
            System.out.println("字节原始内容："+ Arrays.toString(bytes));
            System.out.println("读取到的内容："+new String(bytes)); // 将字节数组转为普通字符串输出

            // 读取剩余字节并存放到byte数组已有元素的后面【最后成为下标read开始的available个元素】
            inputStream.read(bytes,read,available);
            System.out.println("完整读取后："+new String(bytes));

        } catch (FileNotFoundException e) {
            System.err.println("文件不存在");
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(null != inputStream){
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

输出结果：

读取到了10个字节，还剩2个字节可读
字节原始内容：[66, 121, 101, 33, 66, 121, 101, 33, 66, 121, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
读取到的内容：Bye!Bye!By
完整读取后：Bye!Bye!Bye!

思考

读取的字节为什么返回int型变量

1、read方法返回-1相当于是数据字典告诉调用者文件已到底，可以结束读取了，这里的-1是Int型

 当文件未到底时，我们读取的是字节，若返回byte类型，那么势必造成**同一方法返回类型不同**的情况这是不允许的

 2、我们读取的字节实际是由8位二进制组成，**二进制文件不利于直观查看**，可以转成常用的十进制进行展示，因此需要把读取的字节从二进制转成十进制整数，故返回int型

因此结合以上2点，保证**返回类型一致以及直观查看**的情况，因此该方法虽然读取的是字节但返回int型