缓冲流详细解释

 

缓冲流:

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

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

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

• 字节缓冲流：BufferedInputStream，BufferedOutputStream

• 字符缓冲流：BufferedReader，BufferedWriter

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

构造方法:

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

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

package com.heima.zifu;  2 
import java.io.BufferedInputStream;  4 import java.io.BufferedOutputStream;  5 import java.io.FileInputStream;  6 import java.io.FileOutputStream;  7 
//打印图片
public class Demo01 { 10     public static void main(String[] args) throws Exception{ 11         //创建缓冲字节输入流对象指定数据源
        BufferedInputStream shuru=new BufferedInputStream(new FileInputStream("C:\\Users\\ASUS\\Desktop\\截图\\123.jpg")); 13         //创建缓冲字节输出流对象指定数据源
        BufferedOutputStream shucu=new BufferedOutputStream(new FileOutputStream("123.jpg")); 15         //读写数据 16         //定义长度
        byte [] bytes=new byte[1024]; 18         //定义长度
        int len; 20         while ((len=shuru.read(bytes))!=-1){ 21             //导出数据
            shucu.write(bytes,0,len); 23  } 24         //关闭资源
 shucu.close(); 26  shuru.close(); 27 
 } 29 }

 普通方法测试:

 基本代码如下:

 

package com.heima.zifu;  2 import java.io.FileInputStream;  3 import java.io.FileOutputStream;  4 //效率测试
public class Demo02 {  6     public static void main(String[] args) {  7         //记录查询时间
        long shijian = System.currentTimeMillis();  9         try { 10             //创建输入流对象
            FileInputStream fileInputStream = new FileInputStream("C:\\Users\\ASUS\\Desktop\\截图\\222.jpg"); 12             //创建输出流对象
            FileOutputStream fileOutputStream = new FileOutputStream("1215.jpg"); 14  { 15                 //读写数据
                int b; 17                 while ((b=fileInputStream.read())!=-1){//try异常
 fileOutputStream.write(b); 19  } 20  } 21 
        } catch (Exception e) { 23  e.printStackTrace(); 24  } 25         //记录异常
       long end= System.currentTimeMillis(); 27         System.out.println("普通流复制时间:"+(end-shijian)+"毫秒"); 28  } 29 } 30 //输出结果:普通流复制时间:1701毫秒

 

 高效率测试:

 基本代码如下:

 

package com.heima.zifu;  2 
import java.io.*;  4 
//高效流输出时间
public class Demo03 {  7     public static void main(String[] args) {  8         //记录开始时间
        long kaishi = System.currentTimeMillis(); 10         try { 11             //创建高效流字节输入
            BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("C:\\Users\\ASUS\\Desktop\\截图\\222.jpg")); 13             //创建高效流字节输出
            BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(new FileOutputStream("22222.jpg")); 15  { 16                 //读写数据
                int a;//定义变量
                while ((a=bufferedInputStream.read())!=-1){ 19  bufferedOutputStream.write(a); 20  } 21  } 22         } catch (Exception e) { 23  e.printStackTrace(); 24  } 25         //记录结束时间
        long jieshu=System.currentTimeMillis(); 27         //输出
        System.out.println("高效流花费时间:"+(jieshu-kaishi)+"毫秒"); 29 
 } 31 } 32 //输出结果:高效流花费时间:37毫秒

 

 

 总结:

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

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

 字符缓冲流特有的方法:

 

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

 

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

 代码演示:

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

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

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

 如:PrintWriter类中的println方法.

 

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

 

 

 

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

代码演示:

 

package com.heima.zifu;  2 
import java.io.BufferedWriter;  4 import java.io.FileWriter;  5 import java.io.IOException;  6 
public class Demo05 {  8     public static void main(String[] args) throws Exception {  9         //创建高效字符输出流对象
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("a.txt")); 11         //写出数据
        bufferedWriter.write("世人笑我太疯癫，"); 13         //写出换行 14         //BufferedWriter：public void newLine(): 15         // 写一行行分隔符,由系统属性定义符号。
 bufferedWriter.newLine(); 17         bufferedWriter.write("我笑世人看不穿。"); 18         //释放资源
 bufferedWriter.close(); 20  } 21 } 22 //输入结果
/*
世人笑我太疯癫， 25 我笑世人看不穿。 26  */

 

 

 

练习:给文本排序
分析:

1. 逐行读取文本信息。

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

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

package com.heima.zifu;  2 
import java.io.BufferedReader;  4 import java.io.BufferedWriter;  5 import java.io.FileReader;  6 import java.io.FileWriter;  7 import java.util.HashMap;  8 
//练习文本排序
public class Demo06 { 11     public static void main(String[] args) throws Exception { 12         /*
 案例分析 14  1. 逐行读取文本信息。 15  2. 解析文本信息到集合中。 16  3. 遍历集合，按顺序，写出文本信息。 17          */
        //创建双列集合，保存文本数据
        HashMap<String, String> objectObjectHashMap = new HashMap<>(); 20         //创建高效字符输入流对象
        BufferedReader bufferedReader = new BufferedReader(new FileReader("C:\\Users\\ASUS\\Desktop\\截图\\a.txt")); 22         //创建高效字符输出流对象
        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("aaaaa.txt")); 24         //读取数据 25         //定义变量
        String a = null; 27         while ((a = bufferedReader.readLine()) != null) { 28             //解析文本
            String[] split = a.split("\\."); 30             //保存到集合中 31             // String str = new String(split[1].getBytes(), "utf-8");文本
            objectObjectHashMap.put(split[0], split[1]); 33  } 34         //释放资源
 bufferedReader.close(); 36         //遍历集合
        for (int i = 1; i <= objectObjectHashMap.size(); i++) { 38             String key = String.valueOf(i); 39             //获取文本中的内容
            String value = objectObjectHashMap.get(key); 41             //写出拼接文本
            bufferedWriter.write(key + "." + value); 43             //写出换行
 bufferedWriter.newLine(); 45  } 46         //释放资源
 bufferedWriter.close(); 48  } 49 }

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

 1 package com.heima.tongji;  2 import java.io.BufferedReader;  3 import java.io.File;  4 import java.io.FileReader;  5 import java.io.IOException;  6 //文件搜索
public class Demo01 {  8     //定义常量记录代码个数
    static  int count=0; 10     public static void main(String[] args) { 11         //创建File对象
        File dir = new File("D:\\LULIANGHM"); 13         //调用打印目录方法
        try { 15  System.out.println(printDir(dir)); 16         } catch (Exception e) { 17  e.printStackTrace(); 18  } 19  } 20 
    //打印目录方法
    public static int printDir(File dir) throws IOException { 23         //获取子文件和目录
        File[] files = dir.listFiles(); 25         //循环打印
        for (File file1 : files) { 27             //判断是否是文件
            if (file1.isFile()) { 29                 //判断是文件，判断文件名并输出文件绝对路径
                if (file1.getName().endsWith(".java")) { 31                     //定义高效字符输入流封装源文件。
                    BufferedReader bufferedReader = new BufferedReader(new FileReader(file1)); 33                     //定义变量用来存储读取的数据
                    String   line=null; 35                     while ((line=bufferedReader.readLine())!=null){ 36                         //进行输出
 // System.out.println(line);//输出目录下java文件 38                         count++; 39  } 40  } 41                 //判断当前查找到的文件是类型为目录的文件；
                 if(file1.isDirectory()){ 43  printDir(file1); 44  } 45                 }else { 46                 // 是目录，继续遍历,形成递归
 printDir(file1); 48 
 } 50  } 51         return count; 52  } 53 }