242 - 缓冲字节/字符流(处理流)

1、缓冲字节流(处理流)：

                        BufferedInputStream  ,   BufferedOutputStream

【1】读入一个字节，写出一个字节

 【2】利用缓冲字节数组

 【3】利用缓冲区

         想要完成上面的效果，单纯的靠 FileInputStream,FileOutputStream 是不可以完成的，这个时候就需要功能的加强。

        这个加强就需要引入新的流（在FileInputStream,FileOutputStream外面再套一层流）：BufferedInputStream ,BufferedOutputStream ----->处理流                 

 代码示例：

package test4_Buffered;

import java.io.*;

/**
 * @Auther: zhoulz
 * @Description: test4_Buffered
 * @version: 1.0
 */
public class Test1 {
    public static void main(String[] args) throws IOException {
        // 1.有一个源图片
        File f1 = new File("d:\\LOL.jpg");
        //2、有一个目标文件
        File f2 = new File("d:\\LOL2.jpg");
        //3、有一个输入的管道 怼 到 源文件：
        FileInputStream fis = new FileInputStream(f1);
        //4、有一个输出的管道 怼到  目标文件上：
        FileOutputStream fos = new FileOutputStream(f2);

        //5.功能加强，在FileInputStream外面套一个管：BufferedInputStream:
        BufferedInputStream bis = new BufferedInputStream(fis);
        //6.功能加强，在FileOutputStream外面套一个管：BufferedOutputStream:
        BufferedOutputStream bos = new BufferedOutputStream(fos);

        //7、开始动作
        byte[] b = new byte[1024*8];
        int len = bis.read(b);

        while (len != -1){
            //System.out.println(b);
            bos.write(b,0,len);
            //bos.flush();//底层已经帮我们做了刷新缓冲区的操作，
                          // 不用我们手动完成：底层调用flushBuffer()
            len = bis.read(b);
        }

        //8、关闭流 —— 倒着关
        //如果处理流包裹着节点流的话，那么其实只要关闭高级流(处理流),
        // 那么里面的字节流也会随之被关闭
        bos.close();
        bis.close();
        /*fos.close();
        fis.close();*/
    }
}

2、比对非文本文件复制的三种方法的效率

【1】读入一个字节，写出一个字节

代码示例：

//5.开始复制：（边读边写）
        long startTime = System.currentTimeMillis();
        int n = fis.read();
        while (n != -1){
            fos.write(n);
            n = fis.read();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("复制完成的时间为："+(endTime-startTime));

结果：（单位：毫秒）

【2】利用缓冲字节数组

代码示例：

//5.开始复制：（边读边写）
        //利用缓冲数组
        long startTime = System.currentTimeMillis();
        byte[] b = new byte[1024*8];
        int len = fis.read(b);
        while (len != -1){
            //fos.write(b); //写入的文件比原来的大
            fos.write(b,0,len);//写入有效长度
            len = fis.read(b);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("复制完成的时间为："+(endTime-startTime));

结果 ：

 

 【3】利用缓冲区

代码示例：

        //5.功能加强，在FileInputStream外面套一个管：BufferedInputStream:
        BufferedInputStream bis = new BufferedInputStream(fis);
        //6.功能加强，在FileOutputStream外面套一个管：BufferedOutputStream:
        BufferedOutputStream bos = new BufferedOutputStream(fos);

        //7、开始动作
        long startTime = System.currentTimeMillis();
        byte[] b = new byte[1024*8];
        int len = bis.read(b);

        while (len != -1){
            //System.out.println(b);
            bos.write(b,0,len);
            //bos.flush();//底层已经帮我们做了刷新缓冲区的操作，
                          // 不用我们手动完成：底层调用flushBuffer()
            len = bis.read(b);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("复制完成的时间为："+(endTime-startTime));

结果：

3、缓冲字符流(处理流)：

                BufferedReader  ,  BufferedWriter —— 完成文本文件的复制

代码示例：

package test4_Buffered;

import javax.xml.transform.OutputKeys;
import java.io.*;
import java.lang.reflect.Field;

/**
 * @Auther: zhoulz
 * @Description: test4_Buffered
 * @version: 1.0
 */
public class Test2 {
    public static void main(String[] args) throws IOException {
        //1、有一个源文件
        File f1 = new File("d:\\Test.txt");
        //2、有一个目标文件
        File f2 = new File("d:\\Demo.txt");
        //3、需要一个管 怼到 源文件
        FileReader fr = new FileReader(f1);
        //4、需要一根管 怼到 目标文件
        FileWriter fw = new FileWriter(f2);
        //5、套一根管在输入字符流外面：
        BufferedReader br = new BufferedReader(fr);
        //6、套一根管在输出字符流外面：
        BufferedWriter bw = new BufferedWriter(fw);
        //7、开始动作：
        //方式1：读取一个字符，输出一个字符：
        /*int n = br.read();
        while (n != -1){
            bw.write(n);
            n = br.read();
        }*/

        //方式2：利用缓冲数组
        /*char[] ch = new char[8];
        int len = br.read(ch);
        while (len != -1){
            System.out.println(len);
            bw.write(ch,0,len);
            len = br.read(ch);
        }*/
        // 字节流 中没有以下这种方式
        //方式3：读取String
        String str = br.readLine(); //每次读取文本文件中一行，返回字符串
        while (str != null){ //注意，不是 -1 了
            //System.out.println(str);
            bw.write(str);
            //在文本文件中应该再写出一个换行：
            bw.newLine();//新起一行
                         //不加的话，新复制的文件里不会换行
            str = br.readLine();
        }
        //8、关闭流
        bw.close();
        br.close();
    }
}