Java 之 字节输入流 [InputStream]

一、字节输入流

　　java.io.InputStream 抽象类是表示字节输入流的所有类的超类，可以读取字节信息到内存中。

　　它定义了字节输入流的基本共性功能方法。

　　共性方法：

public abstract int read() ： 从输入流读取数据的下一个字节。返回 0 到 255 范围内的 int 字节值。
public int read(byte[] b) ： 从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中，否则以整数形式返回实际读取的字节数。
public int read(byte[] b, int off, int len) ：一次读取多个字节，返回本次实际读取字节数，读取的字节存到b数组中，从[off]开始存储，一次最多读取len个字节
public void close() ：关闭此输入流并释放与此流相关联的任何系统资源。

　　如果 read() 方法到达流末尾没有可用的字节，返回-1。

　　注意：close 方法，当完成流的操作时，必须调用此方法，释放系统资源。

　 InputStream 的子类
    

　　深色的为节点流，浅色的为处理流。

二、FileInputStream 类

　　java.io.FileInputStream 类是文件输入流，从文件中读取数据，读取到内存中使用。

　　1、构造方法

FileInputStream(File file) ： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名。
FileInputStream(String name) ： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。

　　　　参数：读取文件的数据源

　　　　　　String name：文件的路径

　　　　　　File file：文件对象

　　　  构造方法的作用：

　　　　　　① 会创建一个FileInputStream对象

　　　　　　② 会把FileInputStream对象指定构造方法中要读取的文件

　　　　读取数据的原理（硬盘--> 内存）

　　　　　　java程序-->JVM-->OS-->OS读取数据的方法-->读取文件

　　　　字节输入流的使用步骤【重要】：

　　　　　　① 创建FileInputStream对象,构造方法中绑定要读取的数据源

　　　　　　② 使用FileInputStream对象中的方法read,读取文件

　　　　　　③ 释放资源

　　2、读取字节数据

　　　　（1）读取字节： read 方法，每次可以读取一个字节的数据，提升为int类型，读取到文件末尾，返回 -1 ，代码使用演示：

  public static void main(String[] args) throws IOException {
         //1.创建FileInputStream对象,构造方法中绑定要读取的数据源
         FileInputStream fis = new FileInputStream("E:\\c.txt");
         //2.使用FileInputStream对象中的方法read,读取文件
         //int read()读取文件中的一个字节并返回,读取到文件的末尾返回-1
             /*
             发现以上读取文件是一个重复的过程,所以可以使用循环优化
             不知道文件中有多少字节,使用while循环
             while循环结束条件,读取到-1的时候结束

             布尔表达式(len = fis.read())!=-1
                 1.fis.read():读取一个字节
                 2.len = fis.read():把读取到的字节赋值给变量len
                 3.(len = fis.read())!=-1:判断变量len是否不等于-1
          */
         int len = 0; //记录读取到的字节
         while((len = fis.read())!=-1){
             System.out.print(len);//abc
         }

         //3.释放资源
         fis.close();
     }

　　　　（2）使用字节数组读取： read(byte[] b) ，每次读取b的长度个字节到数组中，返回读取到的有效字节个数，读取到末尾时，返回 -1 。

　　　　int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。

　　　　明确两件事情：

　　　　　　a. 方法的参数byte[]的作用?

　　　　　　　　起到缓冲作用,存储每次读取到的多个字节,数组的长度一把定义为1024(1kb)或者1024的整数倍

　　　　　　b.方法的返回值int是什么?

　　　　　　　　每次读取的有效字节个数

　　　　　　Demo :

  public static void main(String[] args) throws IOException {
         //创建FileInputStream对象,构造方法中绑定要读取的数据源
         FileInputStream fis = new FileInputStream("E:\\b.txt");
         //使用FileInputStream对象中的方法read读取文件
         //int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。
          /*
             发现以上读取时一个重复的过程,可以使用循环优化
             不知道文件中有多少字节,所以使用while循环
             while循环结束的条件,读取到-1结束
          */
         byte[] bytes = new byte[1024];//存储读取到的多个字节
         int len = 0; //记录每次读取的有效字节个数
         while((len = fis.read(bytes))!=-1){
             //String(byte[] bytes, int offset, int length) 把字节数组的一部分转换为字符串 offset:数组的开始索引 length:转换的字节个数
             System.out.println(new String(bytes,0,len));
         }

         //释放资源
         fis.close();
     }

　　Tips：使用数组读取，每次读取多个字节，减少了系统间的IO操作次数，从而提高了读写的效率，建议开发中使用。

　　字节流读取文件的原理：

三、复制文件案例

　　复制文件原理图解：

　　文件复制的步骤：

　　　　1. 创建一个字节输入流对象,构造方法中绑定要读取的数据源

　　　　2. 创建一个字节输出流对象,构造方法中绑定要写入的目的地

　　　　3. 使用字节输入流对象中的方法read读取文件

　　　　4. 使用字节输出流中的方法write,把读取到的字节写入到目的地的文件中

　　　　5. 释放资源

　　代码实现：

 public static void main(String[] args) throws IOException {
         //1.创建一个字节输入流对象,构造方法中绑定要读取的数据源
         FileInputStream fis = new FileInputStream("c:\\1.jpg");
         //2.创建一个字节输出流对象,构造方法中绑定要写入的目的地
         FileOutputStream fos = new FileOutputStream("d:\\1.jpg");
         //一次读取一个字节写入一个字节的方式
         //3.使用字节输入流对象中的方法read读取文件
         /*int len = 0;
         while((len = fis.read())!=-1){
             //4.使用字节输出流中的方法write,把读取到的字节写入到目的地的文件中
             fos.write(len);
         }*/

         //使用数组缓冲读取多个字节,写入多个字节
         byte[] bytes = new byte[1024];
         //3.使用字节输入流对象中的方法read读取文件
         int len = 0;//每次读取的有效字节个数
         while((len = fis.read(bytes))!=-1){
             //4.使用字节输出流中的方法write,把读取到的字节写入到目的地的文件中
             fos.write(bytes,0,len);
         }

         //5.释放资源(先关写的,后关闭读的;如果写完了,肯定读取完毕了)
         fos.close();
         fis.close();
     }

　　　注意：流的关闭原则，先开后关，后开先关。