package dev.utils.common;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileFilter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.List;

import dev.utils.JCLogUtils;
import dev.utils.common.encrypt.MD5Utils;

/**
 * detail: 文件操作工具类
 * @author Ttt
 */
public final class FileUtils {

    private FileUtils() {
    }

    // 日志 TAG
    private static final String TAG = FileUtils.class.getSimpleName();
    // 换行字符串
    private static final String NEW_LINE_STR = System.getProperty("line.separator");

    /**
     * 获取文件
     * @param filePath 文件路径
     * @return 文件 {@link File}
     */
    public static File getFile(final String filePath) {
        return getFileByPath(filePath);
    }

    /**
     * 获取文件
     * @param filePath 文件路径
     * @param fileName 文件名
     * @return 文件 {@link File}
     */
    public static File getFile(final String filePath, final String fileName) {
        return (filePath != null && fileName != null) ? new File(filePath, fileName) : null;
    }

    /**
     * 获取文件
     * @param filePath 文件路径
     * @return 文件 {@link File}
     */
    public static File getFileByPath(final String filePath) {
        return filePath != null ? new File(filePath) : null;
    }

    /**
     * 获取路径, 并且进行创建目录
     * @param filePath 保存目录
     * @param fileName 文件名
     * @return 文件 {@link File}
     */
    public static File getFileCreateFolder(final String filePath, final String fileName) {
        // 防止不存在目录文件, 自动创建
        createFolder(filePath);
        // 返回处理过后的 File
        return getFile(filePath, fileName);
    }

    /**
     * 获取路径, 并且进行创建目录
     * @param filePath 保存目录
     * @param fileName 文件名
     * @return 文件 {@link File}
     */
    public static String getFilePathCreateFolder(final String filePath, final String fileName) {
        // 防止不存在目录文件, 自动创建
        createFolder(filePath);
        // 返回处理过后的 File
        File file = getFile(filePath, fileName);
        // 返回文件路径
        return getAbsolutePath(file);
    }

    /**
     * 判断某个文件夹是否创建, 未创建则创建 ( 纯路径 - 无文件名 )
     * @param dirPath 文件夹路径 ( 无文件名字. 后缀 )
     * @return {@code true} success, {@code false} fail
     */
    public static boolean createFolder(final String dirPath) {
        return createFolder(getFileByPath(dirPath));
    }

    /**
     * 判断某个文件夹是否创建, 未创建则创建 ( 纯路径 - 无文件名 )
     * @param file 文件夹路径 ( 无文件名字. 后缀 )
     * @return {@code true} success, {@code false} fail
     */
    public static boolean createFolder(final File file) {
        if (file != null) {
            try {
                // 当这个文件夹不存在的时候则创建文件夹
                if (!file.exists()) {
                    // 允许创建多级目录
                    return file.mkdirs();
                }
                return true;
            } catch (Exception e) {
                JCLogUtils.eTag(TAG, e, "createFolder");
            }
        }
        return false;
    }

    /**
     * 创建文件夹目录 - 可以传入文件名
     * @param filePath 文件路径 + 文件名
     * @return {@code true} success, {@code false} fail
     */
    public static boolean createFolderByPath(final String filePath) {
        return createFolderByPath(getFileByPath(filePath));
    }

    /**
     * 创建文件夹目录 - 可以传入文件名
     * @param file 文件
     * @return {@code true} success, {@code false} fail
     */
    public static boolean createFolderByPath(final File file) {
        // 创建文件夹 - 如果失败才创建
        if (file != null) {
            if (file.exists()) {
                return true;
            } else if (!file.getParentFile().mkdirs()) {
                return createFolder(file.getParent());
            }
        }
        return false;
    }

    /**
     * 创建多个文件夹, 如果不存在则创建
     * @param filePaths 文件路径数组
     * @return {@code true} success, {@code false} fail
     */
    public static boolean createFolderByPaths(final String... filePaths) {
        if (filePaths != null && filePaths.length != 0) {
            for (int i = 0, len = filePaths.length; i < len; i++) {
                createFolder(filePaths[i]);
            }
            return true;
        }
        return false;
    }

    /**
     * 创建多个文件夹, 如果不存在则创建
     * @param files 文件数组
     * @return {@code true} success, {@code false} fail
     */
    public static boolean createFolderByPaths(final File... files) {
        if (files != null && files.length != 0) {
            for (int i = 0, len = files.length; i < len; i++) {
                createFolder(files[i]);
            }
            return true;
        }
        return false;
    }

    // =

    /**
     * 判断目录是否存在, 不存在则判断是否创建成功
     * @param dirPath 目录路径
     * @return {@code true} 存在或创建成功, {@code false} 不存在或创建失败
     */
    public static boolean createOrExistsDir(final String dirPath) {
        return createOrExistsDir(getFileByPath(dirPath));
    }

    /**
     * 判断目录是否存在, 不存在则判断是否创建成功
     * @param file 文件
     * @return {@code true} 存在或创建成功, {@code false} 不存在或创建失败
     */
    public static boolean createOrExistsDir(final File file) {
        // 如果存在, 是目录则返回 true, 是文件则返回 false, 不存在则返回是否创建成功
        return file != null && (file.exists() ? file.isDirectory() : file.mkdirs());
    }

    /**
     * 判断文件是否存在, 不存在则判断是否创建成功
     * @param filePath 文件路径
     * @return {@code true} 存在或创建成功, {@code false} 不存在或创建失败
     */
    public static boolean createOrExistsFile(final String filePath) {
        return createOrExistsFile(getFileByPath(filePath));
    }

    /**
     * 判断文件是否存在, 不存在则判断是否创建成功
     * @param file 文件
     * @return {@code true} 存在或创建成功, {@code false} 不存在或创建失败
     */
    public static boolean createOrExistsFile(final File file) {
        if (file == null) return false;
        // 如果存在, 是文件则返回 true, 是目录则返回 false
        if (file.exists()) return file.isFile();
        // 判断文件是否存在, 不存在则直接返回
        if (!createOrExistsDir(file.getParentFile())) return false;
        try {
            // 存在, 则返回新的路径
            return file.createNewFile();
        } catch (Exception e) {
            JCLogUtils.eTag(TAG, e, "createOrExistsFile");
            return false;
        }
    }

    /**
     * 判断文件是否存在, 存在则在创建之前删除
     * @param filePath 文件路径
     * @return {@code true} 创建成功, {@code false} 创建失败
     */
    public static boolean createFileByDeleteOldFile(final String filePath) {
        return createFileByDeleteOldFile(getFileByPath(filePath));
    }

    /**
     * 判断文件是否存在, 存在则在创建之前删除
     * @param file 文件
     * @return {@code true} 创建成功, {@code false} 创建失败
     */
    public static boolean createFileByDeleteOldFile(final File file) {
        if (file == null) return false;
        // 文件存在并且删除失败返回 false
        if (file.exists() && !file.delete()) return false;
        // 创建目录失败返回 false
        if (!createOrExistsDir(file.getParentFile())) return false;
        try {
            return file.createNewFile();
        } catch (IOException e) {
            JCLogUtils.eTag(TAG, e, "createFileByDeleteOldFile");
            return false;
        }
    }

    /**
     * 获取文件路径
     * @param file 文件
     * @return 文件路径
     */
    public static String getPath(final File file) {
        return file != null ? file.getPath() : null;
    }

    /**
     * 获取文件绝对路径
     * @param file 文件
     * @return 文件绝对路径
     */
    public static String getAbsolutePath(final File file) {
        return file != null ? file.getAbsolutePath() : null;
    }

    // =

    /**
     * 获取文件名
     * @param file 文件
     * @return 文件名
     */
    public static String getName(final File file) {
        return file != null ? file.getName() : null;
    }

