devbox
知新_RL
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java IO流学习总结三：缓冲流-BufferedInputStream、BufferedOutputStream

作者：知新_RL | 2024-02-26 20:40:47

赞

踩

bufferedinputstream是增加了缓冲的输入流,用来连接别的的输入流,其默认的缓

Java IO流学习总结三：缓冲流-BufferedInputStream、BufferedOutputStream

转载请标明出处：http://blog.csdn.net/zhaoyanjun6/article/details/54894451
本文出自【赵彦军的博客】

  1. InputStream
  2. |__FilterInputStream
  3.         |__BufferedInputStream
  • 1
  • 2
  • 3

首先抛出一个问题，有了InputStream为什么还要有BufferedInputStream?

BufferedInputStream和BufferedOutputStream这两个类分别是FilterInputStream和FilterOutputStream的子类，作为装饰器子类，使用它们可以防止每次读取/发送数据时进行实际的写操作，代表着使用缓冲区。

我们有必要知道不带缓冲的操作，每读一个字节就要写入一个字节，由于涉及磁盘的IO操作相比内存的操作要慢很多，所以不带缓冲的流效率很低。带缓冲的流，可以一次读很多字节，但不向磁盘中写入，只是先放到内存里。等凑够了缓冲区大小的时候一次性写入磁盘，这种方式可以减少磁盘操作次数，速度就会提高很多！

同时正因为它们实现了缓冲功能，所以要注意在使用BufferedOutputStream写完数据后，要调用flush()方法或close()方法，强行将缓冲区中的数据写出。否则可能无法写出数据。与之相似还BufferedReader和BufferedWriter两个类。

现在就可以回答在本文的开头提出的问题：

BufferedInputStream和BufferedOutputStream类就是实现了缓冲功能的输入流/输出流。使用带缓冲的输入输出流，效率更高，速度更快。

总结：

  • BufferedInputStream 是缓冲输入流。它继承于FilterInputStream。

  • BufferedInputStream 的作用是为另一个输入流添加一些功能，例如，提供“缓冲功能”以及支持mark()标记和reset()重置方法。

  • BufferedInputStream 本质上是通过一个内部缓冲区数组实现的。例如，在新建某输入流对应的BufferedInputStream后，当我们通过read()读取输入流的数据时，BufferedInputStream会将该输入流的数据分批的填入到缓冲区中。每当缓冲区中的数据被读完之后，输入流会再次填充数据缓冲区；如此反复，直到我们读完输入流数据位置。

BufferedInputStream API简介

源码关键字段分析

  1.  
  2. private static int defaultBufferSize = 8192;//内置缓存字节数组的大小 8KB
  3.  
  4. protected volatile byte buf[];  //内置缓存字节数组
  5.  
  6. protected int count;    //当前buf中的字节总数、注意不是底层字节输入流的源中字节总数
  7.  
  8. protected int pos;      //当前buf中下一个被读取的字节下标
  9.  
  10. protected int markpos = -1; //最后一次调用mark(int readLimit)方法记录的buf中下一个被读取的字节的位置
  11.  
  12. protected int marklimit;    //调用mark后、在后续调用reset()方法失败之前云寻的从in中读取的最大数据量、用于限制被标记后buffer的最大值
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

构造函数

  1. BufferedInputStream(InputStream in) //使用默认buf大小、底层字节输入流构建bis 
  2.  
  3. BufferedInputStream(InputStream in, int size) //使用指定buf大小、底层字节输入流构建bis  
  • 1
  • 2
  • 3

一般方法介绍

  1. int available();  //返回底层流对应的源中有效可供读取的字节数      
  2.  
  3. void close();  //关闭此流、释放与此流有关的所有资源  
  4.  
  5. boolean markSupport();  //查看此流是否支持mark
  6.  
  7. void mark(int readLimit); //标记当前buf中读取下一个字节的下标  
  8.  
  9. int read();  //读取buf中下一个字节  
  10.  
  11. int read(byte[] b, int off, int len);  //读取buf中下一个字节  
  12.  
  13. void reset();   //重置最后一次调用mark标记的buf中的位子  
  14.  
  15. long skip(long n);  //跳过n个字节、 不仅仅是buf中的有效字节、也包括in的源中的字节 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

BufferedOutputStream API简介

关键字段

  1. protected byte[] buf;   //内置缓存字节数组、用于存放程序要写入out的字节  
  2.  
  3. protected int count;   //内置缓存字节数组中现有字节总数 
  • 1
  • 2
  • 3
  • 4

构造函数

  1. BufferedOutputStream(OutputStream out); //使用默认大小、底层字节输出流构造bos。默认缓冲大小是 8192 字节( 8KB )
  2.  
  3. BufferedOutputStream(OutputStream out, int size);  //使用指定大小、底层字节输出流构造bos  
  • 1
  • 2
  • 3

