java增强IO流--字节缓冲流&字符缓冲流

淡淡的烟草味﹌ 2022-02-01 07:55 460阅读 0赞

缓冲流——————-高效读写数据

之前学习了基本的一些流，作为IO流的入门，今天我们要见识一些更强大的流。
比如：
能够高效读写的缓冲流
能够转换编码的转换流
能够持久化存储对象的序列化流等等
这些功能更为强大的流，都是在基本的流对象基础之上创建而来的，就像穿上铠甲的武士一样，相当于是对基本流对象的一种增强。

1.1 概述

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

  • 字节缓冲流：BufferedInputStream，BufferedOutputStream
  • 字符缓冲流：BufferedReader，BufferedWriter

缓冲流的基本原理，是在创建流对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统IO次数，从而提高读写的效率。

1.2 字节缓冲流

构造方法

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

构造举例，代码如下：

  1. // 创建字节缓冲输入流
  2. BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bis.txt"));
  3. // 创建字节缓冲输出流
  4. BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bos.txt"));

效率测试

查询API，缓冲流读写方法与基本的流是一致的，我们通过复制大文件E:\TestBufferOutStream\测试文档.docx（4178KB），测试它的效率。

  1. 基本流，代码如下：
  1. package com.baidu.demo1;
  3. import java.io.FileInputStream;
  4. import java.io.FileOutputStream;
  6. /**
  7.  * 使用基本流完成大文件的拷贝操作
  8.  */
  9. public class myDemo1 {
  11.     public static void main(String[] args) throws Exception {
  12.         long l = System.currentTimeMillis();
  13.         FileInputStream fis = new FileInputStream("E:\\TestBufferOutStream\\测试文档.docx");
  14.         FileOutputStream fos = new FileOutputStream("aaa.docx");
  16.       int i;
  17.      while((i=fis.read())!=-1){
  18.             fos.write(i);
  19.         }
  20.    fos.close();
  21.    fis.close();
  23.     long e = System.currentTimeMillis();//时间非常长 效率非常低    
  24.     System.out.println(e-l);
  25.     }
  26.     }

运行结果：60531ms

  1. 60531
  3. Process finished with exit code 0.
  1. 缓冲流，代码如下：
  1. package com.baidu.demo1;
  3. import java.io.BufferedInputStream;
  4. import java.io.BufferedOutputStream;
  5. import java.io.FileInputStream;
  6. import java.io.FileOutputStream;
  8. /**
  9.  * 使用字节缓存流完成大文件的拷贝操作
  10.  */
  11. public class myDemo2 {
  13.     public static void main(String[] args) throws Exception {
  15.     long l = System.currentTimeMillis();
  16.     FileInputStream fis = new FileInputStream("E:\\TestBufferOutStream\\测试文档.docx");
  17.     FileOutputStream fos = new FileOutputStream("bbb.docx");
  19.     //字节缓冲输入流
  20.     BufferedInputStream bis = new BufferedInputStream(fis);
  21.     //字节缓冲输出流
  22.     BufferedOutputStream bos = new BufferedOutputStream(fos);
  24.     int i;
  26.     while((i=bis.read())!=-1){
  27.         bos.write(i);
  28.     }
  30.     bos.close();
  31.     bis.close();
  33.     fos.close();
  34.     fis.close();
  36.     long e = System.currentTimeMillis();//2780
  38.     System.out.println(e-l);
  39. }
  40. }

如何更快呢？

使用数组的方式，代码如下：

  1. package com.baidu.demo1;
  3. import java.io.BufferedInputStream;
  4. import java.io.BufferedOutputStream;
  5. import java.io.FileInputStream;
  6. import java.io.FileOutputStream;
  8. /**
  9.  * 使用字节缓存流完成大文件的拷贝操作
  10.  * 使用缓冲数组
  11.  */
  12. public class myDemo3 {
  14.     public static void main(String[] args) throws Exception {
  16.     long l = System.currentTimeMillis();
  17.     FileInputStream fis = new FileInputStream("E:\\TestBufferOutStream\\测试文档.docx");
  18.     FileOutputStream fos = new FileOutputStream("ceshi.docx");
  20.     //字节缓冲输入流
  21.     BufferedInputStream bis = new BufferedInputStream(fis);
  22.     //字节缓冲输出流
  23.     BufferedOutputStream bos = new BufferedOutputStream(fos);
  25.     int i;
  27.     byte[] len=new byte[1024*1024];
  29.     while((i=bis.read(len))!=-1){
  30.         bos.write(len,0,i);
  31.     }
  33.     fos.close();
  34.     fis.close();
  36.     long e = System.currentTimeMillis();//154
  38.     System.out.println(e-l);
  40.     }
  41.     }

1.3 字符缓冲流

构造方法

  • public BufferedReader(Reader in) ：创建一个 新的缓冲输入流。
  • public BufferedWriter(Writer out)： 创建一个新的缓冲输出流。

构造举例，代码如下：

  1. // 创建字符缓冲输入流
  2. BufferedReader br = new BufferedReader(new FileReader("br.txt"));
  3. // 创建字符缓冲输出流
  4. BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));

特有方法

字符缓冲流的基本方法与普通字符流调用方式一致，不再阐述，我们来看它们具备的特有方法。

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

1 readLine方法演示，代码如下：

  1. public class BufferedReaderDemo {
  2.     public static void main(String[] args) throws IOException {
  3.            // 创建流对象
  4.         BufferedReader br = new BufferedReader(new FileReader("in.txt"));
  5.         // 定义字符串,保存读取的一行文字
  6.         String line  = null;
  7.           // 循环读取,读取到最后返回null
  8.         while ((line = br.readLine())!=null) {
  9.             System.out.print(line);
  10.             System.out.println("------");
  11.         }
  12.         // 释放资源
  13.         br.close();
  14.     }
  15. }

2 newLine方法演示，代码如下：

  1. public class BufferedWriterDemo throws IOException {
  2.     public static void main(String[] args) throws IOException  {
  3.           // 创建流对象
  4.         BufferedWriter bw = new BufferedWriter(new FileWriter("out.txt"));
  5.           // 写出数据
  6.         bw.write("鹅鹅鹅");
  7.           // 写出换行
  8.         bw.newLine();
  9.         bw.write("曲项向天歌");
  10.         bw.newLine();
  11.         bw.write("白毛浮绿水");
  12.         bw.newLine();
  13.         // 释放资源
  14.         bw.close();
  15.     }
  16. }

输出效果:

  1. 鹅鹅鹅
  2. 曲项向天歌
  3. 白毛浮绿水

发表评论

表情：
评论列表 （有 0 条评论，460人围观）

还没有评论，来说两句吧...

相关阅读

    相关 IO流——缓冲流

    在进行读取文件中数据的操作时，读取数据量大的文件时，读取的速度会很慢，Java中提供了一套缓冲流，可以提高IO流的读写速度。 缓冲流 根据流的分类分为字节缓冲流与字符缓冲流

    妖狐艹你老母妖狐艹你老母/ 0 赞/ 408 阅读