缓冲流（BufferedOutputStream BufferedInputStream BufferedWriter BufferedReader）

原理：在创建流对象时，在内存中会创建一个默认大小的缓冲数组，在读写时，先将数据写在缓冲数组中，再将缓冲数组交给系统-JVM，减少了系统读写次数，从而提高了读写效率
这跟用数组进行read（byte[] b）和write(byte[] b)差不多

BufferedOutputStream类 extends OutputStream-----字节缓冲输出流
构造方法：
public BufferedOutputStream(OutputStream out) ---缓冲数组默认为8192
public BufferedOutputStream(OutputStream out, int size) ---size设置缓冲数组的大小
使用步骤：
1.创建一个继承了OutputStream的类的对象，构造方法中绑定要输出的目的地
2.创建BufferedOutputStream对象，构造方法中传递继承了OutputStream的类的对象
3.使用BufferedOutputStream对象的write方法，写数据
4.使用BufferedOutputStream对象中flush方法，将内存中缓冲数组的数据，刷新到文件中去
5.释放资源（会先调用flush方法，刷新数据，4可省略，直接关闭BufferedOutputStream，OutputStream会自动关闭）

package iotest.bufferedIOtest;

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

public class BufferedOutputStreamTest01 {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("src\\iotest\\bufferedIOtest\\a.txt");
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        bos.write(97);
        bos.flush();
        fos.close();
        bos.close();
    }
}

 

BufferedInputStream 类extends InputStream ---字节缓冲输入流
构造方法：
public BufferedInputStream(InputStream in)---缓冲数组默认为8192
public BufferedInputStream(InputStream in, int size) --size设置缓冲数组的大小

使用步骤：
1.创建一个继承了InputStream 的类的对象，构造方法中绑定要读取的文件的地址
2.创建BufferedInputStream 对象，构造方法中传递继承了InputStream 的类的对象
3.使用BufferedInputStream 对象的read方法，读数据
4.释放资源（直接关闭BufferedOutputStream，OutputStream会自动关闭）

package iotest.bufferedIOtest;

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

public class BufferedInputStreamTest01 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("src\\iotest\\bufferedIOtest\\a.txt");
        BufferedInputStream bis = new BufferedInputStream(fis);
        //一次读取一个字节
        /*int len = 0;
        while ((len = bis.read()) != -1){
            System.out.print((char)len);
        }*/

        //运用数组，一次读取多个字节
        int len = 0;
        byte[] bytes = new byte[1024];
        while ((len = bis.read(bytes)) != -1){
            System.out.println(new String(bytes));
        }
        bis.close();
    }
}

不同方式复制文件的效率比较

package iotest.bufferedIOtest.copytest;

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

//运用字节流，一次读取一个字节，来复制文件
//文件复制共用了429毫秒
public class Copy1 {
    public static void main(String[] args) throws IOException {
        long startTime = System.currentTimeMillis();
        FileInputStream fis = new FileInputStream("C:\\test\\1.jpg");
        FileOutputStream fos = new FileOutputStream("D:\\test\\1.jpg");

        int len = 0;
        while ((len = fis.read()) != -1){
            fos.write(len);
        }
        fos.close();
        fis.close();
        long endTime = System.currentTimeMillis();
        System.out.println("文件复制共用了"+(endTime-startTime)+"毫秒");
    }
}

package iotest.bufferedIOtest.copytest;

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

//运用字节流，运用字节数组来读取文件
//文件复制共用了11毫秒
public class Copy2 {
    public static void main(String[] args) throws IOException {
        long startTime = System.currentTimeMillis();
        FileInputStream fis = new FileInputStream("C:\\test\\1.jpg");
        FileOutputStream fos = new FileOutputStream("D:\\test\\1.jpg");

        int len = 0;
        byte[] bytes = new byte[1024];
        while ((len = fis.read(bytes)) != -1){
            fos.write(bytes,0,len);
        }

        fos.close();
        fis.close();

        long endTime = System.currentTimeMillis();
        System.out.println("文件复制共用了"+(endTime-startTime)+"毫秒");
    }
}

package iotest.bufferedIOtest.copytest;

import java.io.*;

//运用字节缓冲流，一次读写一个字节，来复制文件
//文件复制共用了14毫秒
public class Copy3 {
    public static void main(String[] args) throws IOException {
        long startTime = System.currentTimeMillis();

        FileInputStream fis = new FileInputStream("C:\\test\\1.jpg");
        FileOutputStream fos = new FileOutputStream("D:\\test\\1.jpg");
        BufferedInputStream bis = new BufferedInputStream(fis);
        BufferedOutputStream bos = new BufferedOutputStream(fos);

        int len =0 ;
        while ((len = bis.read()) != -1){
            bos.write(len);
        }
        bos.close();
        bis.close();

        long endTime = System.currentTimeMillis();
        System.out.println("文件复制共用了"+(endTime-startTime)+"毫秒");


    }
}

