java基础43 IO流技术（输入字节流/缓冲输入字节流）

通过File对象可以读取文件或者文件夹的属性数据，如果要读取文件的内容数据，那么我们就要使用IO技术。

一、输入字节流

输入字节流的体系：
-------| InputStream：所有输入字节流的基类（抽象类）
-----------| FileInputStream：向指定文件读取数据的输入字节流
-----------| BufferedInputStream：缓冲输入字节流 注意：凡是缓冲流都不具备读写文件的能力

注意：所有缓冲流都不具备读写文件的能力（比如BufferedInputStream，他要借助FileInputStream的读功能来读文件）

1.1、IO流分类

按照数据的流向划分：
         输入流：把硬盘(或内存)中的数据读到程序中。
         输出流：把程序中的数据写到硬盘(或内存)中。
按照处理的单位划分：
         字节流：字节流读取都是文件中的二进制数据，读取到的二进制数据不会经过任何的处理.
         字符流：字符流读取的数据是以字符为单位的；字符流也是读取的是二进制数据，不过会把这些二进制数据转换为我们认识的字符.（字符流=字节流+解码）

1.2、输入流演示例子

步骤：

    1、找到目标文件
    2、建立数据的输入通道
    3、读取文件中的数据（把硬盘中的数据读取到程序中）
    4、关闭资源（注意：如果不关闭资源，该资源会一直占用CPU，且当你要删除该文件时，将无法删除）

 1 package com.dhb.file;
 2 
 3 import java.io.File;
 4 import java.io.FileInputStream;
 5 import java.io.IOException;
 6 
 7 /**
 8  * @author DSHORE / 2018-7-2
 9  *
10  */
11 public class Demo9 {
12     public static void main(String[] args) throws IOException {
13         readTest3();
14     }
15     
16     //方式一：  缺陷：无法读取完整的一个文件的数据
17     public static void readTest1() throws IOException{
18         //找到目标文件
19         File f=new File("F:\a.txt");
20         //建立数据的输入通道
21         FileInputStream fis=new FileInputStream(f);
22         //读取文件中的数据
23         int count=fis.read();//read()：读取一个字节的数据，并返回读取到的数据
24         System.out.println("读取到的内容："+(char)count);
25         fis.close();//关闭资源
26     }
27     
28     //方式二：使用循环读取文件的数据
29     public static void readTest2() throws IOException{
30         long start=System.currentTimeMillis();//计时(开始点)，返回以毫秒为单位的当前时间
31         //找到目标文件
32         File file=new File("F:\a.txt");
33         //建立数据输入通道
34         FileInputStream fis=new FileInputStream(file);
35         //读取文件中的数据
36         int countent=0;//声明该变量用于存储读取到的数据
37         while((countent = fis.read()) != -1){//-1表示：已经读到文件的末尾了，即：已读完所有数据
38             System.out.print((char)countent);
39         }
40         fis.close();//关闭资源
41         long end=System.currentTimeMillis();//计时(结束点)，返回以毫秒为单位的当前时间
42         System.out.println();
43         System.out.println(end-start);//864
44     }
45     
46     //方式三: 使用缓冲数组读取。   缺点:无法完整读取一个文件         
47     public static void readTest3() throws IOException{
48         //找到目标文件
49         File f=new File("F:\a.txt");  
50         //建立数据的输入通道
51         FileInputStream fis=new FileInputStream(f);
52         //读取文件
53         byte[] buf=new byte[1024];
54         int length=fis.read(buf);
55         System.out.println("length:"+length);
56         //使用字符数组构建字符串
57         String s=new String(buf,0,length);
58         System.out.println("文件中的内容："+s);
59         fis.close();//关闭资源
60     }
61     
62     //方式四： 推荐使用（效率比方式二高）
63     public static void readTest4() throws IOException{
64         long start=System.currentTimeMillis();//计时(开始点)，返回以毫秒为单位的当前时间
65         //找到目标文件
66         File f = new File("F:\a.txt");
67         //建立数据输入通道
68         FileInputStream fis = new FileInputStream(f);
69         //读取文件
70         int length=0;
71         byte[] buf=new byte[1024*3];//存储读取到的数据   缓冲数组是1024的倍数，因为与计算机处理单位是一样的。//理论上缓冲数组越大,效率越高
72         while ((length = fis.read(buf)) != -1) {  //read()方法：如果读取到了文件的末尾,那么返回-1
73             System.out.println(new String(buf,0,length));
74         }
75         //关闭资源
76         fis.close();
77         long end=System.currentTimeMillis(); //计时(结束点)，返回以毫秒为单位的当前时间
78         System.out.println();
79         System.out.println(end-start);//67秒
80     }
81 }