构造函数源码：

  1. /**
  2.   * Creates a new buffered output stream to write data to the
  3.   * specified underlying output stream.
  4.   * @param   out   the underlying output stream.
  5.   */
  6.  public BufferedOutputStream(OutputStream out) {
  7.      this(out, 8192);
  8.  }
  9.  
  10.  /**
  11.   * Creates a new buffered output stream to write data to the
  12.   * specified underlying output stream with the specified buffer
  13.   * size.
  14.   *
  15.   * @param   out    the underlying output stream.
  16.   * @param   size   the buffer size.
  17.   * @exception IllegalArgumentException if size <= 0.
  18.   */
  19.  public BufferedOutputStream(OutputStream out, int size) {
  20.      super(out);
  21.      if (size <= 0) {
  22.          throw new IllegalArgumentException("Buffer size <= 0");
  23.      }
  24.      buf = new byte[size];
  25.  }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

一般方法

  1. //在这里提一句,`BufferedOutputStream`没有自己的`close`方法,当他调用父类`FilterOutputStrem`的方法关闭时,会间接调用自己实现的`flush`方法将buf中残存的字节flush到out中,再`out.flush()`到目的地中,DataOutputStream也是如此。 
  2.  
  3. void  flush();  将写入bos中的数据flush到out指定的目的地中、注意这里不是flush到out中、因为其内部又调用了out.flush()  
  4.  
  5. write(byte b);      将一个字节写入到buf中  
  6.  
  7. write(byte[] b, int off, int len);      将b的一部分写入buf中 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

那么什么时候flush()才有效呢？
答案是：当OutputStream是BufferedOutputStream时。

当写文件需要flush()的效果时，需要
FileOutputStream fos = new FileOutputStream(“c:\a.txt”);
BufferedOutputStream bos = new BufferedOutputStream(fos);
也就是说，需要将FileOutputStream作为BufferedOutputStream构造函数的参数传入，然后对BufferedOutputStream进行写入操作，才能利用缓冲及flush()。

查看BufferedOutputStream的源代码，发现所谓的buffer其实就是一个byte[]。
BufferedOutputStream的每一次write其实是将内容写入byte[]，当buffer容量到达上限时，会触发真正的磁盘写入。
而另一种触发磁盘写入的办法就是调用flush()了。

1.BufferedOutputStream在close()时会自动flush
2.BufferedOutputStream在不调用close()的情况下，缓冲区不满，又需要把缓冲区的内容写入到文件或通过网络发送到别的机器时，才需要调用flush.

实战演练1：复制文件.
操作：使用缓存流将F盘根目录里面名字为：123.png 图片复制成 abc.png

  1. package com.app;
  2. import java.io.BufferedInputStream;
  3. import java.io.BufferedOutputStream;
  4. import java.io.File;
  5. import java.io.FileInputStream;
  6. import java.io.FileNotFoundException;
  7. import java.io.FileOutputStream;
  8. import java.io.IOException;
  9. import java.io.InputStream;
  10. import java.io.OutputStream;
  11.  
  12.  
  13. public class A3 {
  14.  
  15.     public static void main(String[] args) throws IOException {
  16.  
  17.         String filePath = "F:/123.png" ;
  18.         String filePath2 = "F:/abc.png" ;
  19.         File file = new File( filePath ) ;
  20.         File file2 = new File( filePath2 ) ;
  21.         copyFile( file , file2 );
  22.  
  23.     }
  24.  
  25.     /**
  26.      * 复制文件
  27.      * @param oldFile
  28.      * @param newFile
  29.      */
  30.     public static void copyFile( File oldFile , File newFile){
  31.         InputStream inputStream = null ;
  32.         BufferedInputStream bufferedInputStream = null ;
  33.  
  34.         OutputStream outputStream = null ;
  35.         BufferedOutputStream bufferedOutputStream = null ;
  36.  
  37.         try {
  38.             inputStream = new FileInputStream( oldFile ) ;
  39.             bufferedInputStream = new BufferedInputStream( inputStream ) ;
  40.  
  41.             outputStream = new FileOutputStream( newFile ) ;
  42.             bufferedOutputStream = new BufferedOutputStream( outputStream ) ;
  43.  
  44.             byte[] b=new byte[1024];   //代表一次最多读取1KB的内容
  45.  
  46.             int length = 0 ; //代表实际读取的字节数
  47.             while( (length = bufferedInputStream.read( b ) )!= -1 ){
  48.                 //length 代表实际读取的字节数
  49.                 bufferedOutputStream.write(b, 0, length );
  50.             }
  51.             //缓冲区的内容写入到文件
  52.             bufferedOutputStream.flush();
  53.         } catch (FileNotFoundException e) {
  54.             e.printStackTrace();
  55.         }catch (IOException e) {
  56.             e.printStackTrace();
  57.         }finally {
  58.  
  59.             if( bufferedOutputStream != null ){
  60.                 try {
  61.                     bufferedOutputStream.close();
  62.                 } catch (IOException e) {
  63.                     e.printStackTrace();
  64.                 }
  65.             }
  66.  
  67.             if( bufferedInputStream != null){
  68.                 try {
  69.                     bufferedInputStream.close();
  70.                 } catch (IOException e) {
  71.                     e.printStackTrace();
  72.                 }
  73.             }
  74.  
  75.             if( inputStream != null ){
  76.                 try {
  77.                     inputStream.close();
  78.                 } catch (IOException e) {
  79.                     e.printStackTrace();
  80.                 }
  81.             }
  82.  
  83.             if ( outputStream != null ) {
  84.                 try {
  85.                     outputStream.close();
  86.                 } catch (IOException e) {
  87.                     e.printStackTrace();
  88.                 }
  89.             }
  90.  
  91.         }
  92.     }
  93. }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94

