缓冲流详细解释

缓冲流:

概述:缓冲流,也叫高效流,是对4个基本的FileXxx流的增强,所以也是4个流,按照数据类型分类:

 字节流顶层父类:InputStream(字节输入流) 和 OutputStream(字节输出流)

 字符流顶层父类:Reader(字符输入流)  和  Writer(字符输出流)

• 字节缓冲流：BufferedInputStream，BufferedOutputStream

• 字符缓冲流：BufferedReader，BufferedWriter

• 缓冲流的基本原理,是创建流对象时候,会创建一个内置的默认大小的缓冲区数组,通过缓冲区书写.

构造方法:

- public BufferedInputStream(InputStream in) ：创建一个 新的缓冲输入流。 
- public BufferedOutputStream(OutputStream out)： 创建一个新的缓冲输出流。

 构造举例,代码如下图片加载.

package com.heima.zifu;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;

//打印图片
public class Demo01 {
    public static void main(String[] args) throws Exception{
        //创建缓冲字节输入流对象指定数据源
        BufferedInputStream shuru=new BufferedInputStream(new FileInputStream("C:\Users\ASUS\Desktop\截图\123.jpg"));
        //创建缓冲字节输出流对象指定数据源
        BufferedOutputStream shucu=new BufferedOutputStream(new FileOutputStream("123.jpg"));
        //读写数据
        //定义长度
        byte [] bytes=new byte[1024];
        //定义长度
        int len;
        while ((len=shuru.read(bytes))!=-1){
            //导出数据
            shucu.write(bytes,0,len);
        }
        //关闭资源
        shucu.close();
        shuru.close();

    }
}

 普通方法测试:

 基本代码如下:

