00094_缓冲区

1、字节缓冲区

　　（1）写入数据到流中，字节缓冲输出流 BufferedOutputStream；

　　（2）读取流中的数据，字节缓冲输入流 BufferedInputStream；

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

2、字节缓冲输出流BufferedOutputStream

　　通过字节缓冲流，进行文件的读写操作，写数据到文件的操作 。

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

public class BufferedOutputStreamDemo01 {
    public static void main(String[] args) throws IOException {

        // 写数据到文件的方法
        write();
    }

    /*
     * 写数据到文件的方法 1,创建流 2，写数据 3，关闭流
     */
    private static void write() throws IOException {
        // 创建基本的字节输出流
        FileOutputStream fileOut = new FileOutputStream("d:\abc.txt");
        // 使用高效的流，把基本的流进行封装，实现速度的提升
        BufferedOutputStream out = new BufferedOutputStream(fileOut);
        // 2，写数据
        out.write("I Love You".getBytes());
        // 3，关闭流
        out.close();
    }
}

3、字节缓冲输入流 BufferedInputStream

　　完成读取文件中数据的操作。

/*
     * 从文件中读取数据
     * 1,创建缓冲流对象
     * 2，读数据，打印
     * 3，关闭
     */
    private static void read() throws IOException {
        //1,创建缓冲流对象
        FileInputStream fileIn = new FileInputStream("d:\abc.txt");
        //把基本的流包装成高效的流
        BufferedInputStream in = new BufferedInputStream(fileIn);
        //2，读数据
        int ch = -1;
        while ( (ch = in.read()) != -1 ) {
            //打印
            System.out.print((char)ch);
        }
        //3，关闭
        in.close();
    }

4、使用基本的流与高效的流完成复制文件

　　测试视频链接：测试视频 密码：obki

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

/*
 * 需求：将d:\test.mp4文件进行复制
 *         采用4种方式复制
 *         方式1： 采用基本的流，一次一个字节的方式复制    共耗时 67564毫秒
 *         方式2： 采用基本的流，一个多个字节的方式赋值    共耗时 109毫秒
 *         方式3： 采用高效的流，一次一个字节的方式复制    共耗时 936毫秒
 *         方式4： 采用高效的流，一个多个字节的方式赋值    共耗时 43毫秒
 * 
 * 数据源： d:\test.mp4
 * 目的地1: d:\copy1.mp4
 * 目的地2: d:\copy2.mp4
 * 目的地3: d:\copy3.mp4
 * 目的地4: d:\copy4.mp4
 * 
 * 实现的步骤：
 *     1，指定数据源
 *     2，指定目的地
 *     3，读数据
 *     4，写数据
 *     5，关闭流
 * 
 */
public class CopyAVI {
    public static void main(String[] args) throws IOException {
        // 开始计时
        long start = System.currentTimeMillis();
        // 方式1： 采用基本的流，一次一个字节的方式复制
        // method1("d:\test.mp4", "d:\copy1.mp4");
        // 方式2： 采用基本的流，一个多个字节的方式赋值
        // method2("d:\test.mp4", "d:\copy2.mp4");
        // 方式3： 采用高效的流，一次一个字节的方式复制
        // method3("d:\test.mp4", "d:\copy3.mp4");
        // 方式4： 采用高效的流，一个多个字节的方式赋值
        method4("d:\test.mp4", "d:\copy4.mp4");

        // 结束计时
        long end = System.currentTimeMillis();
        // 打印耗时多少毫秒
        System.out.println("共耗时 " + (end - start) + "毫秒");
    }

    // 方式4： 采用高效的流，一个多个字节的方式赋值
    private static void method4(String src, String dest) throws IOException {
        // 1，指定数据源
        BufferedInputStream in = new BufferedInputStream(new FileInputStream(
                src));
        // 2，指定目的地
        BufferedOutputStream out = new BufferedOutputStream(
                new FileOutputStream(dest));
        // 3，读数据
        byte[] buffer = new byte[1024];
        int len = -1;
        while ((len = in.read(buffer)) != -1) {
            // 4,写数据
            out.write(buffer, 0, len);
        }
        // 5，关闭流
        in.close();
        out.close();
    }

