目录实用工具

1. 获取File对象的目录树. 文件夹下面是文件夹 递归调用, 直到没有发现文件夹为止. walk()方法将开始目录转换为File对象, 然后调用recurseDirs: 递归调用

package com.zachary.file;

import java.io.File;
import java.io.FilenameFilter;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.regex.Pattern;

/**
 * @author Zachary.Zheng
 * @version 1.0
 * @date 2019年11月9日
 */
public class Directory {
    /**
     * 获取能匹配正则的文件夹名
     * local()的使用被称为listFile()的File.list()的变体来产生File数组
     * @param dir
     * @param regex
     * @return
     */
    public static File[] local(File dir, final String regex) {
        return dir.listFiles(new FilenameFilter() {
            private Pattern pattern = Pattern.compile(regex);
            
            @Override
            public boolean accept(File dir, String name) {
                return pattern.matcher(new File(name).getName()).matches();
            }
        });
    }
    /**
     * 获取能匹配正则的文件夹名
     * @param path
     * @param regex
     * @return
     */
    public static File[] local(String path, final String regex) {
        return local(new File(path), regex);
    }
    public static class TreeInfo implements Iterable<File> {
        // 文件名称路径
        public List<File> files = new ArrayList<>();
        // 文件夹路径
        public List<File> dirs = new ArrayList<>();
        @Override
        public Iterator<File> iterator() {
            return files.iterator();
        }
        void addAll(TreeInfo other) {
            files.addAll(other.files);
            dirs.addAll(other.dirs);
        }
        @Override
        public String toString() {
            return "TreeInfo [dirs=" + PPrint.pformat(dirs) + ", 

files=" + PPrint.pformat(files) + "]";
        }
    }
    public static TreeInfo walk(String start, String regex) {
        return recurseDirs(new File(start), regex);
    }
    public static TreeInfo walk(File start, String regex) {
        return recurseDirs(start, regex);
    }
    public static TreeInfo walk(String start) {
        return recurseDirs(new File(start), ".*");
    }
    public static TreeInfo walk(File start) {
        return recurseDirs(start, ".*");
    }
    /**
     * 获取目录树
     * recurse: 递归调用
     * 1.local()的使用被称为listFile()的File.list()的变体来产生File数组
     * 2.walk()方法将开始目录转换为File对象, 然后调用recurseDirs
     *     // 文件名称路径 持有所有文件
     *     public List<File> files = new ArrayList<>();
     *     // 文件夹路径 持有所以目录
     *     public List<File> dirs = new ArrayList<>();
     * @param startDir
     * @param regex
     * @return
     */
    static TreeInfo recurseDirs(File startDir, String regex) {
        TreeInfo result = new TreeInfo();
        // 文件夹也可以过滤
        for (File item : Directory.local(startDir, ".*")) {
            if(item.isDirectory()) {
                result.dirs.add(item);
                /*
                 * 1.文件夹下面是文件夹 递归调用, 直到没有发现文件夹为止.
                 * 2.将子文件夹中的目录结构复制给父文件夹
                 */
                result.addAll(recurseDirs(item, regex));
            } else {
                if(item.getName().matches(regex)) {
                    result.files.add(item);
                }
            }
        }
        return result;
    }
    public static void main(String[] args) {
        if(args.length == 0) {
            System.out.println(walk("."));
        } else {
            for (String arg : args) {
                System.out.println(walk(arg));
            }
        }
    }
}
///:~

2. PPrint格式化打印目录树工具

package com.zachary.file;

import java.util.Arrays;
import java.util.Collection;

/**
 * @author Zachary.Zheng
 * @version 1.0
 * @date 2019年11月9日
 */
