分享知識 傳遞快樂

檔案操作工具實作類（接口方式）

package rename;

import java.io.IOException;
import java.util.ArrayList;

/**
 * <pre>
 *  
 * 檔案操作工具實作類： 
 *      1.複制單個檔案 
 *      2.複制檔案夾(包括裡邊的檔案) 
 *      3.删除單個檔案 
 *      4.删除檔案夾(包括裡邊的檔案) 
 *      5.重名單個檔案 
 *      6.重命名檔案夾中相同類型的檔案格式：XXX_1.jpg、XXX_2.jpg、XXX_3.jpg 
 *      7.剪切單個檔案到指定檔案夾 
 *      8.剪切檔案夾到指定檔案夾(包含裡邊的檔案) 
 *      9.指定檔案夾下指定類型檔案統計數量(包含裡邊檔案夾下的符合條件檔案)，并傳回每個符合條件的檔案的絕對路徑字元串ArrayList 
 *      10.指定目錄下查找符合條件的檔案，并傳回包含符合條件的檔案絕對路徑字元串ArrayList
 * </pre>
 * 
 * 
 */

public interface FilesOperationInterface {

  /**
   * 1.複制單個檔案 <br>
   * 2.複制檔案夾(包括裡邊的檔案)
   * 
   * @param sorFile
   *            需要複制的檔案或檔案夾絕對路徑
   * @param toFile
   *            目标檔案夾絕對路徑
   * @return <br>
   *         boolean true 複制成功 false 複制失敗
   */
  public abstract boolean copyFils(String sorFile, String toFile) throws IOException;

  /**
   * 3.删除單個檔案 <br>
   * 4.删除檔案夾(包括裡邊的檔案)
   * 
   * @param delFile
   *            需要删除的檔案絕對路徑或檔案夾絕對路徑
   * @return <br>
   *         boolean true 删除成功 false 删除失敗
   */
  public abstract boolean deleteFiles(String delFile) throws IOException;

  /**
   * 5.重名單個檔案
   * 
   * @param oldFile
   *            需要重命名的檔案絕對路徑
   * @param newName
   *            新的檔案名
   * @return <br>
   *         boolean true 重命名成功 false 重命名失敗
   */
  public abstract boolean renameFile(String oldFile, String newName) throws IOException;

  /**
   * 6.重命名檔案夾中相同類型的檔案格式：XXX_1.jpg、XXX_2.jpg、XXX_3.jpg
   * 
   * @param files
   *            檔案所在的檔案夾絕對路徑
   * @param type
   *            指定類型的檔案
   * @param name
   *            指定檔案名的前一部分
   * @return <br>
   *         boolean true 重命名成功 false 重命名失敗
   */
  public abstract boolean renameFile(String files, String type, String name) throws IOException;

  /**
   * 7.剪切單個檔案到指定檔案夾 <br>
   * 8.剪切檔案夾到指定檔案夾(包含裡邊的檔案)
   * 
   * @param file
   *            需要剪切的檔案或檔案夾所在絕對路徑
   * @param toFiles
   *            剪切到的檔案夾絕對路徑
   * @return <br>
   *         boolean true 剪切成功 false 剪切失敗
   */
  public abstract boolean clipFile(String file, String toFiles) throws IOException;

  /**
   * 9.指定檔案夾下指定類型檔案統計數量(包含裡邊檔案夾下的符合條件檔案)，并傳回每個符合條件的檔案的絕對路徑字元串ArrayList
   * 
   * @param findFiles
   *            查找的目錄絕對路徑
   * @param type
   *            查找的檔案類型 格式：.jpg、.exe(不區分大小寫)
   * @return <br>
   *         ArrayList<String> 傳回所有符合條件的檔案絕對路徑的字元串ArrayList<br>
   *         注意：傳回值ArrayList<String>對象的xX.get(0)是統計的數量，即就是第一個存儲的是統計結果
   */
  public abstract ArrayList<String> findFileType(String findFiles, String type) throws IOException;

