Java基础-IO流对象之字节缓冲流(BufferedOutputStream与BufferedInputStream)

　　　　　　　　　　Java基础-IO流对象之字节缓冲流(BufferedOutputStream与BufferedInputStream)

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正杰

版权声明：原创作品，谢绝转载！否则将追究法律责任。

　　在我们学习字节流与字符流的时候，大家都进行过读取文件中数据的操作，读取数据量大的文件时，读取的速度会很慢，很影响我们程序的效率，那么，我想提高速度，怎么办？Java中提高了一套缓冲流，它的存在，可提高IO流的读写速度

　　缓冲流，根据流的分类分为字节缓冲流与字符缓冲流。本篇博客主要介绍的是字节缓冲流。

一.字节缓冲流

　　字节缓冲流根据流的方向，共有2个:

　　　　　　1>. 写入数据到流中，字节缓冲输出流 BufferedOutputStream

　　　　　　2>.读取流中的数据，字节缓冲输入流 BufferedInputStream

　　它们的内部都包含了一个缓冲区，通过缓冲区读写，就可以提高了IO流的读写速度

 

二.字节输出缓冲流

　　java.io.BufferedOutputStream作用：提高原有输出流的写入效率。

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
EMAIL:y1053419035@qq.com
*/

package cn.org.yinzhengjie.note5;

import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class BufferedOutputStreamDemo {
    public static void main(String[] args) throws IOException {
        //创建字节输出流，绑定文件
        FileOutputStream fos = new FileOutputStream("yinzhengjie.txt");
        //创建字节输出流缓冲流对象，构造方法中，传递字节输出流，实这里也可以直接匿名生成。
        BufferedOutputStream bos = new BufferedOutputStream(fos);    
        //写入一个字节
        bos.write(97);
        //将字符串变成字节数组
        byte[] buf = "yinzhengjie".getBytes();     
        //写一个字节数组
        bos.write(buf);
        //写入字节数组的一部分
        bos.write(buf, 3, 5);
        //释放资源,我们不用关闭fos对象，因为关闭bos对象会自动关闭fos流。
        bos.close();
    }
}

三.字节输入缓冲流

　　java.io.BufferedInputStream作用：提高原有输入流的读取效率。

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
EMAIL:y1053419035@qq.com
*/

package cn.org.yinzhengjie.note5;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class BufferedInputStreamDemo {
    public static void main(String[] args) throws IOException {
        //创建字节输入流，包装文件
        FileInputStream fis = new FileInputStream("yinzhengjie.txt");
        //创建字节输入流缓冲流对象，构造方法中包装字节输入流，包装文件
        BufferedInputStream bis = new BufferedInputStream(fis);
        //按照字节数组的方式进行读取操作，此处我并没有按照单个字节方式进行读取。
        byte[] buf = new byte[4096];
        int len;
        while(( len = bis.read(buf)) != -1 ) {
            System.out.println(new String(buf,0,len));
        }
        //释放资源,此处还是不用关闭fis流对象。
        bis.close();
    }
}


/*
以上代码执行结果如下：
ayinzhengjiezheng
*/

四.四种文件复制方式的效率比较

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
EMAIL:y1053419035@qq.com
*/

package cn.org.yinzhengjie.note5;

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

public class CopyFile {
    public static void main(String[] args) throws IOException {
        
        long start = System.currentTimeMillis();
//        copy1(new File("yinzhengjie.sql"),new File("yinzhengjie.sql.backup"));
//        copy2(new File("yinzhengjie.sql"),new File("yinzhengjie.sql.backup"));
//        copy3(new File("yinzhengjie.sql"),new File("yinzhengjie.sql.backup"));      //
        copy4(new File("yinzhengjie.sql"),new File("yinzhengjie.sql.backup"));   ////拷贝的是600M的文件只需要862毫秒，效率是最高的！（固态硬盘）
        long stop = System.currentTimeMillis();
        System.out.println(stop-start);
    }
    
    

    //1>.字节流读写单个字符。
    public static void copy1(File src,File dest) throws IOException{
        FileInputStream fis = new FileInputStream(src);
        FileOutputStream fos = new FileOutputStream(dest);
        int len;
        while( (len = fis.read()) != -1) {
            fos.write(len);
        }
        fos.close();
        fis.close();
    }
    
    //2>.字节流读写字节数组
    public static void copy2(File src,File dest) throws IOException{
        FileInputStream fis = new FileInputStream(src);
        FileOutputStream fos = new FileOutputStream(dest);
        byte[] cache = new byte[1024];
        int len = 0;
        while( (len = fis.read(cache)) != -1) {
            fos.write(cache, 0, len);
        }
        fos.close();
        fis.close();
    }
    
    //字节流缓冲区读取单个字符
    public static void copy3(File src,File dest) throws IOException{
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(src));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(dest));
        
        int len = 0;
        while( (len = bis.read()) != -1 ) {
            bos.write(len);
        }
        bos.close();
        bis.close();
    }
    
    //字节流缓冲区读取字符数组
    public static void copy4(File src,File dest) throws IOException{
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(src));
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(dest));
        byte[] cache = new byte[1024];
        int len;
        while((len = bis.read(cache)) != -1 ) {
            bos.write(cache, 0, len);
        }
    }
    
}