文件的递归查找、文件复制、文件夹复制的工具包

import java.io.File;
import java.io.FileFilter;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @author Tangwei
 * 
 */
public class FileUtils {

    /**
     * 重载方法(一参) --> 递归文件 , 过滤文件
     * 
     * @param dir
     * @return
     */
    public static List<File> getAllFiles(String dir) {
        // dir 文件路径
        return getAllFiles(new File(dir));
    }

    /**
     * 重载方法 --> 递归文件 , 过滤文件
     * 
     * @param file
     * @return (二参)
     */
    public static List<File> getAllFiles(File dir) {
        return getAllFiles(dir, null);
    }

    /**
     * 重载方法 (二参) --> 递归文件 , 过滤文件
     * 
     * @param dir
     * @param object
     * @return
     */
    // dir 文件路径 suffixs 后缀 (过滤使用)
    public static List<File> getAllFiles(File dir, String[] suffixs) {
        // list数组，存储文件
        List<File> files = new ArrayList<File>();
        if (dir.isDirectory()) {// 如果是文件夹
            // 递归遍历 files --> 文件
            recursionFiles(dir, files, suffixs);
        } else {
            // 如果不是文件夹，直接添加 return 返回
            files.add(dir);
        }
        return files;
    }

    private static void recursionFiles(File dir, List<File> list,
            String[] suffixs) { // listFiles 文件清单
        File[] filesList = dir.listFiles(new FileFilter() {

            @Override
            // 文件过滤器 (白名单)
            public boolean accept(File pathname) {
                if (suffixs == null) // 不过滤
                    return true;
                // 如果是文件夹，不过滤
                if (pathname.isDirectory())
                    return true;
                // 如果后缀符合规范，不过滤
                for (String suffix : suffixs) {
                    if (pathname.getName().endsWith(suffix)) {
                        return true;
                    }
                }
                // 如果不是文件，也不在我的后缀表中，过滤掉
                return false;
            }
        });
        // 如果文件为空，返回
        if (filesList == null)
            return;
        for (File file : filesList) {
            if (file.isDirectory()) {
                // 不要忘了，将dir改成file，不然递归永远不会结束
                recursionFiles(file, list, suffixs);// 该方法先压入栈。执行第二次
            }
            // 如果后缀不为空
            if (suffixs != null) {
                // 如果是文件
                if (file.isFile()) {
                    list.add(file);
                }
            } else {
                list.add(file);
            }
        }
    }

    /**
     * 重载方法 --> copy文件
     * 
     * @param src
     * @param dest
     * @throws IOException
     */
    public static void copyFile(String src, String dest) throws IOException {
        copyFile(new File(src), new File(dest));
    }

    // src 源文件路径 dest 目标文件路径 (复制)
    public static void copyFile(File src, File dest) throws IOException {
        // 复制都使用字节流
        if (src.isDirectory()) {
            throw new IllegalArgumentException("源文件是一个文件夹，请调用copyDir方法");
        }
        // 给目标文件创建父路径名 。 mkdirs-->创建文件夹
        dest.getParentFile().mkdirs();
        FileInputStream fis = new FileInputStream(src);
        FileOutputStream fos = new FileOutputStream(dest);
        // 开始读写
        int len = 0;
        byte[] buf = new byte[1024];
        while ((len = fis.read(buf)) != -1) {
            fos.write(buf, 0, len);
            fos.flush();
        }
        fos.close();
        fis.close();
    }

    /**
     * 重载方法 --> copy文件夹
     * 
     * @param src
     * @param dest
     */
    public static void copyDir(String src, String dest,String[] suffixs) {
        copyDir(new File(src), new File(dest),suffixs);
    }

    public static void copyDir(File src, File dest, String[] suffixs) {
        // 目标文件夹 不允许是 源文件件 的子文件
        // getAbsolutePath 绝对路径
        if (dest.getAbsolutePath().toLowerCase()
                .contains(src.getAbsolutePath().toLowerCase())) {
            throw new IllegalArgumentException("目标文件夹是源文件夹的子文件，不允许复制");
        } else if (src.isFile()) {
            throw new IllegalArgumentException("源文件是一个文件，请调用copyFile的方法");
        } else if (!src.exists()) {
            throw new IllegalArgumentException("源文件夹不存在，请确定后再调用");
        }
        // 给目标文件创建文件夹
        dest.mkdirs();
        // 开始copy,为每一个copy的文件，创建一个线程来操作，使用线程池来管理需要copy的所有线程
        // 1. 将所有文件全部找到
        ExecutorService newFixedThreadPool = Executors.newFixedThreadPool(8);// 创建固定线程池
        List<File> allFiles = getAllFiles(src,suffixs);// 调用递归文件方法
        for (File file : allFiles) { //file
            if (file.isFile()) {
                // 目标文件名 = 源文件名，去将源文件夹src替换成目标文件夹dest
                String fileName = file.getAbsolutePath().replace(
                        src.getAbsolutePath(), dest.getAbsolutePath());
                newFixedThreadPool.execute(new Runnable() { // 启动线程

                            @Override
                            public void run() {
                                // copyFile
                                System.out.println(Thread.currentThread()
                                        .getName()
                                        + ":复制"
                                        + file.getAbsolutePath()
                                        + "到"
                                        + fileName);
                                try {
                                    copyFile(file, new File(fileName));// fileName
                                } catch (IOException e) {
                                    e.printStackTrace();
                                }
                            }
                        });
            }
        }
        // 不在接受新的任务，以前的任务继续执行完毕
        newFixedThreadPool.shutdown(); // 停止线程
    }
　　　　
　

　　　　//文件夹复制与文件的复制 区别在于：各个文件对应其文件夹路径的复制，然后只需要list装载，foreach遍历

//    public static void main(String[] args) {
//        copyDir("C:\\Users\\Windows\\Desktop\\Android", "d:\\abc\\ccc",new String[]{".java"});
//    }
    
}