Java 之 字节输入流 [InputStream]

Posted 2022-10-08 niujifei

一、字节输入流

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

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

　　共性方法：

public void close() ：关闭此输入流并释放与此流相关联的任何系统资源。
public abstract int read() ： 从输入流读取数据的下一个字节。
public int read(byte[] b) ： 从输入流中读取一些字节数，并将它们存储到字节数组 b中 。

　　注意：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 ，代码使用演示：

 1  public static void main(String[] args) throws IOException 
 2         //1.创建FileInputStream对象,构造方法中绑定要读取的数据源
 3         FileInputStream fis = new FileInputStream("E:\\\\c.txt");
 4         //2.使用FileInputStream对象中的方法read,读取文件
 5         //int read()读取文件中的一个字节并返回,读取到文件的末尾返回-1
 6             /*
 7             发现以上读取文件是一个重复的过程,所以可以使用循环优化
 8             不知道文件中有多少字节,使用while循环
 9             while循环结束条件,读取到-1的时候结束
10 
11             布尔表达式(len = fis.read())!=-1
12                 1.fis.read():读取一个字节
13                 2.len = fis.read():把读取到的字节赋值给变量len
14                 3.(len = fis.read())!=-1:判断变量len是否不等于-1
15          */
16         int len = 0; //记录读取到的字节
17         while((len = fis.read())!=-1)
18             System.out.print(len);//abc
19         
20 
21         //3.释放资源
22         fis.close();
23     

 

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

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

　　　　明确两件事情：

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

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

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

　　　　　　　　每次读取的有效字节个数

　　　　　　Demo :

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

 

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

　　字节流读取文件的原理：

 

 

 

三、复制文件案例

　　复制文件原理图解：

 

 　　文件复制的步骤：

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

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

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

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

　　　　5. 释放资源

　　代码实现：

 1 public static void main(String[] args) throws IOException 
 2         //1.创建一个字节输入流对象,构造方法中绑定要读取的数据源
 3         FileInputStream fis = new FileInputStream("c:\\\\1.jpg");
 4         //2.创建一个字节输出流对象,构造方法中绑定要写入的目的地
 5         FileOutputStream fos = new FileOutputStream("d:\\\\1.jpg");
 6         //一次读取一个字节写入一个字节的方式
 7         //3.使用字节输入流对象中的方法read读取文件
 8         /*int len = 0;
 9         while((len = fis.read())!=-1)
10             //4.使用字节输出流中的方法write,把读取到的字节写入到目的地的文件中
11             fos.write(len);
12         */
13 
14         //使用数组缓冲读取多个字节,写入多个字节
15         byte[] bytes = new byte[1024];
16         //3.使用字节输入流对象中的方法read读取文件
17         int len = 0;//每次读取的有效字节个数
18         while((len = fis.read(bytes))!=-1)
19             //4.使用字节输出流中的方法write,把读取到的字节写入到目的地的文件中
20             fos.write(bytes,0,len);
21         
22 
23         //5.释放资源(先关写的,后关闭读的;如果写完了,肯定读取完毕了)
24         fos.close();
25         fis.close();
26     

 

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