  /**
   * 10.指定目錄下查找符合條件的檔案，并傳回包含符合條件的檔案絕對路徑字元串ArrayList
   * 
   * @param findFiles
   *            查找的目錄絕對路徑
   * @param file
   *            查找的檔案名，可以是一部分也可以全名
   * @return <br>
   *         ArrayList<String> <br>
   *         傳回所有符合條件的檔案絕對路徑的字元串ArrayList
   */
  public abstract ArrayList<String> findFile(String findFiles, String file) throws IOException;
}      

package rename;

import java.io.File;
import java.io.FileFilter;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;

/**
 * <pre>
 *  
 * 檔案操作工具實作類： 
 *      1.複制單個檔案 
 *      2.複制檔案夾(包括裡邊的檔案) 
 *      3.删除單個檔案 
 *      4.删除檔案夾(包括裡邊的檔案) 
 *      5.重名單個檔案 
 *      6.重命名檔案夾中相同類型的檔案格式：XXX_1.jpg、XXX_2.jpg、XXX_3.jpg 
 *      7.剪切單個檔案到指定檔案夾 
 *      8.剪切檔案夾到指定檔案夾(包含裡邊的檔案) 
 *      9.指定檔案夾下指定類型檔案統計數量(包含裡邊檔案夾下的符合條件檔案)，并傳回每個符合條件的檔案的絕對路徑字元串ArrayList 
 *      10.指定目錄下查找符合條件的檔案，并傳回包含符合條件的檔案絕對路徑字元串ArrayList
 * </pre>
 * 
 */

public class FilesOperationTools implements FilesOperationInterface {

  // 建立ArrayList對象儲存數量及查找到的路徑
  private static ArrayList<String> list = null;
  // 建立intb變量儲存查找數量
  private int sum = 0;

  public FilesOperationTools() {
    super();
    list = new ArrayList<>();
    list.add(0, "-1");
  }

  @Override
  public boolean copyFils(String sorFile, String toFile) throws IOException {
    // 定義傳回值變量
    boolean flag = false;
    // 封裝字元路徑為File對象
    File sorfile = new File(sorFile);
    File tofile = new File(toFile);
    // 聲明位元組流
    FileInputStream fileInputStream = null;
    FileOutputStream fileOutputStream = null;
    if (sorfile.isFile()) {
      // 建立FileInputStream位元組流讀取檔案對象
      fileInputStream = new FileInputStream(sorfile);
      // 建立FileOutputStream位元組流寫入檔案對象
      File temp = new File(tofile.getAbsolutePath().concat(File.separator).concat(sorfile.getName()));
      fileOutputStream = new FileOutputStream(temp);
      // 定義位元組數組變量，每次都讀進位元組數組
      byte[] by = new byte[1024 * 1000 * 2];
      // 定義每次真實讀取到的位元組長度變量
      int len = 0;
      // 循環複制檔案
      while ((len = fileInputStream.read(by)) != -1) {
        fileOutputStream.write(by, 0, len);
      }
      // 關閉流
      fileInputStream.close();
      fileOutputStream.close();
      // 如果源檔案長度等于複制後的檔案長度，則設定傳回變量 true
      return true;
    } else {
      // 擷取源檔案夾下的所有檔案包含檔案夾的File清單
      File[] files = sorfile.listFiles();
      // 判斷是否擷取到的List對象為null,null說明是特殊檔案或沒權限通路
      if (files != null) {
        // 拼接新的檔案夾路徑并建立
        File temp = new File(tofile.getAbsolutePath().concat(File.separator).concat(sorfile.getName()));
        temp.mkdir();
        // 循環調用方法本身
        for (File file : files) {
          flag = copyFils(file.getAbsolutePath(), temp.getAbsolutePath());
        }
      } else {
        System.out.println("檔案夾下有特殊檔案夾！可能是隐藏的垃圾桶檔案。 " + sorfile.getAbsolutePath());
      }
    }
    return flag;
  }

