文件操作工具实现类（接口方式）_文件系统接口文件操作方法-优快云博客

本文链接：https://blog.youkuaiyun.com/xhaimail/article/details/79465061

本文介绍了一个文件操作工具类，提供了复制、删除、重命名、剪切文件及文件夹的功能，并能统计指定类型文件的数量和查找特定文件。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

分享知识传递快乐

文件操作工具实现类（接口方式）

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