Java 缓冲流简介及简单用法

最新推荐文章于 2024-08-05 13:31:35 发布
最新推荐文章于 2024-08-05 13:31:35 发布
阅读量7.8k 收藏 29
点赞数 10
分类专栏： Java 文章标签： Java stream buffer
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nvd11/article/details/36222719
版权

在java编程中, 我们有时会听到缓冲流和原始流等字眼.


其实在之前的博文中, 提到过流可以分为原始流和处理流.

http://blog.csdn.net/nvd11/article/details/30126233

也就是说处理流是包裹在原始流对原始流的数据进行进一步的处理, 这时的流就有两层了.


而缓冲流就是处理流的一种.


一, 缓冲流的定义

缓冲流是处理流的一种, 它依赖于原始的输入输出流, 它令输入输出流具有1个缓冲区, 显著减少与外部设备的IO次数, 而且提供一些额外的方法.


可见, 缓冲流最大的特点就是具有1个缓冲区! 而我们使用缓冲流无非两个目的:

1. 减少IO次数(提升performance)

2. 使用一些缓冲流的额外的方法.



二, 不使用缓冲流的例子

下面例子, 将1个大小为32MB的音乐文件复制到另1个地方. (/home/gateman/Music/Nickelback - Rockstar.flac 复制到 /home/gateman/tmp/Rockstar.flac

而且只是用原始的 FileInputStream 和 FileOutputStream, 1个1个字节的读取写入.

package Stream_kng.BufferStream_kng;

import java.io.*;

public class Stream2{

    public static void f(){
        FileInputStream fi = null;
        try{
            fi = new FileInputStream("/home/gateman/Music/Nickelback - Rockstar.flac");
        }catch(FileNotFoundException e){
            System.out.println("File not found!");
        }

        FileOutputStream fo = null;
        try{
            fo = new FileOutputStream("/home/gateman/tmp/Rockstar.flac");
        }catch(Exception e){
            System.out.println("error in file output stream's creation");
            e.printStackTrace();
        }

        int byt;
        try{
            byt = fi.read();
            while(-1 != byt){
                fo.write(byt);
                byt = fi.read();
            }
        }catch(IOException e){
            e.printStackTrace();
        }

        try{
            fo.flush();
        }catch(IOException e){
            System.out.println("Exception in flush()");
        }finally{
            if (null != fo){
                try{
                    fo.close();
                }catch(IOException e){
                    System.out.println("Exception in fo.close()");
                }
            }
           
            if (null != fi){
                try{
                    fi.close();
                }catch(IOException e){
                    System.out.println("Exception in fi.close()");
                }
            }
        }

        System.out.println("copy done!");
    }
}



我们看看编译后的执行效果:

gateman@TPEOS classes $ ls /home/gateman/tmp/Rockstar.flac
ls: cannot access /home/gateman/tmp/Rockstar.flac: No such file or directory
gateman@TPEOS classes $ time java Enter_1 
copy done!

real	0m57.385s
user	0m9.640s
sys	0m47.528s
gateman@TPEOS classes $ ls -lh /home/gateman/tmp/Rockstar.flac
-rw-rw-r-- 1 gateman gateman 32M Jul  1 22:43 /home/gateman/tmp/Rockstar.flac

可见复制区区1个32m的文件都用了将近1分钟,  不可以接受啊.


原因就是输入流fi 和 输出流都是1个1个字节的读写, 也就是说这个程序对硬盘读了 30000多次, 写了30000多次.

而硬盘IO是整个计算机最慢的动作, 所以我们需要减少外部设备的IO.


方法很简单, 就是增加每一次IO的数据量(缓冲), 自然就是减少了IO次数.


三, 使用缓冲流的例子

上面的代码只有两个流.

输入流fi 和 输出流.

下面修改一下, 增加两个缓冲流, 分别包裹着原始的输入输出流.

package Stream_kng.BufferStream_kng;

import java.io.*;

public class BufferStream1{

    public static void f(){
        FileInputStream fi = null;
        try{
            fi = new FileInputStream("/home/gateman/Music/Nickelback - Rockstar.flac");
        }catch(FileNotFoundException e){
            System.out.println("File not found!");
        }

        FileOutputStream fo = null;
        try{
            fo = new FileOutputStream("/home/gateman/tmp/Rockstar.flac");
        }catch(Exception e){
            System.out.println("error in file output stream's creation");
            e.printStackTrace();
        }

        //bufferStream
        BufferedInputStream bis = new BufferedInputStream(fi,512);
        BufferedOutputStream bos = new BufferedOutputStream(fo,512);
        

        int byt;
        try{
            byt = bis.read();
            while(-1 != byt){
                bos.write(byt);
                byt = bis.read();
            }
        }catch(IOException e){
            e.printStackTrace();
        }

        try{
            bos.flush();
        }catch(IOException e){
            System.out.println("Exception in flush()");
        }finally{
            if (null != bos){
                try{
                    bos.close();
                }catch(IOException e){
                    System.out.println("Exception in bos.close()");
                }
            }
           
            if (null != bis){
                try{
                    bis.close();
                }catch(IOException e){
                    System.out.println("Exception in bis.close()");
                }
            }

        }

        System.out.println("copy done!!");
    }
}

分析上面代码,  

 BufferedInputStream bis = new BufferedInputStream(fi,512);
 BufferedOutputStream bos = new BufferedOutputStream(fo,512);

这两句就建立了两个缓冲流对象, 分别包裹了 原始的输入流fi 和 原始的输出流fo. 并指定缓冲区的大小未512kb


后面就只调用缓冲流的read()和write方法.

代码看起来还是1个1个字节地读写的, 跟第二节例子很类似.


但是执行效果大大不同:

gateman@TPEOS classes $ ls -lh /home/gateman/tmp/Rockstar.flac
ls: cannot access /home/gateman/tmp/Rockstar.flac: No such file or directory
gateman@TPEOS classes $ time java Enter_1 
copy done!!

real	0m1.766s
user	0m1.612s
sys	0m0.168s
gateman@TPEOS classes $ ls -lh /home/gateman/tmp/Rockstar.flac
-rw-rw-r-- 1 gateman gateman 32M Jul  1 23:19 /home/gateman/tmp/Rockstar.flac

可见这次执行了1.766秒, 相比之前的57多秒简直不可以同日而语.


原因就是缓冲输入流会预读到512k(缓冲区大小)字节才发给程序, 缓冲输出流写满缓冲区(512k)才写入外部设备.


如下图:





四, 缓冲流输入流 BufferedInputStream流的常用方法介绍

上面程序使用了两个缓冲流:

BufferedInputStream 和 BufferedOutputStream.

分别对应输入和输出.


其实它们的机制类似.

这里只介绍缓冲输入流的常用方法:


4.1 new BufferedInputStream(InputStream is, int bufferSize)

这个是缓冲输入流最常用的构造方法.

它有两个参数, 第一个就是要包裹的输入流,  其中InputStream是1个抽象类, 实际上我们传送的是其子类(例如上面例子的FileInputStream)的对象, 这里用到多态的知识.

第二个参数也很重要, 就是制定缓冲流缓冲区的初始大小. 单位是kb 上面的例子我们指定为512kb.


注意构造方法并不需要强制捕捉异常.


4.2 int read() throws IOException

读取一个字节放入缓冲区, 用法与InputStream的read()基本一样的.


4.3 int read(byte[] bytArr) throws IOException

读取若干个字节放入字节数组bytArr, 返回实际读取的字节个数, 用法与InputStream的同名同参方法基本一样.


4.4 void mark(int readlimit) 和 void reset() throws IOException

这个方法就是缓冲输入流额外提供的方法.


它的作用就是在当前位置作1个标记,  它允许调用另1个方法reset() 令到流重新定位到这个标记上.

有点类似于oracle 的transation 的savepoint 和 rollback


它有什么意义?

它可以令我们在流中定1个标记, 然后读取标记后的若干数据作判断or处理, 如果符合某一条件可以返回到标记位置重新读取...


它的参数 int readlimit?

意思是, 调用reset()前允许读取的字节个个数,  更通俗地说, 一旦你标记后读取超过了readlimit个字节, 那么就不可再调用reset()了, 会抛异常.


而且, 这些操作都是基于缓冲区内处理的, 所以标记后读取的字节数也不能大于缓冲区大小再调用reset(), 所以 readlimit设置大于缓冲区是没有意义的.


4.5 void close() throws IOException

上面的例子有4个流, 两个原始流, 两个缓冲流, 但是到了代码的最后只关闭了两个缓冲流.


实际上, java中关闭1个处理流, 会自动调用处理流包裹的原始流的close()方法, 也就是说回嵌套地关闭流, 所以只需要关闭缓冲流, 不需关闭原始流, 否则抛异常!



五, 不使用缓冲流的缓冲机制.

实际上很多人都明白, 基本的原始流InputStream 有1个方法

int read(byte[]) 一次性地读取多个字节.

这个byte[] 字节数组实际上也是1个缓冲区.


下面例子:

package Stream_kng.BufferStream_kng;

import java.io.*;

public class Stream3{

    public static void f(){
        FileInputStream fi = null;
        try{
            fi = new FileInputStream("/home/gateman/Music/Nickelback - Rockstar.flac");
        }catch(FileNotFoundException e){
            System.out.println("File not found!");
        }

        FileOutputStream fo = null;
        try{
            fo = new FileOutputStream("/home/gateman/tmp/Rockstar.flac");
        }catch(Exception e){
            System.out.println("error in file output stream's creation");
            e.printStackTrace();
        }

        byte[] byteArr = new byte[512]; //use a buffer instead of a byte
        int len;
        try{
            len = fi.read(byteArr);
            while(-1 != len){
                fo.write(byteArr,0,len);
                len = fi.read(byteArr);
            }
        }catch(IOException e){
            e.printStackTrace();
        }

        try{
            fo.flush();
        }catch(IOException e){
            System.out.println("Exception in flush()");
        }finally{
            if (null != fo){
                try{
                    fo.close();
                }catch(IOException e){
                    System.out.println("Exception in fo.close()");
                }
            }
           
            if (null != fi){
                try{
                    fi.close();
                }catch(IOException e){
                    System.out.println("Exception in fi.close()");
                }
            }
        }

        System.out.println("copy done!!");
    }
}


上面例子没有使用缓冲流, 只有两个基本的字节输入输入流.

但是每一次读写都是利用到缓冲字节数组 bytArr.


实际上的效果也起到了缓冲作用, 缓冲的大小就是字节数组的大小(例子中是512k)

执行效果

ls: cannot access /home/gateman/tmp/Rockstar.flac: No such file or directory
gateman@TPEOS classes $ time java Enter_1 
copy done!!

real	0m0.246s
user	0m0.120s
sys	0m0.136s
gateman@TPEOS classes $ ls -lh /home/gateman/tmp/Rockstar.flac
-rw-rw-r-- 1 gateman gateman 32M Jul  1 23:48 /home/gateman/tmp/Rockstar.flac

实际效果更快了, 只需0.246s

貌似比使用缓冲流效果更好啊.


那么为何还需要缓冲流呢?

答案就是 缓冲流有预读机制,比起使用缓冲数组的缓冲效果更加明显, 如果处理一些大数据文件, 或者网络传输, 使用缓冲流的效果会更加好!


六, 总结

读到这里, 大家应该知道缓冲流的意义就是缓冲数据.


实际上很多常用的程序都有用到缓冲流的技术, 例如迅雷下载, 有缓冲区设置, 下载一定量的数据到内存, 然后一次过写入到硬盘, 就大大减少了写硬盘的次数.

还有在线视频的缓冲, 都是差不多的机制.




nvd11
关注
  • 10
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
Java字节缓冲流原理与用法详解
08-25
Java字节缓冲流原理与用法详解 Java字节缓冲流是Java IO系统中的一种重要组成部分，用于提高IO操作的性能。下面将详细介绍Java字节缓冲流的原理和用法。 一、Java字节缓冲流原理 Java字节缓冲流是一种基于缓冲区...
java使用缓冲流复制文件的方法
08-27
Java 使用缓冲流复制文件的方法 缓冲流是一种处理流，用来加快节点流对文件操作的速度。在 Java 开发中，使用缓冲流来处理文件可以提高文件处理的效率。在本文中，我们将详细介绍 Java 使用缓冲流复制文件的方法，...
Java 缓冲流
m0_47320958的博客
01-13 490
缓冲流概述 缓冲流也称为高效流、或者高级流。字节流可以称为原始流。 作用：缓冲流自带缓冲区、可以提高原始字节流、字符流读写数据的性能 缓冲流 字节缓冲流 字节缓冲输入流:Bufferedlnputstream 字节缓冲输出流:BufferedOutputStream 字符缓冲流 字符缓冲输入流:BufferedReader 字符缓冲输出流:BufferedWriter 字节缓冲流性能优化原理: 字节缓冲输入流自带了8KB缓冲池，以后我们直接从缓冲池读取数据，所以性能较好。
缓冲流的使用
90后中年人的博客
07-14 110
缓冲流的作用 缓冲流也叫高效流，缓冲流为我们预先开辟了一个8192的缓冲数组 字节缓冲流：BufferedInputStream，BufferedOutputStream 字符缓冲流：BufferedReader，BufferedWriter package com.company; import java.io.*; public class echeo { public static void main(String[] args) { Writer(); //
java之IO篇高级流——缓冲流、转化流、序列化流、打印流、压缩流
最新发布
2202_75483664的博客
08-05 971
上一篇IO流就介绍了File和基本流，这节介绍好用的高级流。还有IO流的心得：随用随创建，什么时候不用什么时候关闭目录前言一、缓冲流1.体系图2.字节缓冲流（1）用法（2）底层原理3.字符缓冲流（1）用法二、转换流1.作用2.示例三、序列化流和反序列化流1.序列化流ObjectOutputStream2.反序列化流ObjectInputStream3.关键细节四、打印流1.字节打印流PrintStream2.字符打印流PrintWriter3.和标准输出流的关系五、压缩流和解压缩流。
缓冲流的基本用法
qq_39409781的博客
01-05 252
package myIO; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; /* * BufferedWriter:将文本写入字符输出流，缓冲各个字符，从...
Java中的缓冲流（高效流)、双列集合、序列化与反序列化
wangsongll的博客
02-01 291
一、字节流 a.可以用来操作文本，还可以操作图片，音频等 例题：使用字节的输出输入流进行文件的复制 public class Demo{ public static void main(String [] args){ //这里获取系统时间，来进行执行效率 long start = System.currentTimeMillis(); //读取文件内容 FileInp
缓冲流的基本使用
云飞扬°的博客
04-13 650
缓冲流的基本使用 ①.BufferedWriter:将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。 ②.BufferedReader:从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。 缓冲流和基本流对底层数据进行读写时所用的方法其实是一样的，只不过创建对象时不一样，但是缓冲流的效率要高一些，所以一般采用缓冲流来读写文件。 ...
JAVA IO流缓冲字节流缓冲字符流等流经典代码示例加注释总结.rar
11-30
2、常用21个IO流：FileWriter、FileReader、...3、JAVA IO流经典代码示例，示例从易到难。代码功能涉及字节、字符、字符串、文本文件、图片、音频、视频。演示错误用法和经典用法。 4、代码的结构可查看README文件。
Java中的缓冲流——学习小结
01-20
使用缓冲流减少了对外部硬盘的访问次数，通过一系列测试证明，使用缓冲流可成几十倍甚至上百倍地提高读写效率，尤其是对于非文本文件的操作。 【重点】 所有的缓冲流都只是提供缓存，没有任何的读取、写入文件能力，...
详解java IO流之缓冲流的使用
08-31
Java IO流中的缓冲流是提高I/O操作性能的重要工具，它们并不直接进行读写操作，而是作为其他流的包装，通过内存缓冲区来优化数据传输。缓冲流分为字节缓冲流和字符缓冲流，每种又有输入和输出两种类型。 1. 字节...
JAVA中的缓冲流
weixin_44131997的博客
12-16 492
JAVA中的字节字符缓冲流
Java中的缓冲流
whycmpx的博客
12-21 192
1、缓冲输入流 Reader抽象类，其子类： InputStreamReader(InputStream in) 参数字节流对象，子类：FileReader(File file) 参数为File对象，FileReader(String fileName) 参数为文件路径； InputStreamReader(InputStream in,Charset cs) 参数为
Java 中的缓冲流
m0_46977298的博客
08-03 384
细节2：newLine()方法，当想写入换行符时，不同的系统中换行符是不一样的，比如Mac是\r，Linux中则是\n，Windows中则是\r\n。代码中直接写换行符其实是不合理的，比如同一个代码，放到不同的系统中效果是不一样的，这样不好，于是就要newLine()方法， 不同的系统中效果都是一样的。（1）缓冲流在使用时要传递基本流的对象过去，因为缓冲流只是对基本流包装了一下，并增加了缓冲区，但是干活的其实还是基本流。字节缓冲流的缓冲区是byte类型的，而字符缓冲流的缓冲区则是char类型的数组。
Java之缓冲流
m0_58398160的博客
09-01 195
1.缓冲流： 字节流于字符流：属于IO流的入门，那么即将学习的是更强大的流 缓冲流：高效流，是在基本流对象的基础上创建而来的，就像普通人穿上铠甲一样，相当于对基础流的一种增强 就是对四个基本的FileXXX流的增强，所以缓冲流也分为四个流 按照类型来区分： 字节缓冲流：BufferedInputStream、BufferedOutputStream 字符缓冲流：BufferedReader、Buffer...
java 缓冲流
zzx03918的博客
12-13 448
通过本文的介绍，我们深入了解了Java缓冲流的原理、使用方法和注意事项。缓冲流通过在内存中创建缓冲区，减少了直接与底层I/O设备的交互次数，从而提高了数据读写效率。在实际应用中，我们可以通过创建BufferedInputStream或BufferedOutputStream对象来使用缓冲流，并通过read()或write()方法进行数据的读取或写入。在使用缓冲流时，需要注意内存消耗情况、异常处理、资源关闭以及数据的完整性和正确性等问题。同时，在使用缓冲流进行网络传输时，需要注意网络连接的稳定性。
java缓冲流
酷酷的锐的博客
09-01 442
BufferedOutputStream:字节缓冲输出流           缓冲输出流的特点是：在流里维护了一个缓冲区，写字节时，先将字节写入缓冲区，当缓冲区满时，再一次性的将数据写到文件里。这样就降低了写的次数，因此提高了效率。                     因为缓冲输出流缺失即时性，可以使用flush方法进行冲刷  PS:当一次写的字节超出缓冲区大小，会直接写入到文件中    ...
Java-缓冲流
m0_47209867的博客
02-10 259
Java-缓冲流一、缓冲流概述二、字节缓冲输出流BufferedOutputStream三、字节缓冲输入流BufferedInputStream四、字符缓冲输出流BufferedWriter五、字符缓冲输入流BufferedReader 一、缓冲流概述 缓冲流：增强基本流的功能，在基本流的基础上演变而来。 按照数据类型进行分类分为： 字节缓冲流：BufferedInputStrem  BufferedOutputStream 字符缓冲流：BufferedReader  BufferedWriter 缓冲流的
java中的缓冲_Java中的缓冲流
weixin_35905707的博客
02-21 158
BufferedWriter和BufferedReaderBufferedWriter:将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。可以指定缓冲区的大小，或者接受默认的大小。在大多数情况下，默认值就足够大了。BufferedReader:从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。构造方法BufferedWriter(Writer ou...
提升IO效率：Java缓冲流详解与实现
缓冲流主要分为字节输入缓冲流（如`BufferedInputStream`）和字节输出缓冲流（如`BufferedOutputStream`），以及字符输入缓冲流（如`BufferedReader`）和字符输出缓冲流（如`BufferedWriter`）。它们的核心作用在于...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

nvd11

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值