自定义文件工具类,(递归)copy文件,递归遍历目录,递归删除文件,递归查找指定目录下指定关键字文件,递归获取指定后缀文件写入文本

package demo.io;

import java.io.*;
import java.util.ArrayList;

public class FileTool {
    /**
     * 递归遍历指定目录下所有文件
     *
     * @param dir   将要遍历的目录
     * @param level 初始化缩进量，一般为0
     */
    public static void listAll(File dir, int level) {
        if (!dir.isDirectory()) {
            System.out.println("传入参数为非目录，递归遍历目录失败");
            return;
        }
        System.out.println(getSpace(level) + dir.getName());//打印正在遍历目录的名称
        level++;//每进一级目录，缩进增加
        File[] files = dir.listFiles();
        for (File f : files) {
            if (f.isDirectory()) {//如果是文件夹，就继续遍历
                listAll(f, level);
            } else {//如果是文件就打印该路径
                System.out.println(getSpace(level) + f.getAbsolutePath());
            }
        }
    }

    //打印指定空格数
    private static String getSpace(int level) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < level; i++) {
            sb.append("\t");
        }
        return sb.toString();
    }

    /**
     * 递归查找指定目录下指定关键字文件
     * *
     *
     * @param dir     指定目录
     * @param keyword 关键字
     * @param level   //初始化缩进量，一般为0
     */
    public static void findFile(File dir, String keyword, int level) {
        if (!dir.isDirectory()) {
            System.out.println("传入参数为非目录，递归查找指定目录下指定关键字文件失败");
            return;
        }
        File[] files = dir.listFiles(new FilterByKeyword(keyword));//获取指定关键字文件列表
        //遍历该目录下的所有文件和目录
        for (File f : files) {
            if (f.isDirectory()) {//如果是目录就继续遍历
                findFile(f, keyword, level);
            } else { //如果是要找的文件，直接输出
                System.out.println(getSpace(level) + f.getAbsolutePath());
            }
        }
    }

    //copy文件
    public static void copyFile(File file, File newFile) {
        if (!file.isFile()) {
            System.out.println("传入参数为非文件，无法copy");
            return;
        }
        //读取源文件信息
        BufferedInputStream bufi = null;
        //写入新文件信息
        BufferedOutputStream bufo = null;
        try {
            bufi = new BufferedInputStream(new FileInputStream(file));
            bufo = new BufferedOutputStream(new FileOutputStream(newFile));//文件自动创建
            int len = 0;
            byte[] buf = new byte[1024];
            while ((len = bufi.read(buf)) != -1) {
                bufo.write(buf, 0, len);
                bufo.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (bufi != null)
                    bufi.close();
                if (bufo != null)
                    bufo.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    //拷贝目录下所有文件
    public static void copyFileAll(File sourceDir, File destDir) {
        destDir.mkdirs();//创建新目录
        File[] files = sourceDir.listFiles();//获取源目录文件对象列表
        for (File file : files) {//file源目录的最近一级子目录及文件
            if (file.isDirectory()) {//如果是目录就继续遍历
                //根据file传入new dir2子目录地址进行创建     listCopyAll中的两个参数同一水平
                copyFileAll(file, new File(destDir.getAbsolutePath(), file.getName()));//在自身目录上衔接目录
            } else {
                //拷贝文件 在自身目录上衔接文件
                copyFile(file, new File(destDir.getAbsolutePath(), file.getName()));
            }
        }
    }

    //递归剪切文件
    public static void renameToAll(File sourceDir, File destDir) {
        destDir.mkdirs();
        File[] files = sourceDir.listFiles();
        for (File file : files) {
            if (file.isDirectory()) {
                //在自身目录上衔接目录
                renameToAll(file, new File(destDir.getAbsolutePath(), file.getName()));
            } else {
                //在自身目录上衔接文件
                file.renameTo(new File(destDir, file.getName()));
            }
        }
        sourceDir.delete();
    }

    //递归删除文件
    public static void deleteAll(File dir) {
        if (!dir.isDirectory()) {
            System.out.println("传入参数为非目录或者不存在，无法删除");
            return;
        }
        File[] files = dir.listFiles();
        for (File f : files) {
            if (f.isDirectory()) {
                deleteAll(f);
            } else {
                System.out.println(f + ": " + f.delete());//删除该目录下文件
            }
        }
        System.out.println(dir + ": " + dir.delete());//删除该目录
    }

    /**
     * 递归获取指定后缀文件写入文本(简单版见：递归获取指定后缀文件写入文件.java)
     *
     * @param dir    查找指定后缀的目录
     * @param suffix 指定后缀名
     * @param file   写入文本的目的文件
     */
    public static void writeSuffixFile(File dir, String suffix, File file) {
        //定义集合存放指定后缀文件的路径
        ArrayList<String> fileNames = new ArrayList<>();
        //定义指定后缀名过滤器
        FilterBySuffix filter = new FilterBySuffix(suffix);
        //递归将文件路径存入集合
        listAll(dir, fileNames, filter);
        //写入文件
        inputFile(file, fileNames);
    }

    //写入文件
    private static void inputFile(File file, ArrayList<String> fileNames) {
        BufferedWriter bufw = null;
        try {
            bufw = new BufferedWriter(new FileWriter(file));
            for (String fileName : fileNames) {
                bufw.write(fileName, 0, fileName.length());
                bufw.newLine();
                bufw.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (bufw != null) {
                    bufw.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    //使用集合存放指定后缀文件的路径
    private static void listAll(File dir, ArrayList<String> fileNames, FilterBySuffix filter) {
        File[] files = dir.listFiles();
        for (File file : files) {
            //如果是目录就继续遍历
            if (file.isDirectory()) {
                listAll(file, fileNames, filter);
            } else {//如果是指定后缀文件就存入集合
                if (filter.accept(file))
                    fileNames.add(file.getAbsolutePath());
            }
        }
    }
}

//过滤器：获取指定关键字文件
class FilterByKeyword implements FileFilter {
    private String suffix;//文件包含的关键字

    FilterByKeyword(String suffix) {
        this.suffix = suffix;
    }

    @Override
    public boolean accept(File pathname) {
        if (pathname.isDirectory())//如果是目录就放入数组，便于以后继续遍历
            return true;
        else//如果是包含关键字文件，就放入数组，便于以后遍历输出
            return pathname.getName().contains(suffix);
    }
}

//过滤器：获取指定后缀关键字文件
class FilterBySuffix implements FileFilter {
    private String suffix;

    FilterBySuffix(String suffix) {
        this.suffix = suffix;
    }

    @Override
    public boolean accept(File pathname) {
        return pathname.getName().endsWith(suffix);
    }
}

class FileToolTest {
    public static void main(String[] args) {
        //copy文件
//        FileTool.copyFile(new File("I:\\Test\\mydb1.sql"), new File("I:\\Test\\3.sql"));
        //递归copy文件
//        FileTool.copyFileAll(new File("I:\\Test\\2"), new File("I:\\Test\\3"));
        //递归遍历目录
//        FileTool.listAll(new File("I:\\Test\\2"),0);
        //递归删除文件
//        FileTool.deleteAll(new File("I:\\Test\\3"));
        //递归剪切文件
//        MyFile.renameToAll(new File("I:\\Test\\22"), new File("I:\\Test\\3"));
        //递归查找指定目录下指定关键字文件
//        FileTool.findFile(new File("I:\\Test\\3"), "新", 0);
        //递归获取指定后缀文件写入文本
        FileTool.writeSuffixFile(new File("I:\\Test\\3"), ".txt", new File("I:\\Test\\递归获取指定后缀文件写入文本.txt"));
    }
}