效果图：

这里写图片描述

如何正确的关闭流

在上面的代码中，我们关闭流的代码是这样写的。

  1. finally {
  2.  
  3.             if( bufferedOutputStream != null ){
  4.                 try {
  5.                     bufferedOutputStream.close();
  6.                 } catch (IOException e) {
  7.                     e.printStackTrace();
  8.                 }
  9.             }
  10.  
  11.             if( bufferedInputStream != null){
  12.                 try {
  13.                     bufferedInputStream.close();
  14.                 } catch (IOException e) {
  15.                     e.printStackTrace();
  16.                 }
  17.             }
  18.  
  19.             if( inputStream != null ){
  20.                 try {
  21.                     inputStream.close();
  22.                 } catch (IOException e) {
  23.                     e.printStackTrace();
  24.                 }
  25.             }
  26.  
  27.             if ( outputStream != null ) {
  28.                 try {
  29.                     outputStream.close();
  30.                 } catch (IOException e) {
  31.                     e.printStackTrace();
  32.                 }
  33.             }
  34.  
  35.         }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35

思考：在处理流关闭完成后，我们还需要关闭节点流吗？

让我们带着问题去看源码：
- bufferedOutputStream.close();

  1.    /**
  2.      * Closes this input stream and releases any system resources
  3.      * associated with the stream.
  4.      * Once the stream has been closed, further read(), available(), reset(),
  5.      * or skip() invocations will throw an IOException.
  6.      * Closing a previously closed stream has no effect.
  7.      *
  8.      * @exception  IOException  if an I/O error occurs.
  9.      */
  10.     public void close() throws IOException {
  11.         byte[] buffer;
  12.         while ( (buffer = buf) != null) {
  13.             if (bufUpdater.compareAndSet(this, buffer, null)) {
  14.                 InputStream input = in;
  15.                 in = null;
  16.                 if (input != null)
  17.                     input.close();
  18.                 return;
  19.             }
  20.             // Else retry in case a new buf was CASed in fill()
  21.         }
  22.     }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

close（）方法的作用
1、关闭输入流，并且释放系统资源
2、BufferedInputStream装饰一个 InputStream 使之具有缓冲功能，is要关闭只需要调用最终被装饰出的对象的 close()方法即可，因为它最终会调用真正数据源对象的 close()方法。因此，可以只调用外层流的close方法关闭其装饰的内层流。

那么如果我们想逐个关闭流，我们该怎么做？

答案是：先关闭外层流，再关闭内层流。一般情况下是：先打开的后关闭，后打开的先关闭；另一种情况：看依赖关系，如果流a依赖流b，应该先关闭流a，再关闭流b。例如处理流a依赖节点流b，应该先关闭处理流a，再关闭节点流b

看懂了怎么正确的关闭流之后，那么我们就可以优化上面的代码了，只关闭外层的处理流。

  1. finally {
  2.  
  3.             if( bufferedOutputStream != null ){
  4.                 try {
  5.                     bufferedOutputStream.close();
  6.                 } catch (IOException e) {
  7.                     e.printStackTrace();
  8.                 }
  9.             }
  10.  
  11.             if( bufferedInputStream != null){
  12.                 try {
  13.                     bufferedInputStream.close();
  14.                 } catch (IOException e) {
  15.                     e.printStackTrace();
  16.                 }
  17.             }
  18.         }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

个人微信号：zhaoyanjun125 ， 欢迎关注

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/知新_RL/article/detail/146893
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号