    // 方式3： 采用高效的流，一次一个字节的方式复制
    private static void method3(String src, String dest) throws IOException {
        // 1，指定数据源
        BufferedInputStream in = new BufferedInputStream(new FileInputStream(
                src));
        // 2，指定目的地
        BufferedOutputStream out = new BufferedOutputStream(
                new FileOutputStream(dest));
        // 3，读数据
        int ch = -1;
        while ((ch = in.read()) != -1) {
            // 4，写数据
            out.write(ch);
        }
        // 5，关闭流
        in.close();
        out.close();
    }

    // 方式2： 采用基本的流，一个多个字节的方式赋值
    private static void method2(String src, String dest) throws IOException {
        // 1，指定数据源
        FileInputStream in = new FileInputStream(src);
        // 2，指定目的地
        FileOutputStream out = new FileOutputStream(dest);
        // 3，读数据
        byte[] buffer = new byte[1024];
        int len = -1;
        while ((len = in.read(buffer)) != -1) {
            // 4，写数据
            out.write(buffer, 0, len);
        }
        // 5，关闭流
        in.close();
        out.close();
    }

    // 方式1： 采用基本的流，一次一个字节的方式复制
    private static void method1(String src, String dest) throws IOException {
        // 1，指定数据源
        FileInputStream in = new FileInputStream(src);
        // 2，指定目的地
        FileOutputStream out = new FileOutputStream(dest);
        // 3，读数据
        int ch = -1;
        while ((ch = in.read()) != -1) {
            // 4，写数据
            out.write(ch);
        }
        // 5，关闭流
        in.close();
        out.close();
    }
}

 5、字符缓冲区

　　（1）字符缓冲输入流 BufferedReader；

　　（2）字符缓冲输出流 BufferedWriter；

　　（3）完成文本数据的高效的写入与读取的操作。

6、字符缓冲输出流 BufferedWriter

　　（1）将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入；

　　（2）方法：void newLine() 根据当前的系统，写入一个换行符。

/*
 * BufferedWriter 字符缓冲输出流
 * 方法
 *     public void newLine()写入一个行分隔符
 * 
 * 需求： 通过缓冲输出流写入数据到文件
 * 分析：
 *     1，创建流对象
 *     2，写数据
 *     3，关闭流
 * 
 */
public class BufferedWriterDemo {
    public static void main(String[] args) throws IOException {
        //创建流
        //基本字符输出流
        FileWriter fileOut = new FileWriter("d:\Java\file.txt");
        //把基本的流进行包装
        BufferedWriter out = new BufferedWriter(fileOut);
        //2，写数据
        for (int i=0; i<5; i++) {
            out.write("hello");
            out.newLine();
        }
        //3,关闭流
        out.close();
    }
}

7、字符缓冲输入流 BufferedReader

　　（1）从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取；

　　（2）public String readLine() 读取一个文本行，包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null。

/*
 * BufferedReader 字符缓冲输入流
 * 
 * 方法：
 *     String readLine() 
 * 需求：从文件中读取数据，并显示数据
 */
public class BufferedReaderDemo {
    public static void main(String[] args) throws IOException {
        //1,创建流
        BufferedReader in = new BufferedReader(new FileReader("d:\Java\file.txt"));
        //2，读数据
        //一次一个字符
        //一次一个字符数组
        //一次读取文本中一行的字符串内容
        String line = null;
        while( (line = in.readLine()) != null ){
            System.out.println(line);
        }
        
        //3,关闭流
        in.close();
    }
}

8、使用字符缓冲流完成文本文件的复制

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/*
 * 采用高效的字符缓冲流，完成文本文件的赋值
 * 
 * 数据源:d:\Java\file.txt
 * 目的地:d:\Java\copyFile.txt
 * 
 * 分析：
 *     1，指定数据源， 是数据源中读数据，采用输入流
 *     2,指定目的地，是把数据写入目的地，采用输出流
 *     3,读数据
 *     4，写数据
 *     5，关闭流
 */
public class CopyTextFile {
    public static void main(String[] args) throws IOException {
        // 1，指定数据源， 是数据源中读数据，采用输入流
        BufferedReader in = new BufferedReader(new FileReader(
                "d:\Java\file.txt"));
        // 2,指定目的地，是把数据写入目的地，采用输出流
        BufferedWriter out = new BufferedWriter(new FileWriter(
                "d:\Java\copyFile.txt"));
        // 3,读数据
        String line = null;
        while ((line = in.readLine()) != null) {
            // 4，写数据
            out.write(line);
            // 写入换行符号
            out.newLine();
        }
        // 5，关闭流
        out.close();
        in.close();
    }
}

完成文本数据的高效的写入与读取的操作