    /**
     * 获取文件名
     * @param filePath 文件路径
     * @return 文件名
     */
    public static String getName(final String filePath) {
        return getName(filePath, "");
    }

    /**
     * 获取文件名
     * @param filePath   文件路径
     * @param defaultStr 默认字符串
     * @return 文件名, 如果文件路径为 null 时, 返回默认字符串
     */
    public static String getName(final String filePath, final String defaultStr) {
        return StringUtils.isSpace(filePath) ? defaultStr : new File(filePath).getName();
    }

    /**
     * 获取文件后缀名 ( 无 "." 单独后缀 )
     * @param file 文件
     * @return 文件后缀名 ( 无 "." 单独后缀 )
     */
    public static String getFileSuffix(final File file) {
        return getFileSuffix(getAbsolutePath(file));
    }

    /**
     * 获取文件后缀名 ( 无 "." 单独后缀 )
     * @param filePath 文件路径或文件名
     * @return 文件后缀名 ( 无 "." 单独后缀 )
     */
    public static String getFileSuffix(final String filePath) {
        // 获取最后的索引
        int lastIndexOf;
        // 判断是否存在
        if (filePath != null && (lastIndexOf = filePath.lastIndexOf('.')) != -1) {
            String result = filePath.substring(lastIndexOf);
            if (result.startsWith(".")) {
                return result.substring(1);
            }
            return result;
        }
        return null;
    }

    /**
     * 获取文件名 ( 无后缀 )
     * @param file 文件
     * @return 文件名 ( 无后缀 )
     */
    public static String getFileNotSuffix(final File file) {
        return getFileNotSuffix(getName(file));
    }

    /**
     * 获取文件名 ( 无后缀 )
     * @param filePath 文件路径
     * @return 文件名 ( 无后缀 )
     */
    public static String getFileNotSuffixToPath(final String filePath) {
        return getFileNotSuffix(getName(filePath));
    }

    /**
     * 获取文件名 ( 无后缀 )
     * @param fileName 文件名
     * @return 文件名 ( 无后缀 )
     */
    public static String getFileNotSuffix(final String fileName) {
        if (fileName != null) {
            if (fileName.lastIndexOf('.') != -1) {
                return fileName.substring(0, fileName.lastIndexOf('.'));
            } else {
                return fileName;
            }
        }
        return null;
    }

    /**
     * 获取路径中的不带拓展名的文件名
     * @param file 文件
     * @return 不带拓展名的文件名
     */
    public static String getFileNameNoExtension(final File file) {
        if (file == null) return null;
        return getFileNameNoExtension(file.getPath());
    }

    /**
     * 获取路径中的不带拓展名的文件名
     * @param filePath 文件路径
     * @return 不带拓展名的文件名
     */
    public static String getFileNameNoExtension(final String filePath) {
        if (StringUtils.isSpace(filePath)) return filePath;
        int lastPoi = filePath.lastIndexOf('.');
        int lastSep = filePath.lastIndexOf(File.separator);
        if (lastSep == -1) {
            return (lastPoi == -1 ? filePath : filePath.substring(0, lastPoi));
        }
        if (lastPoi == -1 || lastSep > lastPoi) {
            return filePath.substring(lastSep + 1);
        }
        return filePath.substring(lastSep + 1, lastPoi);
    }

    /**
     * 获取路径中的文件拓展名
     * @param file 文件
     * @return 文件拓展名
     */
    public static String getFileExtension(final File file) {
        if (file == null) return null;
        return getFileExtension(file.getPath());
    }

    /**
     * 获取路径中的文件拓展名
     * @param filePath 文件路径
     * @return 文件拓展名
     */
    public static String getFileExtension(final String filePath) {
        if (StringUtils.isSpace(filePath)) return filePath;
        int lastPoi = filePath.lastIndexOf('.');
        int lastSep = filePath.lastIndexOf(File.separator);
        if (lastPoi == -1 || lastSep >= lastPoi) return "";
        return filePath.substring(lastPoi + 1);
    }

    // =

    /**
     * 检查是否存在某个文件
     * @param file 文件
     * @return {@code true} yes, {@code false} no
     */
    public static boolean isFileExists(final File file) {
        return file != null && file.exists();
    }

    /**
     * 检查是否存在某个文件
     * @param filePath 文件路径
     * @return {@code true} yes, {@code false} no
     */
    public static boolean isFileExists(final String filePath) {
        return isFileExists(getFileByPath(filePath));
    }

    /**
     * 检查是否存在某个文件
     * @param filePath 文件路径
     * @param fileName 文件名
     * @return {@code true} yes, {@code false} no
     */
    public static boolean isFileExists(final String filePath, final String fileName) {
        return filePath != null && fileName != null && new File(filePath, fileName).exists();
    }

    /**
     * 判断是否文件
     * @param filePath 文件路径
     * @return {@code true} yes, {@code false} no
     */
    public static boolean isFile(final String filePath) {
        return isFile(getFileByPath(filePath));
    }

    /**
     * 判断是否文件
     * @param file 文件
     * @return {@code true} yes, {@code false} no
     */
    public static boolean isFile(final File file) {
        return file != null && file.exists() && file.isFile();
    }

    /**
     * 判断是否文件夹
     * @param filePath 文件路径
     * @return {@code true} yes, {@code false} no
     */
    public static boolean isDirectory(final String filePath) {
        return isDirectory(getFileByPath(filePath));
    }

    /**
     * 判断是否文件夹
     * @param file 文件
     * @return {@code true} yes, {@code false} no
     */
    public static boolean isDirectory(final File file) {
        return file != null && file.exists() && file.isDirectory();
    }

    /**
     * 判断是否隐藏文件
     * @param filePath 文件路径
     * @return {@code true} yes, {@code false} no
     */
    public static boolean isHidden(final String filePath) {
        return isHidden(getFileByPath(filePath));
    }

    /**
     * 判断是否隐藏文件
     * @param file 文件
     * @return {@code true} yes, {@code false} no
     */
    public static boolean isHidden(final File file) {
        return file != null && file.exists() && file.isHidden();
    }

    // =

    /**
     * 获取文件最后修改的毫秒时间戳
     * @param filePath 文件路径
     * @return 文件最后修改的毫秒时间戳
     */
    public static long getFileLastModified(final String filePath) {
        return getFileLastModified(getFileByPath(filePath));
    }

    /**
     * 获取文件最后修改的毫秒时间戳
     * @param file 文件
     * @return 文件最后修改的毫秒时间戳
     */
    public static long getFileLastModified(final File file) {
        if (file == null) return 0L;
        return file.lastModified();
    }

    /**
     * 获取文件编码格式
     * @param filePath 文件路径
     * @return 文件编码格式
     */
    public static String getFileCharsetSimple(final String filePath) {
        return getFileCharsetSimple(getFileByPath(filePath));
    }

    /**
     * 获取文件编码格式
     * @param file 文件
     * @return 文件编码格式
     */
    public static String getFileCharsetSimple(final File file) {
        if (!isFileExists(file)) return null;
        int pos = 0;
        InputStream is = null;
        try {
            is = new BufferedInputStream(new FileInputStream(file));
            pos = (is.read() << 8) + is.read();
        } catch (IOException e) {
            JCLogUtils.eTag(TAG, e, "getFileCharsetSimple");
        } finally {
            CloseUtils.closeIOQuietly(is);
        }
        switch (pos) {
            case 0xefbb:
                return "UTF-8";
            case 0xfffe:
                return "Unicode";
            case 0xfeff:
                return "UTF-16BE";
            default:
                return "GBK";
        }
    }

    /**
     * 获取文件行数
     * @param filePath 文件路径
     * @return 文件行数
     */
    public static int getFileLines(final String filePath) {
        return getFileLines(getFileByPath(filePath));
    }

