Java第三阶段学习（四、缓冲流）

一、缓冲流：

Java中提供了一套缓冲流，它的存在，可提高IO流的读写速度

缓冲流，根据流的分类分为：字节缓冲流与字符缓冲流。

二、字节缓冲流：

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

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

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

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

2.1字节缓冲输出流 BufferedOutputStream类

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("abc.txt");
        //使用高效的流，把基本的流进行封装，实现速度的提升
        BufferedOutputStream out = new BufferedOutputStream(fileOut);
        //2，写数据
        out.write("hello".getBytes());
        //3，关闭流
        out.close();
    }
}

2.2字节缓冲输入流 BufferedInputStream类

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

练习题：利用缓冲字节流复制文件

package com.oracle.demo02;

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

//缓冲字节流
public class BufferCopy {

    public static void main(String[] args) throws IOException {
        long time1=System.currentTimeMillis();
        //1.确定数据源
        FileInputStream fis=new FileInputStream("e:\\java\\eclipse.zip");
        BufferedInputStream bis=new BufferedInputStream(fis);
        //2.确定目标地
        FileOutputStream fos=new FileOutputStream("d:\\java\\java\\dandan\\eclipse.zip");
        BufferedOutputStream bos=new BufferedOutputStream(fos);
        //3.读取与写入
        int len=0;
        byte[] bytes=new byte[1024];
        while((len=bis.read(bytes))!=-1){
            bos.write(bytes);
        }
        //4.刷新并释放资源
        bos.flush();
        bos.close();
        bis.close();
        long time2=System.currentTimeMillis();
        System.out.println("所用时间："+(time2-time1)/1000+"秒");
    }

}

 三、字符缓冲流

1. 字符缓冲输入流 BufferedReader

2.  字符缓冲输出流 BufferedWriter

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

3.1字符缓冲输入流BufferedReader类

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

特殊方法：

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

package com.oracle.Demo01;

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

public class Demo02 {
//字符缓冲输入流
    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        FileReader fr=new FileReader("e:\\java\\output.txt");
        BufferedReader br=new BufferedReader(fr);
        //读取一个文本行的方法      .readLine()   返回值为String  用null来控制循环
        //while循环方法读取
        String str=null;
        while((str=br.readLine())!=null){   //当返回值为null时，说明读取不到字符了
            System.out.println(str);
        }
        //普通方法读取
//        String str1=br.readLine();
//        System.out.println(str1);
//        String str2=br.readLine();
//        System.out.println(str2);
//        String str3=br.readLine();
//        System.out.println(str3);   //当读取不到内容时，会返回null
        br.close();
    }

}

3.2字符缓冲输出流BufferedWriter类

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

特殊方法：

newLine() 根据当前的系统，写入一个换行符。

package com.oracle.Demo01;

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

public class Demo01 {
//字符缓冲输出流
    public static void main(String[] args) throws IOException {
        //1.确定目的地
        FileWriter fw=new FileWriter("e:\\java\\output.txt",true);
        //2.封装为字符缓冲流
        BufferedWriter bw=new BufferedWriter(fw);
        //3.写入数据
        bw.write("你好吗");
        bw.newLine();    //字符缓冲输出流，换行的方法：.newLine();
        bw.flush();
        bw.write("我很好");  //刷新流并不会关闭流，所以可以继续输出
        bw.close();
        
    }

}

练习题：利用缓冲流进行文件复制

package com.oracle.Demo01;

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

public class BufferedCopy {
//缓冲字符流的复制
    public static void main(String[] args) throws IOException {
        //1.获取数据源
        FileReader fr=new FileReader("e:\\java\\output.txt");
        //2.封装成缓冲流
        BufferedReader br=new BufferedReader(fr);
        //3.获取目的地
        FileWriter fw=new FileWriter("e:\\java\\copy.txt",true);
        //4.封装成缓冲流
        BufferedWriter bw=new BufferedWriter(fw);
        //5.读取与写入
        String str=null;
        while((str=br.readLine())!=null){
            bw.write(str);
            bw.newLine();   //因为读取时是用文本行方法读取的，所以为了格式统一，需要加入换行方法
        }
        //6.释放资源
        bw.newLine();
        bw.close();
        br.close();
    }

}