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

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

一、输入字节流

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

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

1.1、IO流分类

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

1.2、输入流演示例子

步骤：

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

package com.dhb.file;

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

/**
 * @author DSHORE / 2018-7-2
 *
 */
public class Demo9 {
    public static void main(String[] args) throws IOException {
        readTest3();
    }
    
    //方式一：  缺陷：无法读取完整的一个文件的数据
    public static void readTest1() throws IOException{
        //找到目标文件
        File f=new File("F:\a.txt");
        //建立数据的输入通道
        FileInputStream fis=new FileInputStream(f);
        //读取文件中的数据
        int count=fis.read();//read()：读取一个字节的数据，并返回读取到的数据
        System.out.println("读取到的内容："+(char)count);
        fis.close();//关闭资源
    }
    
    //方式二：使用循环读取文件的数据
    public static void readTest2() throws IOException{
        long start=System.currentTimeMillis();//计时(开始点)，返回以毫秒为单位的当前时间
        //找到目标文件
        File file=new File("F:\a.txt");
        //建立数据输入通道
        FileInputStream fis=new FileInputStream(file);
        //读取文件中的数据
        int countent=0;//声明该变量用于存储读取到的数据
        while((countent = fis.read()) != -1){//-1表示：已经读到文件的末尾了，即：已读完所有数据
            System.out.print((char)countent);
        }
        fis.close();//关闭资源
        long end=System.currentTimeMillis();//计时(结束点)，返回以毫秒为单位的当前时间
        System.out.println();
        System.out.println(end-start);//864
    }
    
    //方式三: 使用缓冲数组读取。   缺点:无法完整读取一个文件         
    public static void readTest3() throws IOException{
        //找到目标文件
        File f=new File("F:\a.txt");  
        //建立数据的输入通道
        FileInputStream fis=new FileInputStream(f);
        //读取文件
        byte[] buf=new byte[1024];
        int length=fis.read(buf);
        System.out.println("length:"+length);
        //使用字符数组构建字符串
        String s=new String(buf,0,length);
        System.out.println("文件中的内容："+s);
        fis.close();//关闭资源
    }
    
    //方式四： 推荐使用（效率比方式二高）
    public static void readTest4() throws IOException{
        long start=System.currentTimeMillis();//计时(开始点)，返回以毫秒为单位的当前时间
        //找到目标文件
        File f = new File("F:\a.txt");
        //建立数据输入通道
        FileInputStream fis = new FileInputStream(f);
        //读取文件
        int length=0;
        byte[] buf=new byte[1024*3];//存储读取到的数据   缓冲数组是1024的倍数，因为与计算机处理单位是一样的。//理论上缓冲数组越大,效率越高
        while ((length = fis.read(buf)) != -1) {  //read()方法：如果读取到了文件的末尾,那么返回-1
            System.out.println(new String(buf,0,length));
        }
        //关闭资源
        fis.close();
        long end=System.currentTimeMillis(); //计时(结束点)，返回以毫秒为单位的当前时间
        System.out.println();
        System.out.println(end-start);//67秒
    }
}

1.3、实例

package com.dhb.file;

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

/**
 * @author DSHORE / 2018-7-2
 *
 */
//需求：读取一张图片所需的时间
public class Demo8 {
    public static void main(String[] args) throws IOException {
        oppo();
    }
    
    public static void  oppo() throws IOException{
        long start=System.currentTimeMillis();//开始(运行)时间；返回以毫秒为单位的当前时间
        File file = new File("F:\MyJavaCode\20180702.jpg");
        FileInputStream fir=new FileInputStream(file);//读取指定文件中的数据内容
        int length = 0;
        byte[] buf = new byte[1024];
        while((length=fir.read(buf)) != -1){//read()方法：如果读取到了文件的末尾，那么返回-1
            System.out.println(new String (buf,0,length));//从0开始读，到length的最大长度结束
        }
        fir.close();//关闭资源
        long end=System.currentTimeMillis();//结束(运行)时间；返回以毫秒为单位的当前时间
        System.out.println(end-start);//返回值：41毫秒
    }
}

运行结果图：

二、缓冲输入字节流

2.1、概述

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

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

2.2、使用BufferedInputStream的步骤

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

2.3、实例

package com.dhb.file;

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

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

原创作者：DSHORE

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

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

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