    /**
     * 获取文件行数 ( 比 readLine 要快很多 )
     * @param file 文件
     * @return 文件行数
     */
    public static int getFileLines(final File file) {
        if (!isFileExists(file)) return 0;
        int lineCount = 1;
        InputStream is = null;
        try {
            is = new BufferedInputStream(new FileInputStream(file));
            byte[] buffer = new byte[1024];
            int readChars;
            if (NEW_LINE_STR.endsWith("\n")) {
                while ((readChars = is.read(buffer, 0, 1024)) != -1) {
                    for (int i = 0; i < readChars; ++i) {
                        if (buffer[i] == '\n') ++lineCount;
                    }
                }
            } else {
                while ((readChars = is.read(buffer, 0, 1024)) != -1) {
                    for (int i = 0; i < readChars; ++i) {
                        if (buffer[i] == '\r') ++lineCount;
                    }
                }
            }
        } catch (Exception e) {
            JCLogUtils.eTag(TAG, e, "getFileLines");
        } finally {
            CloseUtils.closeIOQuietly(is);
        }
        return lineCount;
    }

    // =

    /**
     * 获取文件大小
     * @param filePath 文件路径
     * @return 文件大小
     */
    public static String getFileSize(final String filePath) {
        return getFileSize(getFileByPath(filePath));
    }

    /**
     * 获取文件大小
     * @param file 文件
     * @return 文件大小
     */
    public static String getFileSize(final File file) {
        return formatByteMemorySize(getFileLength(file));
    }

    /**
     * 获取目录大小
     * @param dirPath 目录路径
     * @return 文件大小
     */
    public static String getDirSize(final String dirPath) {
        return getDirSize(getFileByPath(dirPath));
    }

    /**
     * 获取目录大小
     * @param dir 目录
     * @return 文件大小
     */
    public static String getDirSize(final File dir) {
        return formatByteMemorySize(getDirLength(dir));
    }

    /**
     * 获取文件大小
     * @param filePath 文件路径
     * @return 文件大小
     */
    public static long getFileLength(final String filePath) {
        return getFileLength(getFileByPath(filePath));
    }

    /**
     * 获取文件大小
     * @param file 文件
     * @return 文件大小
     */
    public static long getFileLength(final File file) {
        return file != null ? file.length() : 0L;
    }

    /**
     * 获取目录全部文件大小
     * @param dirPath 目录路径
     * @return 目录全部文件大小
     */
    public static long getDirLength(final String dirPath) {
        return getDirLength(getFileByPath(dirPath));
    }

    /**
     * 获取目录全部文件大小
     * @param dir 目录
     * @return 目录全部文件大小
     */
    public static long getDirLength(final File dir) {
        if (!isDirectory(dir)) return 0;
        long len = 0;
        File[] files = dir.listFiles();
        if (files != null && files.length != 0) {
            for (File file : files) {
                if (file.isDirectory()) {
                    len += getDirLength(file);
                } else {
                    len += file.length();
                }
            }
        }
        return len;
    }

    /**
     * 获取文件大小 - 网络资源
     * @param httpUri 文件网络链接
     * @return 文件大小
     */
    public static long getFileLengthNetwork(final String httpUri) {
        if (StringUtils.isSpace(httpUri)) return 0L;
        // 判断是否网络资源
        boolean isHttpRes = httpUri.toLowerCase().startsWith("http:") || httpUri.toLowerCase().startsWith("https:");
        if (isHttpRes) {
            try {
                HttpURLConnection conn = (HttpURLConnection) new URL(httpUri).openConnection();
                conn.setRequestProperty("Accept-Encoding", "identity");
                conn.connect();
                if (conn.getResponseCode() == 200) {
                    return conn.getContentLength();
                }
                return 0L;
            } catch (Exception e) {
                JCLogUtils.eTag(TAG, e, "getFileLengthNetwork");
            }
        }
        return 0L;
    }

    /**
     * 获取路径中的文件名
     * @param file 文件
     * @return 文件名
     */
    public static String getFileName(final File file) {
        if (file == null) return null;
        return getFileName(file.getPath());
    }

    /**
     * 获取路径中的文件名
     * @param filePath 文件路径
     * @return 文件名
     */
    public static String getFileName(final String filePath) {
        if (StringUtils.isSpace(filePath)) return filePath;
        int lastSep = filePath.lastIndexOf(File.separator);
        return lastSep == -1 ? filePath : filePath.substring(lastSep + 1);
    }

    /**
     * 获取路径中的最长目录地址
     * @param file 文件
     * @return 最长目录地址
     */
    public static String getDirName(final File file) {
        if (file == null) return null;
        return getDirName(file.getPath());
    }

    /**
     * 获取全路径中的最长目录地址
     * @param filePath 文件路径
     * @return 最长目录地址
     */
    public static String getDirName(final String filePath) {
        if (StringUtils.isSpace(filePath)) return filePath;
        int lastSep = filePath.lastIndexOf(File.separator);
        return lastSep == -1 ? "" : filePath.substring(0, lastSep + 1);
    }

    // =

    /**
     * 重命名文件 - 同个目录下, 修改文件名
     * @param filePath    文件路径
     * @param newFileName 文件新名称
     * @return {@code true} yes, {@code false} no
     */
    public static boolean rename(final String filePath, final String newFileName) {
        return rename(getFileByPath(filePath), newFileName);
    }

    /**
     * 重命名文件 - 同个目录下, 修改文件名
     * @param file        文件
     * @param newFileName 文件新名称
     * @return {@code true} yes, {@code false} no
     */
    public static boolean rename(final File file, final String newFileName) {
        // 文件为空返回 false
        if (file == null) return false;
        // 文件不存在返回 false
        if (!file.exists()) return false;
        // 如果文件名没有改变返回 true
        if (newFileName.equals(file.getName())) return true;
        // 拼接新的文件路径
        File newFile = new File(file.getParent() + File.separator + newFileName);
        // 如果重命名的文件已存在返回 false
        return !newFile.exists() && file.renameTo(newFile);
    }

    // ================
    // = 文件大小处理 =
    // ================

    /**
     * 传入文件路径, 返回对应的文件大小
     * @param filePath 文件路径
     * @return 文件大小转换字符串
     */
    public static String formatFileSize(final String filePath) {
        File file = getFileByPath(filePath);
        return formatFileSize(file != null ? file.length() : 0);
    }

    /**
     * 传入文件路径, 返回对应的文件大小
     * @param file 文件
     * @return 文件大小转换字符串
     */
    public static String formatFileSize(final File file) {
        return formatFileSize(file != null ? file.length() : 0);
    }

    /**
     * 传入对应的文件大小, 返回转换后文件大小
     * @param fileSize 文件大小
     * @return 文件大小转换字符串
     */
    public static String formatFileSize(final double fileSize) {
        // 转换文件大小
        DecimalFormat df = new DecimalFormat("#.00");
        String fileSizeStr;
        if (fileSize <= 0) {
            fileSizeStr = "0B";
        } else if (fileSize < 1024) {
            fileSizeStr = df.format(fileSize) + "B";
        } else if (fileSize < 1048576) {
            fileSizeStr = df.format(fileSize / 1024) + "KB";
        } else if (fileSize < 1073741824) {
            fileSizeStr = df.format(fileSize / 1048576) + "MB";
        } else if (fileSize < 1099511627776d) {
            fileSizeStr = df.format(fileSize / 1073741824) + "GB";
        } else {
            fileSizeStr = df.format(fileSize / 1099511627776d) + "TB";
        }
        return fileSizeStr;
    }

    /**
     * 字节数转合适内存大小 保留 3 位小数 (%.位数f)
     * @param byteSize 字节数
     * @return 合适内存大小字符串
     */
    public static String formatByteMemorySize(final double byteSize) {
        return formatByteMemorySize(3, byteSize);
    }