public class PPrint {
    public static String pformat(Collection<?> c) {
        if(c.size() == 0) {
            return "[]";
        }
        StringBuffer result = new StringBuffer("[");
        for (Object elem : c) {
            if(c.size() != 1) {
                result.append("
 ");
            }
            result.append(elem);
        }
        if(c.size() != 1) {
            result.append("
");
        }
        result.append("]");
        return result.toString();
    }
    public static void pprint(Collection<?> c) {
        System.out.println(pformat(c));
    }
    public static void pprint(Object [] c) {
        System.out.println(pformat(Arrays.asList(c)));
    }
}
///:~

3.创建一个工具, 它可以在目录中穿行, 并根据Strategy对象来出理这些目录结构(这是策略模式的另一个实例)

package com.zachary.file;

import java.io.File;
import java.io.IOException;

/**
 * @author Zachary.Zheng
 * @version 1.0
 * @date 2019年11月9日
 */
public class ProcessFiles {
    /**
     * 定义回调函数接口
     * 在调用时实现
     * @author Zachary.Zheng
     * @version 1.0
     * @date 2019年11月9日
     */
    public interface Strategy{
        void process(File file);
    }
    private Strategy strategy;
    private String ext;
    public ProcessFiles(Strategy strategy, String ext) {
        super();
        this.strategy = strategy;
        this.ext = ext;
    }
    public ProcessFiles() {
        super();
    }

    public void start(String [] args) {
        try {
            if(args.length == 0) {
                processDirectoryTree(new File("."));
            } else {
                for (String arg : args) {
                    File fileArg = new File(arg);
                    if(fileArg.isDirectory()) {
                        processDirectoryTree(fileArg);
                    } else {
                        if(!arg.endsWith("." + ext)) {
                            arg += "." + ext;
                        }
                        // 执行回调函数
                        strategy.process(new File(arg).getCanonicalFile());
                    }
                }
            }
        } catch (Exception e) {
            // TODO: handle exception
        }
    }
    public void processDirectoryTree(File root) throws IOException {
        for(File file: Directory.walk(root.getAbsolutePath(), ".*\."+ext)) {
            // 执行回调函数
            strategy.process(file.getCanonicalFile());
        }
    }
    public static void main(String[] args) {
        new ProcessFiles(new ProcessFiles.Strategy() {
            // 回调函数
            public void process(File file) {
                System.out.println(file);
            }
        }, "java").start(args);;
    }
}
/* Output: (sample)
E:\javaBaseLearn\IOStreamworkSpace\java-io-stream\src\com\zachary\io\util\Directory.java
E:\javaBaseLearn\IOStream\workSpace\java-io-stream\src\com\zachary\io\util\DirList.java
E:\javaBaseLearn\IOStream\workSpace\java-io-stream\src\com\zachary\io\util\DirList2.java
E:\javaBaseLearn\IOStream\workSpace\java-io-stream\src\com\zachary\io\util\DirList3.java
E:\javaBaseLearn\IOStream\workSpace\java-io-stream\src\com\zachary\io\util\PPrint.java
E:\javaBaseLearn\IOStream\workSpace\java-io-stream\src\com\zachary\io\util\ProcessFiles.java
E:\javaBaseLearn\IOStream\workSpace\java-io-stream\src\com\zachary\io\util\TreeInfo.java 
*///:~

4.目录的检查及创建

package com.zachary.file;

import java.io.File;
import java.io.IOException;

/**
 * @author Zachary.Zheng
 * @version 1.0
 * @date 2019年11月10日
 */
public class MakeDirectories {
    private static void usage() {
        System.err.println(
            "Usage:MakeDirectories path1 ...
" +
            "Creates each path
" +
            "Usage:MakeDirectories -d path1 ...
" +
            "Creates each path
" +
            "Usage:MakeDirectories -r path1 path2
" +
            "Renames from path1 to path2" );
        System.exit(1);
    }
    private static void fileData(File f) {
        System.out.println(
                "Absolute path: " + f.getAbsolutePath() +
                "
 Can read: " + f.canRead() +
                "
 Can write: " + f.canWrite() +
                "
 getName: " + f.getName() +
                "
 getParent: " + f.getParent() +
                "
 getPath: " + f.getPath() +
                "
 length: " + f.length() +
                "
 lastModified: " + f.lastModified() );
        if(f.isFile()) {
            System.out.println("It's a file");
        } else if(f.isDirectory()) {
            System.out.println("It's s directory");
        }
    }
    public static void main(String[] args) throws IOException {
        if(args.length < 1) {
            usage();
        }
        // 读
        if(args[0].equals("-r")) {
            if(args.length != 3) {
                usage();
            }
            File 
                old = new File(args[1]),
                rename = new File(args[2]);
            // 重新命名 成功返回true 失败返回false
            System.out.println("renameTo: "+old.renameTo(rename));
            fileData(old);
            fileData(rename);
            return; // Exit main
        }
        // add 文件
        // -add MakeDirectoriesTest MakeDirectoriesTest.txt
        if(args[0].equals("-add")) {
            if(args.length != 3) {
                usage();
            }
            File f = new File(args[1], args[2]);
            if(!f.exists()) {
                // 创建文件 MakeDirectoriesTest.txt
                f.createNewFile();
                System.out.println("created..." + f);
            }
            return; // Exit main
        }
        int count = 0;
        boolean del = false;
        if(args[0].equals("-d")) {
            count++;
            del = true;
        }
        count--;
        while (++count < args.length) {
            File f = new File(args[count]);
            if(f.exists()) {
                System.out.println(f + "exists");
                if(del) {
                    System.out.println("deleting..." + f);
                    f.delete();
                }
            } else { // 文件不存在
                if(!del) {
                    f.mkdirs();
                    System.out.println("created..." + f);
                }
            }
            fileData(f);
        }
    }
}