java 缓冲流 Buffer

缓冲流 Buffer ：设置缓冲区加快执行效率

子类：

　（一）BufferedInputStream : 缓冲输入字节流 ，目的:提高读取文件的效率
　　 注意： BufferedInputStream 他是没有读写数据的功能
　　内部实现 ： 你面维护了一个8字节的byte数组。
　　使用步骤:
        1.找到一个目标文件.
        2.建立通道 new FileInputStream（" "）;
        3.创建一个缓冲字节输入流  new BufferedInputStream(FileInputStream);
        4.读取数据 read();
        5.关闭资源 close();

　（二）BufferedOutputStream :缓冲输出字节流    内部维护了一个 8k的字节数组
　　作用： 提高文件的输出的效率，可以提供其他的方法。
　　使用：
 　　 1.找目标
 　　 2.建立通道 FileOutputStream
 　　 3.创建一个缓冲字节输出流
 　　 4.写数据，不会写入到磁盘中。  如果数组中的数据已经满了，才会自动将数据写入到磁盘中。
  　　5.将数据写入到磁盘 ： 调用flush()，或者关闭资源。
 　　 6.关闭资源。

　（三）BuffredRead 缓冲输入字符流。
    　　 有一个扩展的功能：readLine（）; // 可以一次读一行文字。

　（四）BufferedWriter: 缓冲输出字符流
          内部提供一个8192长度的字符数组作为这样一个缓冲区。
   　　 BufferedWriter作用 ：提高写入的效率，拓展FileWriter的功能。

　　　 newLine();  //换行写入数据

简单的字节缓冲流案例

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

 public class buffered {

     /**
      * @param args
      * @throws IOException
      */
     public static void main(String[] args) throws IOException {
         // TODO Auto-generated method stub
         //bufInTest();
         bufOutTest();
     }

     //（1）BufferedInputStream  的使用
     public static void bufInTest() throws IOException{
         //1.找到目标
         File file = new File("D:\\a.txt");
         //2.创建通道
         FileInputStream fis = new FileInputStream(file);

         //**3.创建一个缓冲输入字节流******
         BufferedInputStream bfis = new BufferedInputStream(fis);

         //4.开始写入数据
          int content = 0; // 一次只会取一个字节
         while ((content= bfis.read())!= -1) { // 还是一个一个的读取 问什么可以提高效率呢?
             System.out.print((char)content);
         }
         //5.关闭通道
         bfis.close();
     }

     //（2）BufferedOutputStream   的使用
     public static void bufOutTest() throws IOException{

         //1.找目标
         File file = new File("D:\\b.txt");
         //2.创建通道
         FileOutputStream fos = new FileOutputStream(file);

         //3.创建缓冲流
         BufferedOutputStream bfos = new BufferedOutputStream(fos);

         //4.创建写入文件的数据
         String string  = "good good study day day up";

         //5.写数据, 到这一步只是将数据保存到内存中字节数组中。
         bfos.write(string.getBytes()); 

         //6.再刷新 将数据写入到磁盘中
         //bfos.flush();

         //7.关闭资源
         bfos.close();//内部会实现flush();
     }
 }

简单的字符缓冲流案例

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

 public class fileReader {

     public static void main(String[] args) throws IOException {
         testBufferedWriter();
         testBufferedRead();
     }
         //（1）缓冲输出字符流的使用
     public static void testBufferedWriter() throws IOException{

         //1.建立一个通道，指定一个路径
         FileWriter fiw = new FileWriter("D:\\a.txt",true);

         //2.创建缓冲流
         BufferedWriter bfw = new BufferedWriter(fiw);

         //让数据换行显示
         bfw.newLine();  //换行写入数据

         //3.开始写入数据
         bfw.write("上课不要吃东西");

         //4.关闭资源
         bfw.close(); // 关闭资源之前会做一个刷新操作。调用flush()方法。
     }

     //（2）缓冲输入字符流的使用
     public static void testBufferedRead() throws IOException{

         //1.创建通道并且指定路径
         FileReader fir = new FileReader("D:\\b.txt");

         //2.创建缓冲流
         BufferedReader bfr = new BufferedReader(fir);

         //3.1、开始读取数据（一次读取一个字节）
         int content = 0;
         while ((content = bfr.read()) != -1) {

             System.out.print((char)content);
         }

         //3.2、readLine（）扩展功能，读取一行数据
         String string1 = bfr.readLine();
         System.out.println(string1);

         //一次读取一行数据（返回字符串），效率更高
         String string = null;
         while ((string = bfr.readLine()) != null) {
             System.out.println(string);
         }

         //4.关闭
         bfr.close();
     }
 }