    /**
     * 字节数转合适内存大小 保留 number 位小数 (%.位数f)
     * @param number   保留小数位数
     * @param byteSize 字节数
     * @return 合适内存大小字符串
     */
    public static String formatByteMemorySize(final int number, final double byteSize) {
        if (byteSize < 0d) {
            return "0B";
        } else if (byteSize < 1024d) {
            return String.format("%." + number + "fB", byteSize);
        } else if (byteSize < 1048576d) {
            return String.format("%." + number + "fKB", byteSize / 1024d);
        } else if (byteSize < 1073741824d) {
            return String.format("%." + number + "fMB", byteSize / 1048576d);
        } else if (byteSize < 1099511627776d) {
            return String.format("%." + number + "fGB", byteSize / 1073741824d);
        } else {
            return String.format("%." + number + "fTB", byteSize / 1099511627776d);
        }
    }

    // ============
    // = 文件操作 =
    // ============

    /**
     * 删除文件
     * @param filePath 文件路径
     * @return {@code true} success, {@code false} fail
     */
    public static boolean deleteFile(final String filePath) {
        return deleteFile(getFileByPath(filePath));
    }

    /**
     * 删除文件
     * @param file 文件
     * @return {@code true} success, {@code false} fail
     */
    public static boolean deleteFile(final File file) {
        // 文件存在, 并且不是目录文件, 则直接删除
        if (file != null && file.exists() && !file.isDirectory()) {
            return file.delete();
        }
        return false;
    }

    /**
     * 删除多个文件
     * @param filePaths 文件路径数组
     * @return {@code true} success, {@code false} fail
     */
    public static boolean deleteFiles(final String... filePaths) {
        if (filePaths != null && filePaths.length != 0) {
            for (int i = 0, len = filePaths.length; i < len; i++) {
                deleteFile(filePaths[i]);
            }
            return true;
        }
        return false;
    }

    /**
     * 删除多个文件
     * @param files 文件数组
     * @return {@code true} success, {@code false} fail
     */
    public static boolean deleteFiles(final File... files) {
        if (files != null && files.length != 0) {
            for (int i = 0, len = files.length; i < len; i++) {
                deleteFile(files[i]);
            }
            return true;
        }
        return false;
    }

    // =

    /**
     * 删除文件夹
     * @param filePath 文件路径
     * @return {@code true} success, {@code false} fail
     */
    public static boolean deleteFolder(final String filePath) {
        return deleteFolder(getFileByPath(filePath));
    }

    /**
     * 删除文件夹
     * @param file 文件
     * @return {@code true} success, {@code false} fail
     */
    public static boolean deleteFolder(final File file) {
        if (file != null) {
            try {
                // 文件存在, 并且不是目录文件, 则直接删除
                if (file.exists()) {
                    if (file.isDirectory()) { // 属于文件目录
                        File[] files = file.listFiles();
                        if (null == files || files.length == 0) {
                            file.delete();
                        }
                        for (File f : files) {
                            deleteFolder(f.getPath());
                        }
                        return file.delete();
                    } else { // 属于文件
                        return deleteFile(file);
                    }
                }
            } catch (Exception e) {
                JCLogUtils.eTag(TAG, e, "deleteFolder");
            }
        }
        return false;
    }

    /**
     * 保存文件
     * @param filePath 文件路径
     * @param data     待存储数据
     * @return {@code true} success, {@code false} fail
     */
    public static boolean saveFile(final String filePath, final byte[] data) {
        return saveFile(FileUtils.getFile(filePath), data);
    }

    /**
     * 保存文件
     * @param file 文件
     * @param data 待存储数据
     * @return {@code true} success, {@code false} fail
     */
    public static boolean saveFile(final File file, final byte[] data) {
        if (file != null && data != null) {
            try {
                // 防止文件夹没创建
                createFolder(getDirName(file));
                // 写入文件
                FileOutputStream fos = new FileOutputStream(file);
                BufferedOutputStream bos = new BufferedOutputStream(fos);
                bos.write(data);
                bos.close();
                fos.close();
                return true;
            } catch (Exception e) {
                JCLogUtils.eTag(TAG, e, "saveFile");
            }
        }
        return false;
    }

    /**
     * 追加文件
     * @param filePath 文件路径
     * @param data     待追加数据
     * @return {@code true} success, {@code false} fail
     */
    public static boolean appendFile(final String filePath, final byte[] data) {
        return appendFile(FileUtils.getFile(filePath), data);
    }

    /**
     * 追加文件
     * <pre>
     *     如果未创建文件, 则会创建并写入数据 ( 等同 {@link #saveFile} )
     *     如果已创建文件, 则在结尾追加数据
     * </pre>
     * @param file 文件
     * @param data 待追加数据
     * @return {@code true} success, {@code false} fail
     */
    public static boolean appendFile(final File file, final byte[] data) {
        try {
            // 防止文件夹没创建
            createFolder(getDirName(file));
            // 写入文件
            FileOutputStream fos = new FileOutputStream(file, true);
            BufferedOutputStream bos = new BufferedOutputStream(fos);
            bos.write(data);
            bos.close();
            fos.close();
            return true;
        } catch (Exception e) {
            JCLogUtils.eTag(TAG, e, "appendFile");
        }
        return false;
    }

    // =

    /**
     * 读取文件
     * @param filePath 文件路径
     * @return 文件内容 byte[]
     */
    public static byte[] readFileBytes(final String filePath) {
        return readFileBytes(getFileByPath(filePath));
    }

    /**
     * 读取文件
     * @param file 文件
     * @return 文件内容 byte[]
     */
    public static byte[] readFileBytes(final File file) {
        if (file != null && file.exists()) {
            try {
                FileInputStream fis = new FileInputStream(file);
                int length = fis.available();
                byte[] buffer = new byte[length];
                fis.read(buffer);
                fis.close();
                return buffer;
            } catch (Exception e) {
                JCLogUtils.eTag(TAG, e, "readFileBytes");
            }
        }
        return null;
    }

    /**
     * 读取文件
     * @param inputStream {@link InputStream}
     * @return 文件内容 byte[]
     */
    public static byte[] readFileBytes(final InputStream inputStream) {
        if (inputStream != null) {
            try {
                int length = inputStream.available();
                byte[] buffer = new byte[length];
                inputStream.read(buffer);
                inputStream.close();
                return buffer;
            } catch (Exception e) {
                JCLogUtils.eTag(TAG, e, "readFileBytes");
            }
        }
        return null;
    }

    /**
     * 读取文件
     * @param filePath 文件路径
     * @return 文件内容字符串
     */
    public static String readFile(final String filePath) {
        return readFile(getFileByPath(filePath));
    }

    /**
     * 读取文件
     * @param file 文件
     * @return 文件内容字符串
     */
    public static String readFile(final File file) {
        if (file != null && file.exists()) {
            try {
                return readFile(new FileInputStream(file));
            } catch (Exception e) {
                JCLogUtils.eTag(TAG, e, "readFile");
            }
        }
        return null;
    }

    /**
     * 读取文件
     * @param inputStream {@link InputStream} new FileInputStream(path)
     * @return 文件内容字符串
     */
    public static String readFile(final InputStream inputStream) {
        return readFile(inputStream, null);
    }

    /**
     * 读取文件
     * @param inputStream {@link InputStream} new FileInputStream(path)
     * @param encode      编码格式
     * @return 文件内容字符串
     */
    public static String readFile(final InputStream inputStream, final String encode) {
        if (inputStream != null) {
            try {
                InputStreamReader isr = null;
                if (encode != null) {
                    new InputStreamReader(inputStream, encode);
                } else {
                    new InputStreamReader(inputStream);
                }
                BufferedReader br = new BufferedReader(isr);
                StringBuilder builder = new StringBuilder();
                String line;
                while ((line = br.readLine()) != null) {
                    builder.append(line);
                }
                isr.close();
                br.close();
                return builder.toString();
            } catch (Exception e) {
                JCLogUtils.eTag(TAG, e, "readFile");
            }
        }
        return null;
    }