  @Override
  public boolean deleteFiles(String delFile) throws IOException {
    // 定義傳回值标志
    boolean flag = false;
    // 封裝字元串路徑為File對象
    File delfile = new File(delFile);
    // 判斷是否為檔案，若是則直接删除
    if (delfile.isFile()) {
      return delfile.delete();
    } else {
      // 不是檔案，則擷取目前檔案夾下所有檔案組成的File對象
      File[] files = delfile.listFiles();
      // 判斷是否null,null則是特殊檔案夾
      if (files != null) {
        // 循環調用方法自己
        for (File file : files) {
          flag = deleteFiles(file.getAbsolutePath());
        }
        // 目前檔案夾下的檔案删完後，删除目前檔案夾
        delfile.delete();
      } else {
        System.out.println("檔案夾下有特殊檔案夾！可能是隐藏的垃圾桶檔案，不能删除！ " + delfile.getAbsolutePath());
      }
    }
    return flag;
  }

  @Override
  public boolean renameFile(String oldFile, String newName) throws IOException {
    // 定義傳回值标志
    boolean flag = false;
    // 封裝字元創路徑為File對象
    File oldfile = new File(oldFile);
    File newfile = new File(oldfile.getParent().concat(File.separator).concat(newName));
    if (oldfile.isFile()) {
      flag = oldfile.renameTo(newfile);
    } else {
      System.out.println("指定的檔案絕對路徑有誤！ " + oldFile);
    }
    return flag;
  }

  @Override
  public boolean renameFile(String files, String type, String name) throws IOException {
    // 傳回值标志
    boolean flag = false;
    // 傳進來的類型檔案名變量轉為常量，不然之後的匿名問價過濾内部類不能使用
    final String typ = type.contains(".") ? type : ".".concat(type);
    // 封裝路徑為File對象
    File file = new File(files);
    // 擷取檔案夾下所有符合條件的檔案數組
    File[] fil = file.listFiles(new FileFilter() {
      @Override
      public boolean accept(File path) {
        return path.isFile() && path.getName().toLowerCase().endsWith((typ.toLowerCase()));
      }
    });
    int i = 1;
    for (File fi : fil) {
      flag = fi.renameTo(new File(fi.getParent().concat(File.separator).concat(name).concat("_") + (i++) + typ));
    }
    return flag;
  }

  @Override
  public boolean clipFile(String file, String toFiles) throws IOException {
    boolean flag = false;
    // 封裝目錄
    File sfile = new File(file);
    File tofile = new File(toFiles);
    // 判斷需要剪切的是否單個檔案
    if (sfile.isFile()) {
      flag = sfile.renameTo(new File(toFiles.concat(File.separator).concat(sfile.getName())));
    } else {
      // 調用本類中的複制檔案方法
      flag = copyFils(sfile.getAbsolutePath(), tofile.getAbsolutePath());
      if (flag) {
        // 檔案夾複制完成後，删除原檔案夾
        flag = deleteFiles(sfile.getAbsolutePath());
      }
    }
    return flag;
  }

  @Override
  public ArrayList<String> findFileType(String findFiles, String type) throws IOException {
    // 類型type字元串轉為常量，便于匿名内部類使用
    final String typ = type.contains(".") ? type : ".".concat(type);
    // 封裝查找的目錄為File對象
    File findfiles = new File(findFiles);
    // 擷取目前目錄下File數組
    File[] findfile = findfiles.listFiles();
    if (findfiles != null) {
      for (File find : findfile) {
        if (find.isDirectory()) {
          findFileType(find.getAbsolutePath(), typ);
        } else {
          if (find.getName().toLowerCase().endsWith(typ.toLowerCase())) {
            list.add(find.getAbsolutePath());
            sum++;
          }
        }
      }
    }
    list.set(0, String.valueOf(sum));
    return list;
  }