1.3、实例

 1 package com.dhb.file;
 2 
 3 import java.io.File;
 4 import java.io.FileInputStream;
 5 import java.io.IOException;
 6 
 7 /**
 8  * @author DSHORE / 2018-7-2
 9  *
10  */
11 //需求：读取一张图片所需的时间
12 public class Demo8 {
13     public static void main(String[] args) throws IOException {
14         oppo();
15     }
16     
17     public static void  oppo() throws IOException{
18         long start=System.currentTimeMillis();//开始(运行)时间；返回以毫秒为单位的当前时间
19         File file = new File("F:\MyJavaCode\20180702.jpg");
20         FileInputStream fir=new FileInputStream(file);//读取指定文件中的数据内容
21         int length = 0;
22         byte[] buf = new byte[1024];
23         while((length=fir.read(buf)) != -1){//read()方法：如果读取到了文件的末尾，那么返回-1
24             System.out.println(new String (buf,0,length));//从0开始读，到length的最大长度结束
25         }
26         fir.close();//关闭资源
27         long end=System.currentTimeMillis();//结束(运行)时间；返回以毫秒为单位的当前时间
28         System.out.println(end-start);//返回值：41毫秒
29     }
30 }

运行结果图：

二、缓冲输入字节流

2.1、概述

我们清楚读取文件数据使用缓冲数组读取效率更高，sun公司给我们提供了一个缓冲输入字节流对象，让我们可以更高效率读取文件

注意：凡是缓冲流都不具备读写文件的能力，BufferedInputStream是借助FileInputStream的功能来进行读写操作的

2.2、使用BufferedInputStream的步骤

    1.找到目标文件
    2.建立数据的输入通道
    3.建立缓冲输入字节流
    4.读取数据（把硬盘中的数据读取到程序中）
    5.关闭资源

2.3、实例

 1 package com.dhb.file;
 2 
 3 import java.io.BufferedInputStream;
 4 import java.io.File;
 5 import java.io.FileInputStream;
 6 import java.io.IOException;
 7 
 8 /**
 9  * @author DSHORE / 2018-7-4
10  *
11  */
12 public class Demo1 {
13     public static void main(String[] args) throws IOException {
14         readTest();
15     }
16     public static void readTest() throws IOException{
17         //找到目标文件
18         File file=new File("F:\a.txt");
19         FileInputStream fis=new FileInputStream(file);
20         BufferedInputStream bis=new BufferedInputStream(fis);
21         int length=0;
22         //疑问:BufferInputStream出现的目的：提供读取文件的效率,但是BufferedInputStream和FileInputStream的read()方法每次读取一个字节的数据,那么BufferInputStream效率高从何而来?
23         //答：因为BufferInputStream内部维护了一个8kb的字节数组而已。（其实用 FileInputStream 的方式4和 BufferInputStream 的效率一样高，都差不多，自己喜欢哪种就用哪种）
24         while((length=bis.read())!=-1){
25             System.out.print((char)length);
26         }
27         bis.close();//间接把fis关闭了
28         //fis.close();
29     }
30 }

原创作者：DSHORE

作者主页：http://www.cnblogs.com/dshore123/

原文出自：https://www.cnblogs.com/dshore123/p/9253440.html

欢迎转载，转载务必说明出处。（如果本文对您有帮助，可以点击一下右下角的推荐，或评论，谢谢！）