IO流处理文件读取到字节数组，再从字节数组读取到文件，Java实现

 package cn.zhang.io;
 
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 
 /**
  * 文件读取到字节数组，再从字节数组读取到文件
  * 四个步骤
  * 1、创建源
  * 2、选择流
  * 3、操作
  * 4、释放资源
  * @author zhang
  *
  */
 public class IOTest10 {
     public static void main(String[] args) {
         //指定文件源，获得该文件的字节数组
         byte[] datas = fileToByteArray("very_nice_satellite_images_of_iran-wallpaper-2880x1620.jpg");//图片转为字节数组
         byteArrayToFile(datas,"picture.jpg");//字节数组转为图片
     }
 
     /**
      * 1、文件读取到字节数组，以程序为中心
      * 1)、文件到程序：
      *                 源：main方法中
      *                 流：InputStream、FileInputStream
      *                 操作：输入
      *                 释放资源：需要释放
      *          程序到字节数组：
      *                     源：内部维护，自动创建一个字节数组
      *                     流：ByteArrayOutputStream,不能使用多态，使用ByteArrayOutputStream流中的toByteArray方法，返回字节数组
      *                     操作：输出
      *                     释放资源：不需要释放
      * 2)、结果是获得一个字节数组
      * @param filePath
      * @return
      */
     public static byte[] fileToByteArray(String filePath) {
         //创建源与目的地
         File src = new File(filePath);//获得文件的源头，从哪开始传入(源)
         byte[] dest = null;//最后在内存中形成的字节数组(目的地)
         //选择流
         InputStream is = null;//此流是文件到程序的输入流
         ByteArrayOutputStream baos= null;//此流是程序到新文件的输出流
         //操作(输入操作)
         try {
             is = new FileInputStream(src);//文件输入流
             baos = new ByteArrayOutputStream();//字节输出流，不需要指定文件，内存中存在
             byte[] flush = new byte[1024*10];//设置缓冲，这样便于传输，大大提高传输效率
             int len = -1;//设置每次传输的个数,若没有缓冲的数据大，则返回剩下的数据，没有数据返回-1
             while((len = is.read(flush)) != -1) {
                 baos.write(flush,0,len);//每次读取len长度数据后，将其写出
             }
             baos.flush();//刷新管道数据
             dest = baos.toByteArray();//最终获得的字节数组
             return dest;//返回baos在内存中所形成的字节数组
         } catch (FileNotFoundException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         }finally {
             //释放资源,文件需要关闭,字节数组流无需关闭
             if(null != is) {
                 try {
                     is.close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
 
         }
         return null;
     }
 
     /**
       * 字节数组写出到新的文件
      *1、字节数组读入程序中
      *                    源：传入的字节数组
      *                    流：ByteInputStream
      *                    操作：读入
      *                    释放资源：不需要
      *2、程序写出到新的文件中
      *                    源：传入的新文件目的地
      *                    流：OutputStream FileOutputStream
      *                    操作：写出
      *                    释放资源：需要
      * @param src
      * @param filePath
      */
     public static void byteArrayToFile(byte[] src,String filePath) {
         //创建源
         File dest = new File(filePath);//目的地，新文件
         //src字节数组已经存在
         //选择流
         InputStream is = null;//ByteArrayInputStream的父类
         OutputStream os = null;
         //操作
         try {
             is = new ByteArrayInputStream(src);//字节数组与程序之间的管道
             os = new FileOutputStream(dest);//程序与新文件之间的管道
             //一样的字节数组缓冲操作
             byte[] flush = new byte[1024*10];
             int len = -1;
                 while((len = is.read(flush)) != -1) {
                     os.write(flush,0,len);
                 }
                 os.flush();
         } catch (FileNotFoundException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         }finally {
             if(null != os) {//关闭文件流
                 try {
                     os.close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
         }
     }
 }