java文件搜索工具

文章字数：149,阅读全文大约需要1分钟

package com.colin.tool.file;

import java.io.File;
import java.util.*;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.stream.Stream;

/**
 * 文件搜索流
 *
 * @author colin.cheng
 * @since 1.0.0
 */
public class FileSearchStream {

    private File[] root;
    private boolean parallel;
    private Consumer<File> afterConsumer;
    private Function<File, Boolean> filter;
    private boolean deep = true;

    private FileSearchStream() {}

    public FileSearchStream(File... root) {
        init(root);
    }

    /**
     * 获取一个查询对象
     *
     * @param root
     * @return
     */
    public static FileSearchStream of(File... root) {
        return new FileSearchStream(root);
    }

    public boolean isDeep() {
        return deep;
    }

    /** 如果是文件夹，是否遍历 */
    public FileSearchStream setDeep(boolean deep) {
        this.deep = deep;
        return this;
    }

    /**
     * 获取本地所有盘符
     */
    public static File[] getSystemRoot() {
        return File.listRoots();
    }

    /**
     * 过滤条件
     *
     * @param filter
     * @return
     */
    public FileSearchStream filter(Function<File, Boolean> filter) {
        this.filter = filter;
        return this;
    }

    /**
     * 找到之后如何处理
     *
     * @param afterConsumer
     * @return
     */
    public void forEach(Consumer<File> afterConsumer) {
        this.afterConsumer = afterConsumer;
        searchRoot();
    }

    /**
     * 转换成list
     *
     * @param listFunction
     * @param <T>
     * @return
     */
    public <T> List<T> toList(Function<File, T> listFunction) {
        List<T> list = new LinkedList<>();
        this.afterConsumer = file -> list.add(listFunction.apply(file));
        searchRoot();
        return list;
    }

    /**
     * 分组保存
     *
     * @param keyFunction
     * @param valFunction
     * @param <T>
     * @param <R>
     * @return
     */
    public <T, R> Map<T, List<R>> groupingBy(Function<File, T> keyFunction, Function<File, R> valFunction) {
        Map<T, List<R>> res = new LinkedHashMap<>();
        this.afterConsumer = file -> {
            T key = keyFunction.apply(file);
            R val = valFunction.apply(file);
            if (res.containsKey(key)) {
                res.get(key).add(val);
            } else {
                List<R> list = new LinkedList<>();
                list.add(val);
                res.put(key, list);
            }
        };
        searchRoot();
        return res;
    }

    /**
     * 根据父级文件夹分组
     * 
     * @return
     */
    public Map<String, List<String>> groupingByPath() {
        return groupingBy(File::getParent, File::getName);
    }

    /**
     * 重置
     *
     * @return
     */
    public FileSearchStream reset(File... root) {
        init(root);
        return this;
    }

    /**
     * 初始化
     *
     * @param root
     */
    private void init(File... root) {
        this.root = root;
        this.parallel = false;
        this.afterConsumer = null;
        this.filter = (file) -> true;
    }

    /**
     * 开始搜索
     *
     * @return
     */
    private void searchRoot() {
        final Stream<File> fileStream = Arrays.stream(root);
        if (parallel) {
            fileStream.parallel().forEach(this::search);
        } else {
            fileStream.forEach(this::search);
        }
    }

    /**
     * 获取对应盘符下符合要求的文件
     */
    private void search(File file) {
        File[] f = file.listFiles();
        if (f != null) {
            if (f.length > 0) {
                for (File files : f) {
                    if(deep) {
                        if (files.isDirectory()) {
                            search(files);
                        } else {
                            if (filter.apply(files)) {
                                if (afterConsumer != null) {
                                    afterConsumer.accept(files);
                                }
                            }
                        }
                    } else {
                        if (filter.apply(files)) {
                            if (afterConsumer != null) {
                                afterConsumer.accept(files);
                            }
                        }
                    }
                }
            }
        }
    }

    /**
     * 文件后缀
     */
    public enum FileSuffix {
        /** 图片 */
        IMG("psd", "pdd", "gif", "jpeg", "jpg", "png"),
        /** 文档 */
        DOCUMENT("doc", "docx", "xls", "xlsx", "csv", "ppt", "pptx", "txt"),
        /** 程序 */
        APPLICATION("exe", "bat", "cmd", "sh", "ink", "py", "class", "java"),
        /** 音频 */
        AUDIO("mp3", "flac", "ape", "cd", "wave", "aiff"),
        /** 视频 */
        VIDEO(
            "avi", "mov", "qt", "asf", "rm", "navi", "divX", "mpeg", "mpg", "ogg", "mod", "rmvb", "flv", "mp4", "3gp");

        private String[] suffix;

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

        public boolean check(String fileName) {
            if (fileName.contains(".")) {
                String fileSuffix = fileName.split("\\.")[1];
                fileSuffix = fileSuffix.toLowerCase();
                for (String s : suffix) {
                    String b = s.toLowerCase();
                    if (fileSuffix.equals(b)) {
                        return true;
                    }
                }
            }
            return false;
        }

        public String[] getSuffix() {
            return suffix;
        }
    }
}

---