java文件操作之缓冲字节流与字符流

首先我们必须明白凡是缓冲流，都不具备文件读写能力

其次就是缓冲流，内部都是维护了一个特别大的数组，也就是说，先把数据存放到数组上去，然后等数组满了或者手动刷新在输出到指定的地方。

说一下它的优势：

避免频繁的读取硬盘，读写文件从硬盘频繁与内存产生交互，非常浪费效率与浪费时间，如果先读到数组里面，在一下把数据取出去，效率就比较高。

下面说一下缓冲字节输入流与输出流：

看一下缓冲输入输出读取文件过程分析：

上面非常显著就是直接与内存打交道，一旦缓冲满了，在一下刷出去

比较一下加缓冲区与不加缓冲区，代码运行时间区别：

直接看代码：

import java.io.*;

public class BufferImageCopy {
    public static void main(String[] args) {
        File srcFile = new File("F:\\pxx\\1.jpg");
        File destFile = new File("F:\\pxxpxx.jpg");
        copyImage1(srcFile,destFile);
    }

    //采用缓冲流来读写数据
    public static void copyImage(File srcFile,File destFile) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            long startTime = System.currentTimeMillis();
            //循环读取，一边读一边写数据
            fis = new FileInputStream(srcFile);
            fos = new FileOutputStream(destFile);
            BufferedInputStream bis = new BufferedInputStream(fis);
            BufferedOutputStream bos = new BufferedOutputStream(fos);
            int res = 0;
            //返回读取到的字节数据
            while((res=bis.read()) != -1) {
                bos.write(res);
            }
            long endTime = System.currentTimeMillis();
            System.out.println("程序用时：" + (endTime - startTime));
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    //不用缓冲流读写数据
    public static void copyImage1(File srcFile,File destFile) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            long startTime = System.currentTimeMillis();
            fis = new FileInputStream(srcFile);
            fos = new FileOutputStream(destFile);
            int res = 0;
            while((res = fis.read()) != -1) {
                fos.write(res);
            }
            long endTime = System.currentTimeMillis();
            System.out.println("程序运行时间：" + (endTime - startTime));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                fis.close();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}

下面分别调用一下上面的函数，看一下运行结果：

加了缓冲读取一个文件的时间：

不加缓冲读取一个文件的时间：

这个差距一看还是挺明显啊。 

下面来说说缓冲输入字符流，原理与字节流一样：

下面简单说一下流转换，字符流可以包装成字节流操作