Day 15：缓冲输入输出常用方法和小练习

以拷贝图片为例子，演示异常处理的代码：拷贝一张图片

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

public class Demo1 {

   public static void main(String[] args) throws IOException {
    //找到目标文件
   File inFile = new File("C:\Users\Lenovo\Pictures\Camera Roll\1.jpg");
    File destFile = new File("C:\Users\Lenovo\Pictures\Camera Roll\2.jpg");
    //建立数据的输入输出通道
    FileInputStream fileInputStream = new FileInputStream(inFile);
    FileOutputStream fileOutputStream = new FileOutputStream(destFile);
    //每新创建一个FileOutputStream的时候，默认情况下FileOutputStream 的指针是指向了文件的开始的位置。每写出一次，指向都会出现相应移动。
    //建立缓冲数据，边读边写
    byte[] buf = new byte[1024];
    int length = 0 ;
    while((length = fileInputStream.read(buf))!=-1){ //最后一次只剩下了824个字节
     fileOutputStream.write(buf,0,length); //写出很多次数据，所以就必须要追加。
    }
    //关闭资源原则：先开后关，后开先关。
    fileOutputStream.close();
    fileInputStream.close();
}
}

异常处理：关闭执行后面的代码，并将异常抛给调用对象

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

public class Demo1 {
 
      public static void main(String[] args){
          //找到目标文件
          File inFile = new File("C:\Users\Lenovo\Pictures\Camera Roll\1.jpg");
          File destFile = new File("C:\Users\Lenovo\Pictures\Camera Roll\2.jpg");
          //建立数据的输入输出通道
          FileInputStream fileInputStream;
              try {
                fileInputStream = new  FileInputStream(inFile);
            } catch (FileNotFoundException e) {
                throw new RuntimeException(e);
            }
              FileOutputStream fileOutputStream;
            try {
                fileOutputStream = new FileOutputStream(destFile);
            } catch (FileNotFoundException e) {
                throw new RuntimeException(e);
            } 
          //每新创建一个FileOutputStream的时候，默认情况下FileOutputStream 的指针是指向了文件的开始的位置。 每写出一次，指向都会出现相应移动。
          //建立缓冲数据，边读边写
          byte[] buf = new byte[1024]; 
          int length = 0 ; 
          try {
            while((length = fileInputStream.read(buf))!=-1){ //最后一次只剩下了824个字节
                  try {
                    fileOutputStream.write(buf,0,length);
                } catch (IOException e) {
                    throw new RuntimeException(e);
                } //写出很多次数据，所以就必须要追加。
              }
          } catch (IOException e1) {
            // TODO Auto-generated catch block
            throw new RuntimeException(e1);
          }
         finally { //关闭资源 原则： 先开后关，后开先关。
             if(fileOutputStream!=null) {
                  try {
                    fileOutputStream.close();
                    System.out.println("关闭成功");
                  } catch (IOException e) {
                    throw new RuntimeException(e);
                  }
                  try {
                    fileInputStream.close();
                    System.out.println("关闭成功");
                  } catch (IOException e) {
                    throw new RuntimeException(e);
                  }
            }
         }
     }
}

这样做虽然代码更长了，但是可以更好的处理异常使得代码更加灵活

读取文件数据使用缓冲数组读取效率更高，所以缓冲输入字节流对象,让我们可以更高效率读取文件。

输入字节流体系：
　　InputStream 输入字节流的基类是抽象类
　　　　FileInputStream 读取文件数据的输入字节流
　　　　BufferedInputStream 缓冲输入字节流缓冲输入字节流的出现主要是为了提高读取文件数据的效率。
其实该类内部只不过是维护了一个8kb的字节数组而已。

注意：凡是缓冲流都不具备读写文件的能力

使用BufferedInputStream的步骤 :
　　1. 找到目标文件。
　　2. 建立数据的输入通道
　　3. 建立缓冲输入字节流流
　　4. 关闭资源

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 Demo2 {
    
    public static void main(String[] args) throws IOException {
        readTest2();
    }
    
    public static void readTest2() throws IOException{
        File file = new File("F:\a.txt");
        
        FileInputStream fileInputStream= new FileInputStream(file);
        BufferedInputStream bufferedInputStream= new BufferedInputStream(fileInputStream);
        bufferedInputStream.read();
        
        FileOutputStream fileOutputStream= new FileOutputStream(file);
        BufferedOutputStream bufferedOutputStream= new BufferedOutputStream(fileOutputStream);
        fileOutputStream.write(null);
        
        
        int content = 0 ;
        while((content = fileInputStream.read())!=-1){
            System.out.print((char)content);
        }
        
        bufferedInputStream.close();
    }
}

Q：FileInputStream和BufferedInputStream 都一次只读一个字节为什么后者效率会高

A：BufferedInputStream的Read方法维护了一个8kb的缓冲数组，他会一次性读入8kb并且放在内存中，然后再从内存中一个字节一个字节读取，所以快。FileInputStream是从硬盘中一个字节一个字节读取的所以慢

输出字节流
　　OutputStream 所有输出字节流的基类抽象类
　　　　FileOutputStream 向文件输出数据的输出字节流
　　　　Bufferedoutputstream 缓冲输出字节流 BufferedOutputStream出现的目的是为了提高写数据的效率。
　　内部也是维护了一个8kb的字节数组而已。

使用BufferedOutputStream的步骤：
　　 1. 找到目标文件
　　 2. 建立数据的输出通道

BufferedOutputStream 要注意的细节
　　使用BufferedOutStream写数据的时候，它的write方法是是先把数据写到它内部维护的字节数组中，如果需要把数据真正的写到硬盘上面，需要
　调用flush方法或者是close方法、或者是内部维护的字节数组已经填满数据的时候。

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

public class Demo3 {

    public static void main(String[] args) throws IOException {
        
        File file = new File("F:\1.jpg");
        
        FileOutputStream  fileOutputStream = new FileOutputStream(file);
        
        BufferedOutputStream bufferedOutputStream  = new BufferedOutputStream(fileOutputStream);
        
        bufferedOutputStream.write("hello world".getBytes()); 
        
        //bufferedOutputStream.flush();
        bufferedOutputStream.close();
    }
}

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 Demo4 {

    public static void main(String[] args) throws IOException {
        File  inFile = new File("F:\1.jpg");
        File outFile = new File("E:\2.jpg");
        FileInputStream fileInputStream = new FileInputStream(inFile);
        FileOutputStream fileOutputStream = new FileOutputStream(outFile);
        BufferedInputStream bufferedInputStream = new BufferedInputStream(fileInputStream);
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
        int content = 0; 
        while((content = bufferedInputStream.read())!=-1){
            bufferedOutputStream.write(content);
        bufferedInputStream.close();
        bufferedOutputStream.close();    
        }
    }
}