package com.heima.zifu;
import java.io.FileInputStream;
import java.io.FileOutputStream;
//效率测试
public class Demo02 {
    public static void main(String[] args) {
        //记录查询时间
        long shijian = System.currentTimeMillis();
        try {
            //创建输入流对象
            FileInputStream fileInputStream = new FileInputStream("C:\Users\ASUS\Desktop\截图\222.jpg");
            //创建输出流对象
            FileOutputStream fileOutputStream = new FileOutputStream("1215.jpg");
            {
                //读写数据
                int b;
                while ((b=fileInputStream.read())!=-1){//try异常
                         fileOutputStream.write(b);
                }
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
        //记录异常
       long end= System.currentTimeMillis();
        System.out.println("普通流复制时间:"+(end-shijian)+"毫秒");
    }
}
//输出结果:普通流复制时间:1701毫秒

 高效率测试:

 基本代码如下:

package com.heima.zifu;

import java.io.*;

//高效流输出时间
public class Demo03 {
    public static void main(String[] args) {
        //记录开始时间
        long kaishi = System.currentTimeMillis();
        try {
            //创建高效流字节输入
            BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("C:\Users\ASUS\Desktop\截图\222.jpg"));
            //创建高效流字节输出
            BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("22222.jpg"));
            {
                //读写数据
                int a;//定义变量
                while ((a=bufferedInputStream.read())!=-1){
                    bufferedOutputStream.write(a);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        //记录结束时间
        long jieshu=System.currentTimeMillis();
        //输出
        System.out.println("高效流花费时间:"+(jieshu-kaishi)+"毫秒");

    }
}
//输出结果:高效流花费时间:37毫秒

 

 总结:

• InputStreamReader和OutputStreamWriter
  在构造这两个类对应的流时，它们会自动进行转换，将平台缺省的编码集编码的字节转换为Unicode字符。对英语环境，其缺省的编码集一般为ISO8859-1。
• BufferedReader和BufferedWriter
  这两个类对应的流使用了缓冲，能大大提高输入输出的效率。这两个也是过滤器流，常用来对InputStreamReader和OutputStreamWriter进行处理。

 注意:普通字节流在传字节数组的时候比高效字节流快.

 字符缓冲流特有的方法:

- BufferedReader：public String readLine(): 读一行文字。 
- BufferedWriter：public void newLine(): 写一行行分隔符,由系统属性定义符号。

 readLine()方法读取一行代码:

 代码演示:

package com.heima.zifu;
import java.io.BufferedReader;
import java.io.FileReader;
//readLine方法
public class Demo04 {
    public static void main(String[] args) throws Exception{
        //创建高效字符输入流对象
        BufferedReader bufferedReader = new BufferedReader(new FileReader("c.txt"));
        //定义字符串
        String line=null;
        //循环读取
        while ((line=bufferedReader.readLine())!=null){
            for(int i=0;i<line.length();i++){
                System.out.println(line+" "+i);
                System.out.println("-----------");
            }
        }
        //释放资源
        bufferedReader.close();
    }
}

 对BufferedReader类，该类的readLine()方法能一次从流中读入一行，但对于BufferedWriter类，就没有一次写一行的方法，所以若要向流中一次写一行，

 可用PrintWriter类将原来的流改造成新的打印流，PrintWriter类有一个方法println()，能一次输出一行。

 如:PrintWriter类中的println方法.

PrintWriter out = new PrintWriter(new BufferedWriter(
      new FileWriter("D:javacode	est.txt")));
out.println("Hello World!");
out.close();

newLine方法演示写一行分割符:

代码演示:

package com.heima.zifu;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class Demo05 {
    public static void main(String[] args) throws Exception {
        //创建高效字符输出流对象
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("a.txt"));
        //写出数据
        bufferedWriter.write("世人笑我太疯癫，");
        //写出换行
        //BufferedWriter：public void newLine():
        // 写一行行分隔符,由系统属性定义符号。
        bufferedWriter.newLine();
        bufferedWriter.write("我笑世人看不穿。");
        //释放资源
        bufferedWriter.close();
    }
}
//输入结果
/*
世人笑我太疯癫，
我笑世人看不穿。
 */

练习:给文本排序
分析:

1. 逐行读取文本信息。

2. 解析文本信息到集合中。

3. 遍历集合，按顺序，写出文本信息。

package com.heima.zifu;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.util.HashMap;

//练习文本排序
public class Demo06 {
    public static void main(String[] args) throws Exception {
        /*
        案例分析
       1. 逐行读取文本信息。
       2. 解析文本信息到集合中。
       3. 遍历集合，按顺序，写出文本信息。
         */
        //创建双列集合，保存文本数据
        HashMap<String, String> objectObjectHashMap = new HashMap<>();
        //创建高效字符输入流对象
        BufferedReader bufferedReader = new BufferedReader(new FileReader("C:\Users\ASUS\Desktop\截图\a.txt"));
        //创建高效字符输出流对象
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("aaaaa.txt"));
        //读取数据
        //定义变量
        String a = null;
        while ((a = bufferedReader.readLine()) != null) {
            //解析文本
            String[] split = a.split("\.");
            //保存到集合中
            // String str = new String(split[1].getBytes(), "utf-8");文本
            objectObjectHashMap.put(split[0], split[1]);
        }
        //释放资源
        bufferedReader.close();
        //遍历集合
        for (int i = 1; i <= objectObjectHashMap.size(); i++) {
            String key = String.valueOf(i);
            //获取文本中的内容
            String value = objectObjectHashMap.get(key);
            //写出拼接文本
            bufferedWriter.write(key + "." + value);
            //写出换行
            bufferedWriter.newLine();
        }
        //释放资源
        bufferedWriter.close();
    }
}

 练习:记录自己电脑目录下书写了多少行代码.

 1 package com.heima.tongji;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
//文件搜索
public class Demo01 {
    //定义常量记录代码个数
    static  int count=0;
    public static void main(String[] args)  {
        //创建File对象
        File dir = new File("D:\LULIANGHM");
        //调用打印目录方法
        try {
            System.out.println(printDir(dir));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //打印目录方法
    public static int printDir(File dir) throws IOException {
        //获取子文件和目录
        File[] files = dir.listFiles();
        //循环打印
        for (File file1 : files) {
            //判断是否是文件
            if (file1.isFile()) {
                //判断是文件，判断文件名并输出文件绝对路径
                if (file1.getName().endsWith(".java")) {
                    //定义高效字符输入流封装源文件。
                    BufferedReader bufferedReader = new BufferedReader(new FileReader(file1));
                    //定义变量用来存储读取的数据
                    String   line=null;
                    while ((line=bufferedReader.readLine())!=null){
                        //进行输出
                        // System.out.println(line);//输出目录下java文件
                        count++;
                    }
                }
                //判断当前查找到的文件是类型为目录的文件；
                 if(file1.isDirectory()){
                    printDir(file1);
                 }
                }else {
                // 是目录，继续遍历,形成递归
                printDir(file1);

            }
        }
        return count;
    }
}