    // =

    /**
     * 复制单个文件
     * @param inputStream  文件流 ( 被复制 )
     * @param destFilePath 目标文件地址
     * @param overlay      如果目标文件存在, 是否覆盖
     * @return {@code true} success, {@code false} fail
     */
    public static boolean copyFile(final InputStream inputStream, final String destFilePath, final boolean overlay) {
        if (inputStream == null || destFilePath == null) {
            return false;
        }
        File destFile = new File(destFilePath);
        // 如果属于文件夹则跳过
        if (destFile.isDirectory()) {
            return false;
        }
        if (destFile.exists()) {
            // 如果目标文件存在并允许覆盖
            if (overlay) {
                // 删除已经存在的目标文件, 无论目标文件是目录还是单个文件
                destFile.delete();
            } else { // 如果文件存在, 但是不覆盖, 则返回 false 表示失败
                return false;
            }
        } else {
            // 如果目标文件所在目录不存在, 则创建目录
            if (!destFile.getParentFile().exists()) {
                // 目标文件所在目录不存在
                if (!destFile.getParentFile().mkdirs()) {
                    // 复制文件失败: 创建目标文件所在目录失败
                    return false;
                }
            }
        }
        // 复制文件
        int byteread = 0; // 读取的字节数
        InputStream is = inputStream;
        OutputStream os = null;
        try {
            os = new FileOutputStream(destFile);
            byte[] buffer = new byte[1024];
            while ((byteread = is.read(buffer)) != -1) {
                os.write(buffer, 0, byteread);
            }
            return true;
        } catch (Exception e) {
            JCLogUtils.eTag(TAG, e, "copyFile");
            return false;
        } finally {
            CloseUtils.closeIOQuietly(os, is);
        }
    }

    /**
     * 复制单个文件
     * @param srcFilePath  待复制的文件地址
     * @param destFilePath 目标文件地址
     * @param overlay      如果目标文件存在, 是否覆盖
     * @return {@code true} success, {@code false} fail
     */
    public static boolean copyFile(final String srcFilePath, final String destFilePath, final boolean overlay) {
        if (srcFilePath == null || destFilePath == null) {
            return false;
        }
        File srcFile = new File(srcFilePath);
        // 判断源文件是否存在
        if (!srcFile.exists()) {
            return false;
        } else if (!srcFile.isFile()) { // srcFile.isDirectory();
            return false;
        }
        // 判断目标文件是否存在
        File destFile = new File(destFilePath);
        // 如果属于文件夹则跳过
        if (destFile.isDirectory()) {
            return false;
        }
        if (destFile.exists()) {
            // 如果目标文件存在并允许覆盖
            if (overlay) {
                // 删除已经存在的目标文件, 无论目标文件是目录还是单个文件
                new File(destFilePath).delete();
            } else { // 如果文件存在, 但是不覆盖, 则返回 false 表示失败
                return false;
            }
        } else {
            // 如果目标文件所在目录不存在, 则创建目录
            if (!destFile.getParentFile().exists()) {
                // 目标文件所在目录不存在
                if (!destFile.getParentFile().mkdirs()) {
                    // 复制文件失败: 创建目标文件所在目录失败
                    return false;
                }
            }
        }
        // 复制文件
        int byteread = 0; // 读取的字节数
        InputStream is = null;
        OutputStream os = null;
        try {
            is = new FileInputStream(srcFile);
            os = new FileOutputStream(destFile);
            byte[] buffer = new byte[1024];
            while ((byteread = is.read(buffer)) != -1) {
                os.write(buffer, 0, byteread);
            }
            return true;
        } catch (Exception e) {
            JCLogUtils.eTag(TAG, e, "copyFile");
            return false;
        } finally {
            CloseUtils.closeIOQuietly(os, is);
        }
    }

    /**
     * 复制文件夹
     * @param srcFolderPath  待复制的文件夹地址
     * @param destFolderPath 目标文件夹地址
     * @param overlay        如果目标文件存在, 是否覆盖
     * @return {@code true} success, {@code false} fail
     */
    public static boolean copyFolder(final String srcFolderPath, final String destFolderPath, final boolean overlay) {
        return copyFolder(srcFolderPath, destFolderPath, srcFolderPath, overlay);
    }

    /**
     * 复制文件夹
     * @param srcFolderPath  待复制的文件夹地址
     * @param destFolderPath 目标文件夹地址
     * @param sourcePath     源文件地址 ( 用于保递归留记录 )
     * @param overlay        如果目标文件存在, 是否覆盖
     * @return {@code true} success, {@code false} fail
     */
    private static boolean copyFolder(final String srcFolderPath, final String destFolderPath, final String sourcePath, final boolean overlay) {
        if (srcFolderPath == null || destFolderPath == null || sourcePath == null) {
            return false;
        }
        File srcFile = new File(srcFolderPath);
        // 判断源文件是否存在
        if (!srcFile.exists()) {
            return false;
        } else if (!srcFile.isDirectory()) { // 不属于文件夹则跳过
            return false;
        }
        // 判断目标文件是否存在
        File destFile = new File(destFolderPath);
        // 如果文件夹没创建, 则创建
        if (!destFile.exists()) {
            // 允许创建多级目录
            destFile.mkdirs();
        }
        // 判断是否属于文件夹
        if (!destFile.isDirectory()) { // 不属于文件夹则跳过
            return false;
        }
        // 判断是否存在
        if (srcFile.exists()) {
            // 获取文件路径
            File[] files = srcFile.listFiles();
            // 防止不存在文件
            if (files != null && files.length != 0) {
                // 进行遍历
                for (File file : files) {
                    // 文件存在才进行处理
                    if (file.exists()) {
                        // 属于文件夹
                        if (file.isDirectory()) {
                            copyFolder(file.getAbsolutePath(), destFolderPath, sourcePath, overlay);
                        } else { // 属于文件
                            // 复制的文件地址
                            String filePath = file.getAbsolutePath();
                            // 获取源文件地址 - 并且进行判断
                            String dealSource = new File(sourcePath).getAbsolutePath();
                            // 属于最前才进行处理
                            if (filePath.indexOf(dealSource) == 0) {
                                // 获取处理后的地址
                                dealSource = filePath.substring(dealSource.length());
                                // 获取需要复制保存的地址
                                String savePath = new File(destFolderPath, dealSource).getAbsolutePath();
                                // 进行复制文件
                                boolean isResult = copyFile(filePath, savePath, overlay);
                            }
                        }
                    }
                }
            }
        }
        return true;
    }

    // =

    /**
     * 移动 ( 剪切 ) 文件
     * @param srcFilePath  待移动的文件地址
     * @param destFilePath 目标文件地址
     * @param overlay      如果目标文件存在, 是否覆盖
     * @return {@code true} success, {@code false} fail
     */
    public static boolean moveFile(final String srcFilePath, final String destFilePath, final boolean overlay) {
        // 复制文件
        if (copyFile(srcFilePath, destFilePath, overlay)) {
            // 删除文件
            return deleteFile(srcFilePath);
        }
        return false;
    }

    /**
     * 移动 ( 剪切 ) 文件夹
     * @param srcFilePath  待移动的文件夹地址
     * @param destFilePath 目标文件夹地址
     * @param overlay      如果目标文件存在, 是否覆盖
     * @return {@code true} success, {@code false} fail
     */
    public static boolean moveFolder(final String srcFilePath, final String destFilePath, final boolean overlay) {
        // 复制文件夹
        if (copyFolder(srcFilePath, destFilePath, overlay)) {
            // 删除文件夹
            return deleteFolder(srcFilePath);
        }
        return false;
    }

