JavaSe之使用缓冲字节型处理流与缓冲字符型处理流实现文件复制 —— 学习缓冲流的笔记/学习IO流(四 — 完结篇)

首先给大家介绍一下什么是缓冲流:

java缓冲流本身不具IO功能,只是在别的流上加上缓冲提高效率,像是为别的流装上一种包装。当对文件或其他目标频繁读写或操作效率低,效能差。这时使用缓冲流能够更高效的读写信息。因为缓冲流先将数据缓存起来,然后一起写入或读取出来。所以说,缓冲流还是很重要的,在IO操作时记得加上缓冲流提升性能。

上述是我引用别人的话。其实缓冲流最重要的作用还是提升效率。给大家举一个通俗易懂的例子解说一下基本IO流的用途以及相互之间的联系:在当今社会,快递为大家提供了诸多方便,在世界上无时无刻都在进行快递的运送。文件(File)的作用相当于快递中的始发地与目的地之间的关系,节点流就像是运送快递的火车,缓冲流则在空间上增加了快递传输的速率。如果说节点流使用小货车装载快递进行运输的,那缓冲流就可能是大货车或者火车进行装载运输的,这两者的差距大家可想而知是在数量上的差距,而缓冲流和节点流的差距也是在这里。例子说完了,不知道大家看懂了吗?可在评论区进一步交流~


其次,给大家介绍一下具体的缓冲流以及它们各自属于输入流还是输出流:

- 缓冲流之字节流
字节输入缓冲流 ——> BufferedInputStream
字节输出缓冲流 ——> BufferedOutputStream

- 缓冲之字符流为
字符输入缓冲流 ——> BufferedReader
字符输出缓冲流 ——> BufferedWriter
接下来给大家介绍一下这四种流它们各自的功能:

  • BufferedOutputStream类实现缓冲的输出了,通过设置这种输出流,应用程序就可以将各个字节写入底层输出流中,而不必每一个字节写入都调用底层系统;
  • BufferedInputStream为别的输入流添加缓冲功能,在创建BufferedInputStream时会创建一个内部缓冲数组,用于缓冲数据,提高性能;
  • BufferedWriter是将文本写入字符输出流,缓冲各个字符,从而提供高效的写入。可以指定缓冲区的大小,一般情况下,默认的缓冲区大小就足够了;
  • .BufferedReader是从字符输入流中读取信息,缓冲各个字符,从而实现高效读取。可以指定缓冲区的大小,一般情况下,默认的缓冲区大小就足够了。

再次,我们来看看使用这两对缓冲流如何实现文件的复制,在这里注意了,它们虽然是缓冲流,但也是字符与字节流的进一步扩展,其各自针对的对象类型即操作的文件类型还是不变的。

- 使用缓冲字节流来完成文件的复制
步骤与代码都在底下:

package com.mec.about_BufferedAny;

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 TestAboutBufferedInOrOut {
    public static void main(String[] args) {
        //1.创建两个文件的对象,一个是源文件的位置与名称,另一个是木的文件的位置与名称
        File src = new File("Three.txt");     //源文件
        File dest = new File("Four.txt");     //目标文件

        //2.创建节点流,将创建的两个文件的对象传入相对应的节点流的构造方法中
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
                FileInputStream fis = new FileInputStream(src);
                FileOutputStream fos = new FileOutputStream(dest);

                //3.创建对应的缓冲流,将节点流的对象传入相应的缓冲流的构造方法中
                bis = new BufferedInputStream(fis);
                bos = new BufferedOutputStream(fos);
                //4.实现复制的核心代码
                //先定义一个数组,用于存放程序从源文件中读出的字节;
                //再定义一个整型的变量,用于存放每次程序读入到数组中的长度
                byte[] b = new byte[20];
                int len;
                while((len = bis.read(b)) != -1) {
                //写入操作
                    bos.write(b, 0, len);
                    bos.flush();
                }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
        //5.关闭文件,原因不再赘述;如果我不懂的小伙伴,可以在前一篇的文章的代码中看到原因
            if(bis != null) {
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        if(bos != null) {
            try {
                bos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }       
    }
}

我们来看一下这段代码所产生的结果:

  1. 代码未执行前的工程目录:
    JavaSe之使用缓冲字节型处理流与缓冲字符型处理流实现文件复制 —— 学习缓冲流的笔记/学习IO流(四 — 完结篇)_第1张图片

  2. 执行完代码并刷新之后的工程目录:
    JavaSe之使用缓冲字节型处理流与缓冲字符型处理流实现文件复制 —— 学习缓冲流的笔记/学习IO流(四 — 完结篇)_第2张图片

  3. 我们打开这两个文件对比一下:
    JavaSe之使用缓冲字节型处理流与缓冲字符型处理流实现文件复制 —— 学习缓冲流的笔记/学习IO流(四 — 完结篇)_第3张图片
    缓冲字节流的部分说完了,整个字节流部分就到这里吧!如果以后有其他一些问题,我会再写博客与大家分享。接下来,我们进入缓冲字符流的学习~


    - 使用字缓冲符流来完成文件的复制
    这个步骤与代码也是放在一起的,如下所示:

package com.mec.about_BufferedAny;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class TestAboutReaderAndWriter {
    public static void main(String[] args) {
        //使用BufferedReader和BufferedWriter实现文文件复制吗?是的
        //1.创建两个文件的对象,指明两个文件的位置以及名称
        File src = new File("One.txt");   //源文件
        File dest = new File("Two.txt");    //目标文件

        //2.写出两个文件的节点流,将各自的File对象作为参数传入构造方法中
        //这里的理解与上述字节型代码相似
        BufferedReader br = null;
        BufferedWriter bw = null;
        try {
                FileReader fr = new FileReader(src);
                FileWriter fw = new FileWriter(dest);

                br = new BufferedReader(fr);
                bw = new BufferedWriter(fw);
            //被注释起来的这一段是实现复制的核心代码的另一种实现方式   
            /*  String string = null;
                while((string = br.readLine()) != null) {
                    bw.write(string);
                    bw.newLine();
                    bw.flush();                 
                }*/
                //3.复制的核心代码,在这里定义数组与整型变量的理解与上述字节型代码相同
                char[] c = new char[400];
                int len;
                while((len = br.read(c)) != -1) {
                    bw.write(c, 0, len);
                    bw.flush();   //这个函数是BufferedWriter特有的
                }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
        //4.关闭文件操作
            if(br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(bw != null) {
                try {
                    bw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

执行步骤与上述相同,在此我们只看最终结果:
JavaSe之使用缓冲字节型处理流与缓冲字符型处理流实现文件复制 —— 学习缓冲流的笔记/学习IO流(四 — 完结篇)_第4张图片
写到这里,缓冲字符流的部分基本完成。最后的最后,我想给大家说几点比较重要的注意事项:

- 字节流与字符流的几个不同之处
1.字节流及其扩充类在使用时,要关注其定义数组的类型,字节行的数组为byte类型,而字符型的数组为char类型;
2.选择合适的节点流与缓冲流,保证程序正确执行;
3.一定要在程序完成之后关闭文件,如果是并列层次的文件,则都要关闭,如果是有小到大的顺序,就像File ——> FileInputStream ——> BufferedReader,则可以只关闭BufferedReader类所产生的对象。
那博主的学习IO流部分就结束了!谢谢大家~
图片来源:视觉中国
JavaSe之使用缓冲字节型处理流与缓冲字符型处理流实现文件复制 —— 学习缓冲流的笔记/学习IO流(四 — 完结篇)_第5张图片

*
*
*
*
*
*

你可能感兴趣的:(about_Java)