Java實現對於文件的多種操作，複製、刪除、重命名、剪切文件、統計指定類型文件數等10個功能

代碼實現了：

文件操作工具實現類：
1.複製單個文件 2.複製文件夾(包括裏邊的文件)
3.刪除單個文件
4.刪除文件夾(包括裏邊的文件)
5.重名單個文件
6.重命名文件夾中相同類型的文件格式：XXX_1.jpg、XXX_2.jpg、XXX_3.jpg
7.剪切單個文件到指定文件夾
8.剪切文件夾到指定文件夾(包含裏邊的文件)
9.指定文件夾下指定類型文件統計數量(包含裏邊文件夾下的符合條件文件)，並返回每個符合條件的文件的絕對路徑字符串ArrayList
10.指定目錄下查找符合條件的文件，並返回包含符合條件的文件絕對路徑字符串ArrayList

代碼分爲連個類，一個接口類，一個實現類，可以直接調用實現類的方法進行相關的操作，複製不足之處就是使用了文件字節流，並沒有使用緩衝字節流，需要的可以自己修改，這個也很簡單，雖然沒有使用緩衝流但碼中也是有緩衝的，就是讀取到2M的數據後才輸出到文件的。

方法中的剪切文件夾，是首先調用了自己的複製文件夾方法，完後調用刪除文件夾方法，統計指定類型文件數量使用的是ArrayList存儲，第0個即是數量後邊存儲的是查找到的每個符合的文件絕對路徑。

請看代碼：

文件操作類接口：

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>
 * 
 * 2014-04-03
 * 
 * <pre>
 * @author kaifang
 * @version 1.0
 * </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;
}

實現類：

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>
 * 
 * 2014-04-03
 * 
 * <pre>
 * @author kaifang
 * @version 1.0
 * </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);
				}
			}
		}
	}
}

測試類：

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

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);
	}
}

歡迎交流技術，^0^