package iotest.bufferedIOtest.copytest;

import java.io.*;

//运用字节缓冲流，运用字节数组，来复制文件
//文件复制共用了10毫秒
public class Copy4 {
    public static void main(String[] args) throws IOException {
        long startTime = System.currentTimeMillis();

        FileInputStream fis = new FileInputStream("C:\\test\\1.jpg");
        FileOutputStream fos = new FileOutputStream("D:\\test\\1.jpg");

        BufferedInputStream bis = new BufferedInputStream(fis);
        BufferedOutputStream bos = new BufferedOutputStream(fos);

        int len = 0;
        byte[] bytes = new byte[1024];
        while ((len = bis.read(bytes)) != -1){
            bos.write(bytes,0,len);
        }
        bos.close();
        bis.close();

        long endTime = System.currentTimeMillis();
        System.out.println("文件复制共用了"+(endTime-startTime)+"毫秒");



    }
}

结论：数组+缓冲流 > 只用数组 > 只用缓冲流，来一个字节一个字节的读写 > 一个字节一个字节的读写

 

BufferedWriter类 extends Writer ---字符缓冲输出流
构造方法：
public BufferedWriter(Writer out) --默认缓冲数组
public BufferedWriter(Writer out, int sz)---size设置缓冲数组的大小
特有的方法：
public void newLine()---获取系统的换行符，写下来，换行（有这个方法不用区分系统换行符了）

package iotest.bufferedIOtest;

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

public class BufferedWriterTest01 {
    public static void main(String[] args) throws IOException {
        FileWriter fw = new FileWriter("src\\iotest\\bufferedIOtest\\a.txt");
        BufferedWriter bw = new BufferedWriter(fw);
        bw.write("哈哈哈哈");
        bw.newLine();
        bw.write("喀斯柯达");

        bw.close();
        System.out.println();


    }
}

BufferedReader类extends Reader--字符缓冲输入流
构造方法：
public BufferedReader(Reader in)---默认缓冲数组
public BufferedReader(Reader in, int sz) ---size设置缓冲数组的大小
特有的方法：
public String readLine() ---读取一行数据
行的终止符号：可以是换行\n,回车\r,也可以是\r\n
返回值：
包含该行内容的字符串，不包含任何行终止符，如果到达流末尾，返回null

package iotest.bufferedIOtest;

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

public class BufferReaderTest01 {
    public static void main(String[] args) throws IOException {
        FileReader fr = new FileReader("src\\iotest\\bufferedIOtest\\a.txt");
        BufferedReader br = new BufferedReader(fr);
        /*int len = 0;
        while ((len = br.read()) != -1){
            System.out.println((char) len);
        }*/

        String line = null;
        while ((line = br.readLine()) != null){
            System.out.print(line);
        }
        br.close();
    }
}

 

练习：对文本内容进行排序
a.txt文本中
4.哈哈哈手机单
1.Adam什么的
3.爱迪生，啊啊大
2.啊看到了
6.asda,;阿克苏达
5.马上打多少吗

b.txt文本中
变成
1.Adam什么的
2.啊看到了
3.爱迪生，啊啊大
4.哈哈哈手机单
5.马上打多少吗
6.asda,;阿克苏达

package iotest.bufferedIOtest;

import java.io.*;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

public class SortText {
    public static void main(String[] args) throws IOException {
        HashMap<Integer,String> hashMap = new HashMap<Integer, String>();
        FileReader fr = new FileReader("src\\iotest\\bufferedIOtest\\a.txt");
        FileWriter fw = new FileWriter("src\\iotest\\bufferedIOtest\\b.txt");
        BufferedReader br = new BufferedReader(fr);
        BufferedWriter bw = new BufferedWriter(fw);
        //按行来读取文件
        String line = null;
        while ((line = br.readLine()) != null){
            //每行将string按.分割,存储到hashmap中,注意.为转义字符，需要用\\变为普通的.
            String[] split = line.split("\\.");
            hashMap.put(Integer.valueOf(split[0]),split[1]);

        }

        //对hashmap按key进行排序,hashmap会自动排好序，这儿为手动排序
       /* Iterator iter = hashMap.entrySet().iterator();
        while (iter.hasNext()) {
            Map.Entry entry = (Map.Entry) iter.next();
            Object key = entry.getKey();
            Object val = entry.getValue();
        }*/

        //按key遍历hashmap，将key和value拼接成完整的一行，写入文件中
       for(Integer key:hashMap.keySet()){
           bw.write(key+"."+hashMap.get(key));
           bw.newLine();//换行
       }

        bw.close();
        br.close();

    }
}