    // =

    /**
     * detail: 覆盖 / 替换事件
     * @author Ttt
     */
    public interface OnReplaceListener {

        /**
         * 是否覆盖 / 替换文件
         * @return {@code true} yes, {@code false} no
         */
        boolean onReplace();
    }

    /**
     * 复制或移动目录
     * @param srcDirPath  源目录路径
     * @param destDirPath 目标目录路径
     * @param listener    是否覆盖监听器
     * @param isMove      是否移动
     * @return {@code true} 复制或移动成功, {@code false} 复制或移动失败
     */
    public static boolean copyOrMoveDir(final String srcDirPath, final String destDirPath, final OnReplaceListener listener, final boolean isMove) {
        return copyOrMoveDir(getFileByPath(srcDirPath), getFileByPath(destDirPath), listener, isMove);
    }

    /**
     * 复制或移动目录
     * @param srcDir   源目录
     * @param destDir  目标目录
     * @param listener 是否覆盖监听器
     * @param isMove   是否移动
     * @return {@code true} 复制或移动成功, {@code false} 复制或移动失败
     */
    public static boolean copyOrMoveDir(final File srcDir, final File destDir, final OnReplaceListener listener, final boolean isMove) {
        if (srcDir == null || destDir == null || listener == null) return false;
        // 为防止以上这种情况出现出现误判, 须分别在后面加个路径分隔符
        String srcPath = srcDir.getPath() + File.separator;
        String destPath = destDir.getPath() + File.separator;
        if (destPath.contains(srcPath)) return false;
        // 源文件不存在或者不是目录则返回 false
        if (!srcDir.exists() || !srcDir.isDirectory()) return false;
        if (destDir.exists()) {
            if (listener.onReplace()) { // 需要覆盖则删除旧目录
                if (!deleteAllInDir(destDir)) { // 删除文件失败的话返回 false
                    return false;
                }
            } else { // 不需要覆盖直接返回即可 true
                return true;
            }
        }
        // 目标目录不存在返回 false
        if (!createOrExistsDir(destDir)) return false;
        File[] files = srcDir.listFiles();
        for (File file : files) {
            File oneDestFile = new File(destPath + file.getName());
            if (file.isFile()) {
                // 如果操作失败返回 false
                if (!copyOrMoveFile(file, oneDestFile, listener, isMove)) return false;
            } else if (file.isDirectory()) {
                // 如果操作失败返回 false
                if (!copyOrMoveDir(file, oneDestFile, listener, isMove)) return false;
            }
        }
        return !isMove || deleteDir(srcDir);
    }

    /**
     * 复制或移动文件
     * @param srcFilePath  源文件路径
     * @param destFilePath 目标文件路径
     * @param listener     是否覆盖监听器
     * @param isMove       是否移动
     * @return {@code true} 复制或移动成功, {@code false} 复制或移动失败
     */
    public static boolean copyOrMoveFile(final String srcFilePath, final String destFilePath, final OnReplaceListener listener, final boolean isMove) {
        return copyOrMoveFile(getFileByPath(srcFilePath), getFileByPath(destFilePath), listener, isMove);
    }

    /**
     * 复制或移动文件
     * @param srcFile  源文件
     * @param destFile 目标文件
     * @param listener 是否覆盖监听器
     * @param isMove   是否移动
     * @return {@code true} 复制或移动成功, {@code false} 复制或移动失败
     */
    public static boolean copyOrMoveFile(final File srcFile, final File destFile, final OnReplaceListener listener, final boolean isMove) {
        if (srcFile == null || destFile == null || listener == null) return false;
        // 如果源文件和目标文件相同则返回 false
        if (srcFile.equals(destFile)) return false;
        // 源文件不存在或者不是文件则返回 false
        if (!srcFile.exists() || !srcFile.isFile()) return false;
        if (destFile.exists()) { // 目标文件存在
            if (listener.onReplace()) { // 需要覆盖则删除旧文件
                if (!destFile.delete()) { // 删除文件失败的话返回 false
                    return false;
                }
            } else { // 不需要覆盖直接返回即可 true
                return true;
            }
        }
        // 目标目录不存在返回 false
        if (!createOrExistsDir(destFile.getParentFile())) return false;
        try {
            return FileIOUtils.writeFileFromIS(destFile, new FileInputStream(srcFile), false) && !(isMove && !deleteFile(srcFile));
        } catch (FileNotFoundException e) {
            JCLogUtils.eTag(TAG, e, "copyOrMoveFile");
            return false;
        }
    }

    /**
     * 复制目录
     * @param srcDirPath  源目录路径
     * @param destDirPath 目标目录路径
     * @param listener    是否覆盖监听器
     * @return {@code true} 复制成功, {@code false} 复制失败
     */
    public static boolean copyDir(final String srcDirPath, final String destDirPath, final OnReplaceListener listener) {
        return copyDir(getFileByPath(srcDirPath), getFileByPath(destDirPath), listener);
    }

    /**
     * 复制目录
     * @param srcDir   源目录
     * @param destDir  目标目录
     * @param listener 是否覆盖监听器
     * @return {@code true} 复制成功, {@code false} 复制失败
     */
    public static boolean copyDir(final File srcDir, final File destDir, final OnReplaceListener listener) {
        return copyOrMoveDir(srcDir, destDir, listener, false);
    }

    /**
     * 复制文件
     * @param srcFilePath  源文件路径
     * @param destFilePath 目标文件路径
     * @param listener     是否覆盖监听器
     * @return {@code true} 复制成功, {@code false} 复制失败
     */
    public static boolean copyFile(final String srcFilePath, final String destFilePath, final OnReplaceListener listener) {
        return copyFile(getFileByPath(srcFilePath), getFileByPath(destFilePath), listener);
    }

    /**
     * 复制文件
     * @param srcFile  源文件
     * @param destFile 目标文件
     * @param listener 是否覆盖监听器
     * @return {@code true} 复制成功, {@code false} 复制失败
     */
    public static boolean copyFile(final File srcFile, final File destFile, final OnReplaceListener listener) {
        return copyOrMoveFile(srcFile, destFile, listener, false);
    }

    /**
     * 移动目录
     * @param srcDirPath  源目录路径
     * @param destDirPath 目标目录路径
     * @param listener    是否覆盖监听器
     * @return {@code true} 移动成功, {@code false} 移动失败
     */
    public static boolean moveDir(final String srcDirPath, final String destDirPath, final OnReplaceListener listener) {
        return moveDir(getFileByPath(srcDirPath), getFileByPath(destDirPath), listener);
    }

    /**
     * 移动目录
     * @param srcDir   源目录
     * @param destDir  目标目录
     * @param listener 是否覆盖监听器
     * @return {@code true} 移动成功, {@code false} 移动失败
     */
    public static boolean moveDir(final File srcDir, final File destDir, final OnReplaceListener listener) {
        return copyOrMoveDir(srcDir, destDir, listener, true);
    }

    /**
     * 移动文件
     * @param srcFilePath  源文件路径
     * @param destFilePath 目标文件路径
     * @param listener     是否覆盖监听器
     * @return {@code true} 移动成功, {@code false} 移动失败
     */
    public static boolean moveFile(final String srcFilePath, final String destFilePath, final OnReplaceListener listener) {
        return moveFile(getFileByPath(srcFilePath), getFileByPath(destFilePath), listener);
    }

    /**
     * 移动文件
     * @param srcFile  源文件
     * @param destFile 目标文件
     * @param listener 是否覆盖监听器
     * @return {@code true} 移动成功, {@code false} 移动失败
     */
    public static boolean moveFile(final File srcFile, final File destFile, final OnReplaceListener listener) {
        return copyOrMoveFile(srcFile, destFile, listener, true);
    }

