JavaIO流中的拷貝

　　JavaIO流中對數據的操作尤為重要，掌握了基本的拷貝操作，才能將各種數據源的操作聯系起來。

　　先來看看對文件夾的拷貝吧：

/**
 * 利用遞歸實現文件夾的拷貝操作
 * 分析：判斷
 *     是文件：調用拷貝文件的方法fileCopy(...)
 *     是文件夾：創建文件夾，並使用遞歸實現子文件夾/子文件的判斷及操作
 * @param src：要拷貝的文件夾源頭
 * @param dest：要拷貝到的文件夾源頭
 */
public static void dirCopy(File src,File dest) {
    if(src.isFile()) { //是文件
        fileCopy(src, dest);
    }else { //是文件夾
        dest.mkdirs();
        for(File subSrc:src.listFiles()) { //遍歷子文件夾/子文件
            dirCopy(subSrc, new File(dest,subSrc.getName()));
        }
    }
}

　　對文件的拷貝，我們可以這樣寫：

/**
 * 實現文件的拷貝
 *     輸入流讀取的同時輸出流進行寫出
 * @param src：要拷貝的文件源頭
 * @param dest：要拷貝到的文件源頭
 */
public static void fileCopy(File src,File dest) {
    //1.創建源
    //2.選擇流
    InputStream is = null;
    OutputStream os = null;
    try {
        is = new FileInputStream(src);
        os = new FileOutputStream(dest);
        //3.操作：分段讀取並寫出
        int len; //接收長度
        byte[] flush = new byte[1024]; //緩沖容器，一次讀寫1k
        while((len=is.read(flush))!=-1) {
            os.write(flush, 0, len);
        }
        os.flush(); //寫完手動刷新，避免數據在緩沖容器中（當然當流關閉時會自動刷新）
    }catch(FileNotFoundException e) {
        e.printStackTrace();
    }catch(IOException e) {
        e.printStackTrace();
    }finally {
        //4.關閉流，分別關閉，先打開的后關閉
        try {
            if(os!=null) {    //判斷是否為空，避免空指針異常
                os.close();
            }
        }catch(IOException e) {
            e.printStackTrace();
        }
        try {
            if(is!=null) { //判斷是否為空，避免空指針異常
                is.close();
            }
        }catch(IOException e) {
            e.printStackTrace();
        }
    }
}

　　以上代碼只能實現對文件的拷貝操作，當然適合於拷貝任何格式的數據文件，包括視頻、音頻、圖片等等。但是如果我想將一張圖片拷貝到字節數組中呢（這里的字節數組相當於內存），也就是說從文件到字節數組，或着是從字節數組到文件。那么以上代碼就具有局限性了，也不易於擴展，來看以下代碼：

/**
 * 對接流
 * @param is：輸入流
 * @param os：輸出流
 */
public static void copy(InputStream is,OutputStream os) {
    //1.創建源
    //2.選擇流
    try {
        //3.操作
        byte[] flush = new byte[1024]; //緩沖容器
        int len; //接收長度
        while((len=is.read(flush))!=-1) {
            os.write(flush, 0, len);
        }
        os.flush();
    }catch(FileNotFoundException e) {
        e.printStackTrace();
    }catch(IOException e) {
        e.printStackTrace();
    }finally {
        try {
            if(os!=null) {
                os.close();
            }
        }catch(IOException e) {
            e.printStackTrace();
        }
        try {
            if(is!=null) {
                is.close();
            }
        }catch(IOException e) {
            e.printStackTrace();
        }
    }
}

　　嗯，這樣就可以實現以上要求了，但是我們發現：關閉資源的操作一直在，而且都一樣，我們可以封裝一下，這樣在finally中就可以直接調用了。

/**
 * 關閉的方法
 * @param is：輸入流
 * @param os：輸出流
 */
public static void close(InputStream is,OutputStream os) {
    try {
        if(os!=null) {
            os.close();
        }
    }catch(IOException e) {
        e.printStackTrace();
    }
    try {
        if(is!=null) {
            is.close();
        }
    }catch(IOException e) {
        e.printStackTrace();
    }
}

　　好了，看看封裝的代碼，幸虧只有兩個流，要是流很多咋辦，形參太多，但是我們發現輸入流InputStream和輸出流OutputStream都實現了同一個接口：Closeable。嗯，這樣，我們可以試試JDK1.5的新特性：可變參數。

/**
 * 封裝的關閉方法
 * @param ios：要關閉的流
 */
public static void close(Closeable... ios) {
    for(Closeable io:ios) {
        try {
            if(io!=null) {
                io.close();
            }
        }catch(IOException e) {
            e.printStackTrace();
        }
    }
}

　　現在看似完美了，但我還不太滿意，有時候，我覺得手動關閉資源太麻煩了。別急，來看看JDK1.7的新特性：try...with...resources(自動關閉資源)。

/**
 * JDK1.7之后的新特性 try...with...resources:自動關閉資源
 * 文件的拷貝
 * @param srcPath：要拷貝的源頭
 * @param destPath：要拷貝到的目的地
 */
public static void copy1(String srcPath,String destPath) {
    //1.創建源
    File src = new File(srcPath);
    File dest = new File(destPath);
    //2.選擇流
    try(InputStream is = new FileInputStream(src);
        OutputStream os = new FileOutputStream(dest)) {
        //3.操作
        byte[] flush = new byte[1024]; //緩沖容器
        int len; //接收長度
        while((len=is.read(flush))!=-1) {
            os.write(flush, 0, len);
        }
        os.flush();
    }catch(FileNotFoundException e) {
        e.printStackTrace();
    }catch(IOException e) {
        e.printStackTrace();
    }
}

　　大家發現：try里面寫的好繁瑣，別急，看看JDK1.9的改進版（不過要求你所要關閉的資源是final或等效於final的變量）。

/**
 * JDK1.9之后對 try...with...resources的改進
 * 對接流
 * @param is：輸入流
 * @param os：輸出流
 */
public static void copy2(InputStream is,OutputStream os) {
    //1.創建源
    //2.選擇流
    try(is;os) {
        //3.操作
        byte[] flush = new byte[1024]; //緩沖容器
        int len; //接收長度
        while((len=is.read(flush))!=-1) {
            os.write(flush, 0, len);
        }
        os.flush();
    }catch(FileNotFoundException e) {
        e.printStackTrace();
    }catch(IOException e) {
        e.printStackTrace();
    }
}

　　哈哈，看上去是不是簡潔很多。對的，隨着JDK的新版本發布，越來越多的新技術，也使得代碼看起來越簡潔，不過對我們的要求也只會越來越高。前段時間JDK12已經出來了，還沒用，不過我相信肯定會有好多的新特性，期待，也看好Java，加油。