  @Override
  public ArrayList<String> findFile(String findFiles, String file) throws IOException {
    // 封裝路徑
    File findfiles = new File(findFiles);
    // 判斷是否查找指定類型的
    if ("*.".equals(file.substring(0, 2))) {
      // 調用上邊查找指定類型的方法
      findFileType(findFiles, file.substring(1));
    } else {
      // 調用分離出去的方法
      getFile(findfiles, file);
    }
    // 移除索引是0的元素
    list.remove(0);
    return list;
  }

  // findFile(String findFiles, String file)方法，當查找的是包含某個字元串是，分離便于遞歸調用<br>
  private void getFile(File findFiles, String file) {
    File[] files = findFiles.listFiles();
    if (files != null) {
      for (File f : files) {
        if (f.isFile() && f.getName().toLowerCase().contains(file.toLowerCase())) {
          list.add(f.getAbsolutePath());
        } else {
          if (f.getName().toLowerCase().contains(file.toLowerCase())) {
            list.add(f.getAbsolutePath());
          }
          getFile(f, file);
        }
      }
    }
  }
}      

package rename;

import java.io.IOException;
import java.util.ArrayList;

/**
 * 
 * @author Hyang
 * @date 2017年1月22日
 */
public class FileToolsTest {
     /** 
     * FilesOperationTools 測試類 
     *  
     * @param args 
     * @throws IOException 
     */  
    public static void main(String[] args) throws IOException {  
        // File file=new File("D:\\temp\\123\\金貴晟 - 虹之間.mp3");  
        // System.out.println(file.getParent());  
  
        // 建立FilesOperationTools對象  
        FilesOperationTools fileOperation = new FilesOperationTools();  
        boolean f = false;  
        // 測試複制單個檔案  
        // f = fileOperation.copyFils(  
        // "C:\\Users\\kaifang\\Desktop\\oracle.txt", "D:\\");  
        // f = fileOperation.copyFils("F:\\喜歡的音樂\\白夜.mp3", "D:\\temp");  
        // 測試複制檔案夾包含所有檔案  
        // f = fileOperation.copyFils("F:\\123", "D:\\temp");  
        // if (f) {  
        // System.out.println("複制完成！\n");  
        // }  
  
        // 測試删除單個檔案  
        // f = fileOperation.deleteFiles("D:\\temp\\123\\金貴晟 - 虹之間.mp3");  
        // 測試删除檔案  
        // f = fileOperation.deleteFiles("D:\\temp\\123");  
        // if (f) {  
        // System.out.println("删除完成！");  
        // }  
  
        // 測試重命名單個檔案  
        // f = fileOperation.renameFile("D:\\temp\\123\\金貴晟 - 虹之間.mp3",  
        // "123.mp3");  
        // if (f) {  
        // System.out.println("重命名完畢！");  
        // }  
  
        // 測試重命名同種類型的檔案  
        // f = fileOperation.renameFile("D:\\temp", "Mp3", "");  
        // if (f) {  
        // System.out.println("多個檔案重命名完成！");  
        // }  
  
        // 測試查找指定類型的檔案  
        // ArrayList<String> list = fileOperation.findFileType("D:\\temp",  
        // "Mp3");  
        // System.out.println("mp3數量：" + list.get(0));  
        // for (int i = 1; i < list.size(); i++) {  
        // System.out.println(list.get(i));  
        // }  
  
        // 測試剪切單個檔案  
        // f = fileOperation.clipFile("F:\\123\\金貴晟 - 虹之間.mp3", "D:\\temp");  
        // 測試剪切整個檔案夾  
        // f = fileOperation.clipFile("F:\\123", "D:\\temp");  
        // if (f) {  
        // System.out.println("剪切成功！");  
        // }  
  
        // 測試查找指定類型檔案  
        ArrayList<String> lis = fileOperation.findFile("D:\\temp", "*.mp3");  
        // 測試查找包含指定字元的檔案  
//      ArrayList<String> lis = fileOperation.findFile("D:\\temp", "mp3");  
        System.out.println(lis);  
    }  
}