    /**
     * 删除目录
     * @param dirPath 目录路径
     * @return {@code true} 删除成功, {@code false} 删除失败
     */
    public static boolean deleteDir(final String dirPath) {
        return deleteDir(getFileByPath(dirPath));
    }

    /**
     * 删除目录
     * @param dir 目录
     * @return {@code true} 删除成功, {@code false} 删除失败
     */
    public static boolean deleteDir(final File dir) {
        if (dir == null) return false;
        // dir doesn't exist then return true
        if (!dir.exists()) return true;
        // dir isn't a directory then return false
        if (!dir.isDirectory()) return false;
        File[] files = dir.listFiles();
        if (files != null && files.length != 0) {
            for (File file : files) {
                if (file.isFile()) {
                    if (!file.delete()) return false;
                } else if (file.isDirectory()) {
                    if (!deleteDir(file)) return false;
                }
            }
        }
        return dir.delete();
    }

    /**
     * 删除目录下所有东西
     * @param dirPath 目录路径
     * @return {@code true} 删除成功, {@code false} 删除失败
     */
    public static boolean deleteAllInDir(final String dirPath) {
        return deleteAllInDir(getFileByPath(dirPath));
    }

    /**
     * 删除目录下所有东西
     * @param dir 目录
     * @return {@code true} 删除成功, {@code false} 删除失败
     */
    public static boolean deleteAllInDir(final File dir) {
        return deleteFilesInDirWithFilter(dir, new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                return true;
            }
        });
    }

    /**
     * 删除目录下所有文件
     * @param dirPath 目录路径
     * @return {@code true} 删除成功, {@code false} 删除失败
     */
    public static boolean deleteFilesInDir(final String dirPath) {
        return deleteFilesInDir(getFileByPath(dirPath));
    }

    /**
     * 删除目录下所有文件
     * @param dir 目录
     * @return {@code true} 删除成功, {@code false} 删除失败
     */
    public static boolean deleteFilesInDir(final File dir) {
        return deleteFilesInDirWithFilter(dir, new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                return pathname.isFile();
            }
        });
    }

    /**
     * 删除目录下所有过滤的文件
     * @param dirPath 目录路径
     * @param filter  过滤器
     * @return {@code true} 删除成功, {@code false} 删除失败
     */
    public static boolean deleteFilesInDirWithFilter(final String dirPath, final FileFilter filter) {
        return deleteFilesInDirWithFilter(getFileByPath(dirPath), filter);
    }

    /**
     * 删除目录下所有过滤的文件
     * @param dir    目录
     * @param filter 过滤器
     * @return {@code true} 删除成功, {@code false} 删除失败
     */
    public static boolean deleteFilesInDirWithFilter(final File dir, final FileFilter filter) {
        if (filter == null) return false;
        // dir is null then return false
        if (dir == null) return false;
        // dir doesn't exist then return true
        if (!dir.exists()) return true;
        // dir isn't a directory then return false
        if (!dir.isDirectory()) return false;
        File[] files = dir.listFiles();
        if (files != null && files.length != 0) {
            for (File file : files) {
                if (filter.accept(file)) {
                    if (file.isFile()) {
                        if (!file.delete()) return false;
                    } else if (file.isDirectory()) {
                        if (!deleteDir(file)) return false;
                    }
                }
            }
        }
        return true;
    }

    /**
     * 获取目录下所有文件 - 不递归进子目录
     * @param dirPath 目录路径
     * @return 文件链表
     */
    public static List<File> listFilesInDir(final String dirPath) {
        return listFilesInDir(dirPath, false);
    }

    /**
     * 获取目录下所有文件 - 不递归进子目录
     * @param dir 目录
     * @return 文件链表
     */
    public static List<File> listFilesInDir(final File dir) {
        return listFilesInDir(dir, false);
    }

    /**
     * 获取目录下所有文件
     * @param dirPath     目录路径
     * @param isRecursive 是否递归进子目录
     * @return 文件链表
     */
    public static List<File> listFilesInDir(final String dirPath, final boolean isRecursive) {
        return listFilesInDir(getFileByPath(dirPath), isRecursive);
    }

    /**
     * 获取目录下所有文件
     * @param dir         目录
     * @param isRecursive 是否递归进子目录
     * @return 文件链表
     */
    public static List<File> listFilesInDir(final File dir, final boolean isRecursive) {
        return listFilesInDirWithFilter(dir, new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                return true;
            }
        }, isRecursive);
    }

    /**
     * 获取目录下所有过滤的文件 - 不递归进子目录
     * @param dirPath 目录路径
     * @param filter  过滤器
     * @return 文件链表
     */
    public static List<File> listFilesInDirWithFilter(final String dirPath, final FileFilter filter) {
        return listFilesInDirWithFilter(getFileByPath(dirPath), filter, false);
    }

    /**
     * 获取目录下所有过滤的文件 - 不递归进子目录
     * @param dir    目录
     * @param filter 过滤器
     * @return 文件链表
     */
    public static List<File> listFilesInDirWithFilter(final File dir, final FileFilter filter) {
        return listFilesInDirWithFilter(dir, filter, false);
    }

    /**
     * 获取目录下所有过滤的文件
     * @param dirPath     目录路径
     * @param filter      过滤器
     * @param isRecursive 是否递归进子目录
     * @return 文件链表
     */
    public static List<File> listFilesInDirWithFilter(final String dirPath, final FileFilter filter, final boolean isRecursive) {
        return listFilesInDirWithFilter(getFileByPath(dirPath), filter, isRecursive);
    }

    /**
     * 获取目录下所有过滤的文件
     * @param dir         目录
     * @param filter      过滤器
     * @param isRecursive 是否递归进子目录
     * @return 文件链表
     */
    public static List<File> listFilesInDirWithFilter(final File dir, final FileFilter filter, final boolean isRecursive) {
        if (!isDirectory(dir) || filter == null) return null;
        List<File> list = new ArrayList<>();
        File[] files = dir.listFiles();
        if (files != null && files.length != 0) {
            for (File file : files) {
                if (filter.accept(file)) {
                    list.add(file);
                }
                if (isRecursive && file.isDirectory()) {
                    list.addAll(listFilesInDirWithFilter(file, filter, true));
                }
            }
        }
        return list;
    }

    // =

    /**
     * detail: 文件列表
     * @author Ttt
     */
    public static class FileList {

        // 当前文件夹
        private File mFile;
        // 文件夹内子文件列表
        private List<FileList> mSubFiles;

        /**
         * 构造函数
         * @param file 当前文件夹
         */
        public FileList(File file) {
            this(file, new ArrayList<>(0));
        }

        /**
         * 构造函数
         * @param file  当前文件夹
         * @param lists 文件夹内子文件列表
         */
        public FileList(File file, List<FileList> lists) {
            this.mFile = file;
            this.mSubFiles = lists;
        }

        // =

        /**
         * 获取当前文件夹
         * @return {@link File}
         */
        public File getFile() {
            return mFile;
        }

        /**
         * 获取文件夹内子文件列表
         * @return {@link ArrayList}
         */
        public List<FileList> getSubFiles() {
            return mSubFiles;
        }
    }

    // =

    /**
     * 获取目录下所有文件 - 不递归进子目录
     * @param dirPath 目录路径
     * @return 文件链表
     */
    public static List<FileList> listFilesInDirBean(final String dirPath) {
        return listFilesInDirBean(dirPath, false);
    }

    /**
     * 获取目录下所有文件 - 不递归进子目录
     * @param dir 目录
     * @return 文件链表
     */
    public static List<FileList> listFilesInDirBean(final File dir) {
        return listFilesInDirBean(dir, false);
    }

    /**
     * 获取目录下所有文件
     * @param dirPath     目录路径
     * @param isRecursive 是否递归进子目录
     * @return 文件链表
     */
    public static List<FileList> listFilesInDirBean(final String dirPath, final boolean isRecursive) {
        return listFilesInDirBean(getFileByPath(dirPath), isRecursive);
    }

    /**
     * 获取目录下所有文件
     * @param dir         目录
     * @param isRecursive 是否递归进子目录
     * @return 文件链表
     */
    public static List<FileList> listFilesInDirBean(final File dir, final boolean isRecursive) {
        return listFilesInDirWithFilterBean(dir, new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                return true;
            }
        }, isRecursive);
    }

    /**
     * 获取目录下所有过滤的文件 - 不递归进子目录
     * @param dirPath 目录路径
     * @param filter  过滤器
     * @return 文件链表
     */
    public static List<FileList> listFilesInDirWithFilterBean(final String dirPath, final FileFilter filter) {
        return listFilesInDirWithFilterBean(getFileByPath(dirPath), filter, false);
    }

    /**
     * 获取目录下所有过滤的文件 - 不递归进子目录
     * @param dir    目录
     * @param filter 过滤器
     * @return 文件链表
     */
    public static List<FileList> listFilesInDirWithFilterBean(final File dir, final FileFilter filter) {
        return listFilesInDirWithFilterBean(dir, filter, false);
    }

    /**
     * 获取目录下所有过滤的文件
     * @param dirPath     目录路径
     * @param filter      过滤器
     * @param isRecursive 是否递归进子目录
     * @return 文件链表
     */
    public static List<FileList> listFilesInDirWithFilterBean(final String dirPath, final FileFilter filter, final boolean isRecursive) {
        return listFilesInDirWithFilterBean(getFileByPath(dirPath), filter, isRecursive);
    }

    /**
     * 获取目录下所有过滤的文件
     * @param dir         目录
     * @param filter      过滤器
     * @param isRecursive 是否递归进子目录
     * @return 文件链表
     */
    public static List<FileList> listFilesInDirWithFilterBean(final File dir, final FileFilter filter, final boolean isRecursive) {
        if (!isDirectory(dir) || filter == null) return null;
        List<FileList> list = new ArrayList<>();
        File[] files = dir.listFiles();
        if (files != null && files.length != 0) {
            for (File file : files) {
                if (filter.accept(file)) {
                    FileList fileList;
                    if (isRecursive && file.isDirectory()) {
                        List<FileList> subs = listFilesInDirWithFilterBean(file, filter, true);
                        fileList = new FileList(file, subs);
                    } else {
                        fileList = new FileList(file);
                    }
                    list.add(fileList);
                }
            }
        }
        return list;
    }

    // ================
    // = 图片类型判断 =
    // ================

    // 图片格式
    private static final String[] IMAGE_FORMATS = new String[]{".PNG", ".JPG", ".JPEG", ".BMP", ".GIF", ".WEBP"};

    /**
     * 根据文件名判断文件是否为图片
     * @param file 文件
     * @return {@code true} yes, {@code false} no
     */
    public static boolean isImageFormats(final File file) {
        return file != null && isImageFormats(file.getPath(), IMAGE_FORMATS);
    }

    /**
     * 根据文件名判断文件是否为图片
     * @param filePath 文件路径
     * @return {@code true} yes, {@code false} no
     */
    public static boolean isImageFormats(final String filePath) {
        return isImageFormats(filePath, IMAGE_FORMATS);
    }

    /**
     * 根据文件名判断文件是否为图片
     * @param filePath    文件路径
     * @param fileFormats 文件格式
     * @return {@code true} yes, {@code false} no
     */
    public static boolean isImageFormats(final String filePath, final String[] fileFormats) {
        return isFileFormats(filePath, fileFormats);
    }

    // ================
    // = 音频类型判断 =
    // ================

    // 音频格式
    private static final String[] AUDIO_FORMATS = new String[]{".MP3", ".AAC", ".OGG", ".WMA", ".APE", ".FLAC", ".RA"};

    /**
     * 根据文件名判断文件是否为音频
     * @param file 文件
     * @return {@code true} yes, {@code false} no
     */
    public static boolean isAudioFormats(final File file) {
        return file != null && isAudioFormats(file.getPath(), AUDIO_FORMATS);
    }

    /**
     * 根据文件名判断文件是否为音频
     * @param filePath 文件路径
     * @return {@code true} yes, {@code false} no
     */
    public static boolean isAudioFormats(final String filePath) {
        return isAudioFormats(filePath, AUDIO_FORMATS);
    }

    /**
     * 根据文件名判断文件是否为音频
     * @param filePath    文件路径
     * @param fileFormats 文件格式
     * @return {@code true} yes, {@code false} no
     */
    public static boolean isAudioFormats(final String filePath, final String[] fileFormats) {
        return isFileFormats(filePath, fileFormats);
    }

    // ================
    // = 视频类型判断 =
    // ================

    // 视频格式
    private static final String[] VIDEO_FORMATS = new String[]{".MP4", ".AVI", ".MOV", ".ASF", ".MPG", ".MPEG", ".WMV", ".RM", ".RMVB", ".3GP", ".MKV"};

    /**
     * 根据文件名判断文件是否为视频
     * @param file 文件
     * @return {@code true} yes, {@code false} no
     */
    public static boolean isVideoFormats(final File file) {
        return file != null && isVideoFormats(file.getPath(), VIDEO_FORMATS);
    }

    /**
     * 根据文件名判断文件是否为视频
     * @param filePath 文件路径
     * @return {@code true} yes, {@code false} no
     */
    public static boolean isVideoFormats(final String filePath) {
        return isVideoFormats(filePath, VIDEO_FORMATS);
    }

    /**
     * 根据文件名判断文件是否为视频
     * @param filePath    文件路径
     * @param fileFormats 文件格式
     * @return {@code true} yes, {@code false} no
     */
    public static boolean isVideoFormats(final String filePath, final String[] fileFormats) {
        return isFileFormats(filePath, fileFormats);
    }

    // =

    /**
     * 根据文件名判断文件是否为指定格式
     * @param file        文件
     * @param fileFormats 文件格式
     * @return {@code true} yes, {@code false} no
     */
    public static boolean isFileFormats(final File file, final String[] fileFormats) {
        return file != null && isFileFormats(file.getPath(), fileFormats);
    }

    /**
     * 根据文件名判断文件是否为指定格式
     * @param filePath    文件路径
     * @param fileFormats 文件格式
     * @return {@code true} yes, {@code false} no
     */
    public static boolean isFileFormats(final String filePath, final String[] fileFormats) {
        if (filePath == null || fileFormats == null || fileFormats.length == 0) return false;
        String path = filePath.toUpperCase();
        for (String format : fileFormats) {
            if (format != null) {
                if (path.endsWith(format.toUpperCase())) {
                    return true;
                }
            }
        }
        return false;
    }

    // ============
    // = MD5Utils =
    // ============

    /**
     * 获取文件 MD5 值
     * @param filePath 文件路径
     * @return 文件 MD5 值
     */
    public static byte[] getFileMD5(final String filePath) {
        return MD5Utils.getFileMD5(filePath);
    }

    /**
     * 获取文件 MD5 值
     * @param filePath 文件路径
     * @return 文件 MD5 值转十六进制字符串
     */
    public static String getFileMD5ToHexString(final String filePath) {
        return MD5Utils.getFileMD5ToHexString(filePath);
    }

    /**
     * 获取文件 MD5 值
     * @param file 文件
     * @return 文件 MD5 值转十六进制字符串
     */
    public static String getFileMD5ToHexString(final File file) {
        return MD5Utils.getFileMD5ToHexString(file);
    }

    /**
     * 获取文件 MD5 值
     * @param file 文件
     * @return 文件 MD5 值 byte[]
     */
    public static byte[] getFileMD5(final File file) {
        return MD5Utils.getFileMD5(file);
    }
}