java substring 年月字符串截取年 java怎么截取日期的年月日

转载

mob64ca140dc73b 2024-07-10 15:25:03

1. 删除指定文件夹底下的文件夹及文件

1.1 使用FileUtils删除

优点：使用工具类，代码干净，速度快
缺点：无法屏蔽一些不想删除或者根据条件删除文件，无法得知删除数量

1.1.1 引入依赖

<dependency>
            <groupId>commons-fileupload</groupId>
            <artifactId>commons-fileupload</artifactId>
            <version>1.3.3</version>
        </dependency>

1.1.2 使用

File file = new File("/home/yhc/workSpace/log");        
        try {
            FileUtils.deleteDirectory(file);
        } catch (IOException e) {
            e.printStackTrace();
        }

1.1.3 其他功能

2.1 参数

参数名	含义	默认值
path	删除的文件路径，支持多个路径，用	分割
PATH_PATTERN	切割路径含有/[或[的正则表达式	Pattern.compile(“^((?![\\/]\[).)*”)
RULE_PATTERN	切割路径含有[的正则表达式	Pattern.compile(“\[.*”)
days	保留天数，超过此天数的文件将被删除	30
dayTimes	一天的毫秒数	24 * 60 * 60 * 1000
ignoreName	忽略的文件名，多个文件名用;分割	123.txt;123.log
pathRetention	是否按路径删除文件	true
	下列为多线程特有参数
threadNum	线程池大小	2

path入参必须含有yyyy mm dd 不区分大小写，/不区分。类似[YYYY]/[YYYYMM]/[YYYYMMDD]、[YYYY]/[MM]/[DD]、[YYYYMMDD]、[YYYY]/[YYYYMM]/[DD]等皆支持

2.2 代码（单线程）

package com.api.apidemo.tool.file;

import org.apache.commons.lang3.StringUtils;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.attribute.BasicFileAttributeView;
import java.nio.file.attribute.BasicFileAttributes;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @author yhc
 * @description 批量删除文件-普通方式
 */
public class BatchDeleteFile {
    /**
     * 删除的文件路径，支持多个路径，用|分割
     */
    public static final String path = "/home/cathay10/workSpace/log/[yyyyMMdd]";
    /**
     * 切割路径含有/[或\[的正则表达式
     */
    public static final Pattern PATH_PATTERN = Pattern.compile("^((?![\\\\/]\\[).)*");
    /**
     * 切割路径含有[的正则表达式
     */
    public static final Pattern RULE_PATTERN = Pattern.compile("\\[.*");
    /**
     * 保留天数，超过此天数的文件将被删除
     */
    public static final int days = 30;
    /**
     * 一天的毫秒数
     */
    public static final int dayTimes = 24 * 60 * 60 * 1000;
    /**
     * 忽略的文件名，多个文件名用;分割
     */
    public static final String ignoreName = "123.txt;123.log";
    /**
     * 是否按路径删除文件
     */
    public static final boolean pathRetention = true;

    public static void main(String[] args) {
        long begin = System.currentTimeMillis();
        long num = batchDeleteFile();
        // 打印总删除文件数
        long stop = System.currentTimeMillis();
        System.out.println("执行结束，耗时：" + (stop - begin) + "ms" + " 删除文件数量：" + num);
    }

    /**
     * 批量删除文件
     */
    public static long batchDeleteFile() {
        // 删除数量
        long num = 0;
        // 删除路径集合 有需要可以添加多个路径，按 | 分割
        List sourceList = Arrays.asList(path.split("\\|"));
        int length = sourceList.size();
        if (length > 0) {
            for (int m = 0; m < length; m++) {
                // 判断目录是否含有日期格式
                String targetPath = replaceDate(sourceList.get(m).toString());
                // 处理通配符，将路径中的通配符替换为正则表达式
                targetPath = replaceWildcard(targetPath);
                if (pathRetention) {
                    // 按日期格式路径删除文件
                    // 截取掉除了年月日之外的路径
                    String dirPath = pathSplit(sourceList.get(m).toString());
                    File dir = new File(dirPath);
                    if (dir.exists()) {
                        // 当前日期
                        LocalDate nowDate = LocalDate.now();
                        String rule = ruleSplit(sourceList.get(m).toString());
                        num = num + judgeDocumentPath(dir, ignoreName, nowDate, rule);
                    }
                } else {
                    String dirPath = pathSplit(targetPath);
                    // 按最后修改时间删除文件
                    File file = new File(dirPath);
                    if (file.exists()) {
                        num = num + judgeDocument(file, ignoreName);
                    }
                }
            }
        }
        return num;
    }

    /**
     * 处理文件路径，替换日期格式占位符为当前日期
     *
     * @param path 原始路径
     * @return 处理后的路径，如果没有找到日期占位符，则返回原路径
     */
    public static String replaceDate(String path) {
        String targetPath;
        if (StringUtils.containsIgnoreCase(path, "[yyyy]/[MM]/[dd]")) {
            targetPath = replaceIgnoreCase(path, "[yyyy]/[MM]/[dd]", LocalDate.now().toString().replace("-", "/"));
        } else if (StringUtils.containsIgnoreCase(path, "[yyyyMMdd]")) {
            targetPath = replaceIgnoreCase(path, "[yyyymmdd]", LocalDate.now().toString().replace("-", ""));
        } else {
            targetPath = path;
        }
        return targetPath;
    }

    /**
     * 处理文件路径，将路径中的通配符替换为正则表达式
     *
     * @param path 原始路径
     * @return 处理后的路径，如果没有找到通配符，则返回原路径
     */
    public static String replaceWildcard(String path) {
        path.replaceAll("\\*", ".*").replaceAll("\\?", ".");
        return path;
    }

    /**
     * 获取路径中是否包含日期格式
     *
     * @param targetPath 路径
     * @return 处理后的路径，截取第一次遇到日期格式前的路径，如果没有找到有效的日期格式，则返回原路径
     */
    public static String pathSplit(String targetPath) {
        Matcher pathMatcher = PATH_PATTERN.matcher(targetPath);
        while (pathMatcher.find()) {
            if (pathMatcher.group() != null) {
                return pathMatcher.group();
            }
        }
        // 没有找到有效的日期
        return null;
    }

    /**
     * 获取路径中的日期规则正则
     *
     * @param targetPath 路径
     * @return 规则正则
     */
    public static String ruleSplit(String targetPath) {
        Matcher ruleMatcher = RULE_PATTERN.matcher(targetPath);
        String ruleContent;
        while (ruleMatcher.find()) {
            ruleContent = replaceCharsInSquareBrackets(ruleMatcher.group());
            if (ruleContent != null) {
                return ruleContent;
            }
        }
        // 没有找到有效的日期
        return null;
    }

    /**
     * 替换方括号内的时间格式字符，分隔符[]
     *
     * @param str
     * @return 替换后的字符串
     */
    public static String replaceCharsInSquareBrackets(String str) {
        // 正则表达式匹配方括号内的内容
        String regex = "\\[(.*?)\\]";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(str);

        // 存储原始和替换后的内容
        List<String> originalMatches = new ArrayList<>();
        List<String> replacedMatches = new ArrayList<>();

        // 提取匹配的内容并进行替换
        while (matcher.find()) {
            originalMatches.add(matcher.group());
            String match = matcher.group();
            String match2 = match.replace("YYYY", "yyyy").replace("mm", "MM").replace("DD", "dd");
            replacedMatches.add(match2);
        }

        // 将原始字符串分解，然后用替换后的内容替换匹配的子串
        StringBuilder replacedStr = new StringBuilder(str);
        for (int i = 0; i < originalMatches.size(); i++) {
            int startIndex = replacedStr.indexOf(originalMatches.get(i));
            int endIndex = startIndex + originalMatches.get(i).length();
            replacedStr.replace(startIndex, endIndex, replacedMatches.get(i));
        }
        return replacedStr.toString().replaceAll("\\[", "").replaceAll("\\]", "");
    }

    /**
     * 替换字符串，不区分大小写
     *
     * @param original 原始字符串
     * @param from     要替换的字符串
     * @param to       替换后的字符串
     * @return 替换后的字符串
     */
    public static String replaceIgnoreCase(String original, String from, String to) {
        // 将要查找的字符串转换为正则表达式形式，并添加不区分大小写的标志(?i)
        String regex = "(?i)" + Pattern.quote(from);

        // 使用正则表达式进行替换
        return original.replaceAll(regex, to);
    }

    /**
     * 文件处理
     *
     * @param file       要处理的文件夹
     * @param ignoreName 忽略文件名
     * @return 处理的文件数量
     */
    public static long judgeDocumentPath(File file, String ignoreName, LocalDate nowDate, String rule) {
        long num = 0;
        File[] files = file.listFiles();
        for (File file1 : files) {
            if (file1.isDirectory()) {
                //调用方法循环完成对文件夹中文件的删除
                Pattern PATH_RELE_PATTERN = Pattern.compile(rule.replaceAll("[/\\\\]", "[/\\\\\\\\]").replace("yyyy", "(\\d{4})").replace("MM", "(\\d{2})").replace("dd", "(\\d{2})"));
                Matcher matcher = PATH_RELE_PATTERN.matcher(file1.getAbsolutePath());
                if (matcher.find()) {
                    LocalDate pathDate = dateConversion(matcher.group(), rule);
                    long betweenDays = ChronoUnit.DAYS.between(pathDate, nowDate);
                    if (betweenDays > days) {
                        num = num + delFilePath(file1, ignoreName);
                    }
                } else {
                    //调用方法循环完成对文件夹中文件的删除
                    num = num + judgeDocumentPath(file1, ignoreName, nowDate, rule);
                }
            }
        }
        return num;
    }

    /**
     * 循环删除目录下的文件
     *
     * @param file 要删除的文件夹
     * @return 处理的文件数量
     */
    public static long delFilePath(File file, String ignoreName) {
        long num = 0;
        if (file.list().length < 1) {
            deleteDirectoryPath(file);
        } else {
            File[] files = file.listFiles();
            for (File file1 : files) {
                if (file1.isDirectory()) {
                    num = num + delFilePath(file1, ignoreName);
                } else if (!getIsNotLike(ignoreName, file1.getName())) {
                    file1.delete();
                    ++num;
                }
            }
            deleteDirectoryPath(file);
        }
        return num;
    }

    /**
     * 删除文件夹
     *
     * @param files
     */
    public static void deleteDirectoryPath(File files) {
        if (files.exists() && files.list().length < 1) {
            try {
                Path path = files.toPath();
                Files.delete(path);
                deleteDirectoryPath(new File(path.getParent().toString()));
            } catch (IOException e) {
            }
        }
    }

    /**
     * 判断文件名中是否包含关键字，如果包含则剔除
     *
     * @param notLikeStr
     * @param fileName
     * @return
     */
    public static boolean getIsNotLike(String notLikeStr, String fileName) {
        String[] strArr = notLikeStr.split(";");
        for (int i = 0; i < strArr.length; i++) {
            if (fileName.contains(strArr[i])) {
                return true;
            }
        }
        return false;
    }

    /**
     * 判断文件是否过期，如果过期则删除
     *
     * @param file       要处理的文件
     * @param ignoreName 忽略文件名
     * @return 处理的文件数量
     */
    private static long judgeDocument(File file, String ignoreName) {
        long num = 0;
        File[] files = file.listFiles();
        for (File file1 : files) {
            if (file1.isDirectory()) {
                //调用方法循环完成对文件夹中文件的删除
                num = num + delFile(file1, ignoreName);
            } else {
                num = num + analysisFiles(file1, ignoreName);
            }
        }
        return num;
    }

    /**
     * 判断文件是否过期，如果过期则删除
     *
     * @param file       要处理的文件
     * @param ignoreName 忽略文件名
     * @return 处理的文件数量
     */
    public static long delFile(File file, String ignoreName) {
        long num = 0;
        if (file.list().length < 1) {
            deleteDirectory(file);
        } else {
            File[] files = file.listFiles();
            for (File file1 : files) {
                if (file1.isDirectory()) {
                    num = num + delFile(file1, ignoreName);
                } else {
                    num = num + analysisFiles(file1, ignoreName);
                }
                deleteDirectory(file);
            }
        }
        return num;
    }

    /**
     * 删除文件夹
     *
     * @param files 要删除的文件夹
     */
    public static void deleteDirectory(File files) {
        if (files.list().length < 1) {
            try {
                Path path = files.toPath();
                Files.delete(path);
            } catch (IOException e) {
            }
        }
    }

    /**
     * 判断文件是否过期，如果过期则删除
     *
     * @param file       要处理的文件
     * @param ignoreName 忽略文件名
     * @return 处理的文件数量
     */
    public static long analysisFiles(File file, String ignoreName) {

        long num = 0;
        //系统当前时间
        double nowTime = System.currentTimeMillis();
        Path path = file.toPath();
        //根据创建时间和系统当前时间判断文件存在时间是否大于要求天数（CLEANTIMEs * 24 * 60 * 60 * 1000）
        try {
            BasicFileAttributeView basicView = Files.getFileAttributeView(path, BasicFileAttributeView.class);
            BasicFileAttributes basicAttribs = basicView.readAttributes();
            String fileName = file.getName();
            if (getIsNotLike(ignoreName, fileName)) {
                return 0;
            }
            //最后修改时间
            Date savaTime = new Date(basicAttribs.lastModifiedTime().toMillis());
            double saveTimes = savaTime.getTime();
            if (nowTime - saveTimes > (double) days * dayTimes) {
                Files.delete(path);
                ++num;
            }
        } catch (IOException e1) {
        }
        return num;
    }

    /**
     * 转换日期格式，支持格式为：formats
     *
     * @param path 路径
     * @return LocalDate 转换后的日期
     */
    public static LocalDate dateConversion(String path, String rule) {
        String[] formats = {rule.replace("\\", "/"), rule.replace("/", "\\")};
        for (String format : formats) {
            try {
                LocalDate localDate = LocalDate.parse(path, DateTimeFormatter.ofPattern(format));
                if (localDate != null) {
                    return localDate;
                }
            } catch (DateTimeParseException e) {
                // 没有找到有效的日期
            }
        }
        return null;
    }
}

2.3 代码（线程池）

package com.api.apidemo.tool.file;

import org.apache.commons.lang3.StringUtils;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.attribute.BasicFileAttributeView;
import java.nio.file.attribute.BasicFileAttributes;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.concurrent.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @author yhc
 * @description: 批量删除文件-多线程方式
 */
public class BatchDeleteFileThread {
    /**
     * 删除的文件路径，支持多个路径，用|分割
     */
    public static final String path = "/home/cathay10/workSpace/log/[yyyy]/[MM]/[dd]";
    /**
     * 切割路径含有/[或\[的正则表达式
     */
    public static final Pattern PATH_PATTERN = Pattern.compile("^((?![\\\\/]\\[).)*");
    /**
     * 切割路径含有[的正则表达式
     */
    public static final Pattern RULE_PATTERN = Pattern.compile("\\[.*");
    /**
     * 保留天数，超过此天数的文件将被删除
     */
    public static final int days = 30;
    /**
     * 一天的毫秒数
     */
    public static final int dayTimes = 24 * 60 * 60 * 1000;
    /**
     * 线程池大小
     */
    public static final int threadNum = 2;
    /**
     * 忽略的文件名，多个文件名用;分割
     */
    public static final String ignoreName = "123.txt;123.log";
    /**
     * 是否按路径删除文件
     */
    public static final boolean pathRetention = true;

    public static void main(String[] args) {
        long begin = System.currentTimeMillis();
        long num = batchDeleteFile();

        // 打印总删除文件数
        long stop = System.currentTimeMillis();
        System.out.println("执行结束，耗时：" + (stop - begin) + "ms" + " 删除文件数量：" + num);
    }

    /**
     * 批量删除文件
     */
    public static long batchDeleteFile() {
        // 删除数量
        long num = 0;
        // 删除路径集合 有需要可以添加多个路径，按 | 分割
        List sourceList = Arrays.asList(path.split("\\|"));
        int length = sourceList.size();
        if (length > 0) {
            for (int m = 0; m < length; m++) {
                // 判断目录是否含有日期格式
                String targetPath = replaceDate(sourceList.get(m).toString());
                // 处理通配符，将路径中的通配符替换为正则表达式
                targetPath = replaceWildcard(targetPath);
                if (pathRetention) {
                    // 按日期格式路径删除文件
                    // 截取掉除了年月日之外的路径
                    String dirPath = pathSplit(sourceList.get(m).toString());
                    File dir = new File(dirPath);
                    if (dir.exists()) {
                        // 当前日期
                        LocalDate nowDate = LocalDate.now();
                        String rule = ruleSplit(sourceList.get(m).toString());
                        num = num + judgeDocumentPath(dir, ignoreName, nowDate, rule);
                    }
                } else {
                    String dirPath = pathSplit(targetPath);
                    // 按最后修改时间删除文件
                    File file = new File(dirPath);
                    if (file.exists()) {
                        num = num + judgeDocument(file, ignoreName);
                    }
                }
            }
        }
        return num;
    }

    /**
     * 处理文件路径，替换日期格式占位符为当前日期
     *
     * @param path 原始路径
     * @return 处理后的路径，如果没有找到日期占位符，则返回原路径
     */
    public static String replaceDate(String path) {
        String targetPath;
        if (StringUtils.containsIgnoreCase(path, "[yyyy]/[MM]/[dd]")) {
            targetPath = replaceIgnoreCase(path, "[yyyy]/[MM]/[dd]", LocalDate.now().toString().replace("-", "/"));
        } else if (StringUtils.containsIgnoreCase(path, "[yyyyMMdd]")) {
            targetPath = replaceIgnoreCase(path, "[yyyymmdd]", LocalDate.now().toString().replace("-", ""));
        } else {
            targetPath = path;
        }
        return targetPath;
    }

    /**
     * 处理文件路径，将路径中的通配符替换为正则表达式
     *
     * @param path 原始路径
     * @return 处理后的路径，如果没有找到通配符，则返回原路径
     */
    public static String replaceWildcard(String path) {
        path.replaceAll("\\*", ".*").replaceAll("\\?", ".");
        return path;
    }

    /**
     * 获取路径中是否包含日期格式，支持格式为：formats
     *
     * @param targetPath 路径
     * @return 处理后的路径，截取第一次遇到日期格式前的路径，如果没有找到有效的日期格式，则返回原路径
     */
    public static String pathSplit(String targetPath) {
        Matcher pathMatcher = PATH_PATTERN.matcher(targetPath);
        while (pathMatcher.find()) {
            if (pathMatcher.group() != null) {
                return pathMatcher.group();
            }
        }
        // 没有找到有效的日期
        return null;
    }

    /**
     * 获取路径中的日期规则正则
     *
     * @param targetPath 路径
     * @return 规则正则
     */
    public static String ruleSplit(String targetPath) {
        Matcher ruleMatcher = RULE_PATTERN.matcher(targetPath);
        String ruleContent;
        while (ruleMatcher.find()) {
            ruleContent = replaceCharsInSquareBrackets(ruleMatcher.group());
            if (ruleContent != null) {
                return ruleContent;
            }
        }
        // 没有找到有效的日期
        return null;
    }

    /**
     * 替换方括号内的时间格式字符，分隔符[]
     *
     * @param str
     * @return 替换后的字符串
     */
    public static String replaceCharsInSquareBrackets(String str) {
        // 正则表达式匹配方括号内的内容
        String regex = "\\[(.*?)\\]";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(str);

        // 存储原始和替换后的内容
        List<String> originalMatches = new ArrayList<>();
        List<String> replacedMatches = new ArrayList<>();

        // 提取匹配的内容并进行替换
        while (matcher.find()) {
            originalMatches.add(matcher.group());
            String match = matcher.group();
            String match2 = match.replace("YYYY", "yyyy").replace("mm", "MM").replace("DD", "dd");
            replacedMatches.add(match2);
        }

        // 将原始字符串分解，然后用替换后的内容替换匹配的子串
        StringBuilder replacedStr = new StringBuilder(str);
        for (int i = 0; i < originalMatches.size(); i++) {
            int startIndex = replacedStr.indexOf(originalMatches.get(i));
            int endIndex = startIndex + originalMatches.get(i).length();
            replacedStr.replace(startIndex, endIndex, replacedMatches.get(i));
        }
        return replacedStr.toString().replaceAll("\\[", "").replaceAll("\\]", "");
    }

    /**
     * 替换字符串，不区分大小写
     *
     * @param original 原始字符串
     * @param from     要替换的字符串
     * @param to       替换后的字符串
     * @return 替换后的字符串
     */
    public static String replaceIgnoreCase(String original, String from, String to) {
        // 将要查找的字符串转换为正则表达式形式，并添加不区分大小写的标志(?i)
        String regex = "(?i)" + Pattern.quote(from);

        // 使用正则表达式进行替换
        return original.replaceAll(regex, to);
    }

    /**
     * 文件处理
     *
     * @param file       要处理的文件夹
     * @param ignoreName 忽略文件名
     * @return 处理的文件数量
     */
    public static long judgeDocumentPath(File file, String ignoreName, LocalDate nowDate, String rule) {
        ExecutorService executorService = Executors.newFixedThreadPool(threadNum);
        long num = 0;
        File[] files = file.listFiles();
        for (File file1 : files) {
            Future<Long> future = executorService.submit(new DeleteFileCallable(pathRetention, file1, ignoreName, nowDate, rule));
            try {
                num = num + future.get();
            } catch (InterruptedException | ExecutionException e) {
                throw new RuntimeException(e);
            }
        }
        // 关闭线程池
        executorService.shutdown();
        return num;
    }

    /**
     * 文件处理
     *
     * @param file       要处理的文件夹
     * @param ignoreName 忽略文件名
     * @return 处理的文件数量
     */
    public static long threadJudgeDocumentPath(File file, String ignoreName, LocalDate nowDate, String rule) {
        long num = 0;
        File[] files = file.listFiles();

        if (file.isDirectory()) {
            //调用方法循环完成对文件夹中文件的删除
            Pattern PATH_RELE_PATTERN = Pattern.compile(rule.replaceAll("[/\\\\]", "[/\\\\\\\\]").replace("yyyy", "(\\d{4})").replace("MM", "(\\d{2})").replace("dd", "(\\d{2})"));
            Matcher matcher = PATH_RELE_PATTERN.matcher(file.getAbsolutePath());
            if (matcher.find()) {
                LocalDate pathDate = dateConversion(matcher.group(), rule);
                long betweenDays = ChronoUnit.DAYS.between(pathDate, nowDate);
                if (betweenDays > days) {
                    num = num + delFilePath(file, ignoreName);
                }
            } else {
                for (File file1 : files) {
                    //调用方法循环完成对文件夹中文件的删除
                    num = num + threadJudgeDocumentPath(file1, ignoreName, nowDate, rule);
                }
            }
        }
        return num;
    }

    /**
     * 循环删除目录下的文件
     *
     * @param file 要删除的文件夹
     * @return 处理的文件数量
     */
    public static long delFilePath(File file, String ignoreName) {
        long num = 0;
        if (file.list().length < 1) {
            deleteDirectoryPath(file);
        } else {
            File[] files = file.listFiles();
            for (File file1 : files) {
                if (file1.isDirectory()) {
                    num = num + delFilePath(file1, ignoreName);
                } else if (!getIsNotLike(ignoreName, file1.getName())) {
                    file1.delete();
                    ++num;
                }
            }
            deleteDirectoryPath(file);
        }
        return num;
    }

    /**
     * 删除文件夹
     *
     * @param files
     */
    public static void deleteDirectoryPath(File files) {
        if (files.exists() && files.list().length < 1) {
            try {
                Path path = files.toPath();
                Files.delete(path);
                deleteDirectoryPath(new File(path.getParent().toString()));
            } catch (IOException e) {
            }
        }
    }

    /**
     * 判断文件名中是否包含关键字，如果包含则剔除
     *
     * @param notLikeStr
     * @param fileName
     * @return
     */
    public static boolean getIsNotLike(String notLikeStr, String fileName) {
        String[] strArr = notLikeStr.split(";");
        for (int i = 0; i < strArr.length; i++) {
            if (fileName.contains(strArr[i])) {
                return true;
            }
        }
        return false;
    }

    /**
     * 判断文件是否过期，如果过期则删除
     *
     * @param file       要处理的文件
     * @param ignoreName 忽略文件名
     * @return 处理的文件数量
     */
    private static long judgeDocument(File file, String ignoreName) {
        ExecutorService executorService = Executors.newFixedThreadPool(threadNum);
        long num = 0;
        File[] files = file.listFiles();
        for (File file1 : files) {
            Future<Long> future = executorService.submit(new DeleteFileCallable(pathRetention, file1, ignoreName, null, null));
            try {
                num = num + future.get();
            } catch (InterruptedException | ExecutionException e) {
                throw new RuntimeException(e);
            }
        }
        // 关闭线程池
        executorService.shutdown();
        return num;
    }

    /**
     * 判断文件是否过期，如果过期则删除
     *
     * @param file       要处理的文件
     * @param ignoreName 忽略文件名
     * @return 处理的文件数量
     */
    private static long threadJudgeDocument(File file, String ignoreName) {
        long num = 0;
        if (file.isDirectory()) {
            //调用方法循环完成对文件夹中文件的删除
            num = num + delFile(file, ignoreName);
        } else {
            num = num + analysisFiles(file, ignoreName);
        }
        return num;
    }

    /**
     * 判断文件是否过期，如果过期则删除
     *
     * @param file       要处理的文件
     * @param ignoreName 忽略文件名
     * @return 处理的文件数量
     */
    public static long delFile(File file, String ignoreName) {
        long num = 0;
        if (file.list().length < 1) {
            deleteDirectory(file);
        } else {
            File[] files = file.listFiles();
            for (File file1 : files) {
                if (file1.isDirectory()) {
                    num = num + delFile(file1, ignoreName);
                } else {
                    num = num + analysisFiles(file1, ignoreName);
                }
                deleteDirectory(file);
            }
        }
        return num;
    }

    /**
     * 删除文件夹
     *
     * @param files 要删除的文件夹
     */
    public static void deleteDirectory(File files) {
        if (files.list().length < 1) {
            try {
                Path path = files.toPath();
                Files.delete(path);
            } catch (IOException e) {
            }
        }
    }

    /**
     * 判断文件是否过期，如果过期则删除
     *
     * @param file       要处理的文件
     * @param ignoreName 忽略文件名
     * @return 处理的文件数量
     */
    public static long analysisFiles(File file, String ignoreName) {

        long num = 0;
        //系统当前时间
        double nowTime = System.currentTimeMillis();
        Path path = file.toPath();
        //根据创建时间和系统当前时间判断文件存在时间是否大于要求天数（CLEANTIMEs * 24 * 60 * 60 * 1000）
        try {
            BasicFileAttributeView basicView = Files.getFileAttributeView(path, BasicFileAttributeView.class);
            BasicFileAttributes basicAttribs = basicView.readAttributes();
            String fileName = file.getName();
            if (getIsNotLike(ignoreName, fileName)) {
                return 0;
            }
            //最后修改时间
            Date savaTime = new Date(basicAttribs.lastModifiedTime().toMillis());
            double saveTimes = savaTime.getTime();
            if (nowTime - saveTimes > (double) days * dayTimes) {
                Files.delete(path);
                ++num;
            }
        } catch (IOException e1) {
        }
        return num;
    }

    /**
     * 转换日期格式，支持格式为：formats
     *
     * @param path 路径
     * @return LocalDate 转换后的日期
     */
    public static LocalDate dateConversion(String path, String rule) {
        String[] formats = {rule.replace("\\", "/"), rule.replace("/", "\\")};
        for (String format : formats) {
            try {
                LocalDate localDate = LocalDate.parse(path, DateTimeFormatter.ofPattern(format));
                if (localDate != null) {
                    return localDate;
                }
            } catch (DateTimeParseException e) {
                // 没有找到有效的日期
            }
        }
        return null;
    }

    static class DeleteFileCallable implements Callable<Long> {
        private boolean pathRetention;
        private File file;
        private String ignoreName;
        private LocalDate nowDate;
        private String rule;

        public DeleteFileCallable(boolean pathRetention, File file, String ignoreName, LocalDate nowDate, String rule) {
            this.pathRetention = pathRetention;
            this.file = file;
            this.ignoreName = ignoreName;
            this.nowDate = nowDate;
            this.rule = rule;
        }

        @Override
        public Long call() {
            long num;
            Thread currentThread = Thread.currentThread();
            System.out.println("Thread ID: " + currentThread.getId() + " 文件路径：" + file.getAbsolutePath());
            if (pathRetention) {
                System.out.println("按日期格式路径删除文件");
                num = threadJudgeDocumentPath(file, ignoreName, nowDate, rule);
            } else {
                System.out.println("按文件最后修改时间删除文件");
                num = threadJudgeDocument(file, ignoreName);
            }
            return num;
        }
    }
}

2.4 代码（流）

package com.api.apidemo.tool.file;

import org.apache.commons.lang3.StringUtils;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.time.temporal.ChronoUnit;
import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Stream;

/**
 * @author yhc
 * @description 批量删除文件-流方式
 */
public class BatchDeleteFileStream {
    /**
     * 删除的文件路径，支持多个路径，用|分割
     */
    public static final String path = "/home/cathay10/workSpace/log/[yyyy]/[MM]/[dd]";
    /**
     * 切割路径含有/[或\[的正则表达式
     */
    public static final Pattern PATH_PATTERN = Pattern.compile("^((?![\\\\/]\\[).)*");
    /**
     * 切割路径含有[的正则表达式
     */
    public static final Pattern RULE_PATTERN = Pattern.compile("\\[.*");
    /**
     * 保留天数，超过此天数的文件将被删除
     */
    public static final int days = 30;
    /**
     * 一天的毫秒数
     */
//    public static final int dayTimes = 24 * 60 * 60 * 1000;
    public static final int dayTimes = 1000;
    /**
     * 忽略的文件名，多个文件名用;分割
     */
    public static final String ignoreName = "123.txt;123.log";
    /**
     * 是否按路径删除文件
     */
    public static final boolean pathRetention = true;

    public static void main(String[] args) {
        long begin = System.currentTimeMillis();
        long num = batchDeleteFile();
        // 打印总删除文件数
        long stop = System.currentTimeMillis();
        System.out.println("执行结束，耗时：" + (stop - begin) + "ms" + " 删除文件数量：" + num);
    }

    /**
     * 批量删除文件
     */
    public static long batchDeleteFile() {
        // 删除数量
        long num = 0;
        // 删除路径集合 有需要可以添加多个路径，按 | 分割
        List sourceList = Arrays.asList(path.split("\\|"));
        int length = sourceList.size();
        if (length > 0) {
            for (int m = 0; m < length; m++) {
                // 判断目录是否含有日期格式
                String targetPath = replaceDate(sourceList.get(m).toString());
                // 处理通配符，将路径中的通配符替换为正则表达式
                targetPath = replaceWildcard(targetPath);
                if (pathRetention) {
                    // 按日期格式路径删除文件
                    // 截取掉除了年月日之外的路径
                    String dirPath = pathSplit(sourceList.get(m).toString());
                    File dir = new File(dirPath);
                    if (dir.exists()) {
                        // 当前日期
                        LocalDate nowDate = LocalDate.now();
                        String rule = ruleSplit(sourceList.get(m).toString());
                        num = num + judgeDocumentPath(dir, ignoreName, nowDate, rule);
                    }
                } else {
                    String dirPath = pathSplit(targetPath);
                    // 按最后修改时间删除文件
                    File file = new File(dirPath);
                    if (file.exists()) {
                        num = num + deleteFolder(file, ignoreName);
                    }
                }
            }
        }
        return num;
    }

    /**
     * 处理文件路径，替换日期格式占位符为当前日期
     *
     * @param path 原始路径
     * @return 处理后的路径，如果没有找到日期占位符，则返回原路径
     */
    public static String replaceDate(String path) {
        String targetPath;
        if (StringUtils.containsIgnoreCase(path, "[yyyy]/[MM]/[dd]")) {
            targetPath = replaceIgnoreCase(path, "[yyyy]/[MM]/[dd]", LocalDate.now().toString().replace("-", "/"));
        } else if (StringUtils.containsIgnoreCase(path, "[yyyyMMdd]")) {
            targetPath = replaceIgnoreCase(path, "[yyyymmdd]", LocalDate.now().toString().replace("-", ""));
        } else {
            targetPath = path;
        }
        return targetPath;
    }

    /**
     * 处理文件路径，将路径中的通配符替换为正则表达式
     *
     * @param path 原始路径
     * @return 处理后的路径，如果没有找到通配符，则返回原路径
     */
    public static String replaceWildcard(String path) {
        path.replaceAll("\\*", ".*").replaceAll("\\?", ".");
        return path;
    }

    /**
     * 获取路径中是否包含日期格式，支持格式为：formats
     *
     * @param targetPath 路径
     * @return 处理后的路径，截取第一次遇到日期格式前的路径，如果没有找到有效的日期格式，则返回原路径
     */
    public static String pathSplit(String targetPath) {
        Matcher pathMatcher = PATH_PATTERN.matcher(targetPath);
        while (pathMatcher.find()) {
            if (pathMatcher.group() != null) {
                return pathMatcher.group();
            }
        }
        // 没有找到有效的日期
        return null;
    }

    /**
     * 获取路径中的日期规则正则
     *
     * @param targetPath 路径
     * @return 规则正则
     */
    public static String ruleSplit(String targetPath) {
        Matcher ruleMatcher = RULE_PATTERN.matcher(targetPath);
        String ruleContent;
        while (ruleMatcher.find()) {
            ruleContent = replaceCharsInSquareBrackets(ruleMatcher.group());
            if (ruleContent != null) {
                return ruleContent;
            }
        }
        // 没有找到有效的日期
        return null;
    }

    /**
     * 替换方括号内的时间格式字符，分隔符[]
     *
     * @param str
     * @return 替换后的字符串
     */
    public static String replaceCharsInSquareBrackets(String str) {
        // 正则表达式匹配方括号内的内容
        String regex = "\\[(.*?)\\]";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(str);

        // 存储原始和替换后的内容
        List<String> originalMatches = new ArrayList<>();
        List<String> replacedMatches = new ArrayList<>();

        // 提取匹配的内容并进行替换
        while (matcher.find()) {
            originalMatches.add(matcher.group());
            String match = matcher.group();
            String match2 = match.replace("YYYY", "yyyy").replace("mm", "MM").replace("DD", "dd");
            replacedMatches.add(match2);
        }

        // 将原始字符串分解，然后用替换后的内容替换匹配的子串
        StringBuilder replacedStr = new StringBuilder(str);
        for (int i = 0; i < originalMatches.size(); i++) {
            int startIndex = replacedStr.indexOf(originalMatches.get(i));
            int endIndex = startIndex + originalMatches.get(i).length();
            replacedStr.replace(startIndex, endIndex, replacedMatches.get(i));
        }
        return replacedStr.toString().replaceAll("\\[", "").replaceAll("\\]", "");
    }

    /**
     * 替换字符串，不区分大小写
     *
     * @param original 原始字符串
     * @param from     要替换的字符串
     * @param to       替换后的字符串
     * @return 替换后的字符串
     */
    public static String replaceIgnoreCase(String original, String from, String to) {
        // 将要查找的字符串转换为正则表达式形式，并添加不区分大小写的标志(?i)
        String regex = "(?i)" + Pattern.quote(from);

        // 使用正则表达式进行替换
        return original.replaceAll(regex, to);
    }

    /**
     * 文件处理
     *
     * @param file       要处理的文件夹
     * @param ignoreName 忽略文件名
     * @return 处理的文件数量
     */
    public static long judgeDocumentPath(File file, String ignoreName, LocalDate nowDate, String rule) {
        long num = 0;
        File[] files = file.listFiles();
        for (File file1 : files) {
            if (file1.isDirectory()) {
                //调用方法循环完成对文件夹中文件的删除
                Pattern PATH_RELE_PATTERN = Pattern.compile(rule.replaceAll("[/\\\\]", "[/\\\\\\\\]").replace("yyyy", "(\\d{4})").replace("MM", "(\\d{2})").replace("dd", "(\\d{2})"));
                Matcher matcher = PATH_RELE_PATTERN.matcher(file1.getAbsolutePath());
                if (matcher.find()) {
                    LocalDate pathDate = dateConversion(matcher.group(), rule);
                    long betweenDays = ChronoUnit.DAYS.between(pathDate, nowDate);
                    if (betweenDays > days) {
                        num = num + deleteFolderPath(file1, ignoreName);
                    }
                } else {
                    //调用方法循环完成对文件夹中文件的删除
                    num = num + judgeDocumentPath(file1, ignoreName, nowDate, rule);
                }
            }
        }
        return num;
    }

    /**
     * 判断文件名中是否包含关键字，如果包含则剔除
     *
     * @param notLikeStr
     * @param fileName
     * @return
     */
    public static boolean getIsNotLike(String notLikeStr, String fileName) {
        String[] strArr = notLikeStr.split(";");
        for (int i = 0; i < strArr.length; i++) {
            if (fileName.contains(strArr[i])) {
                return true;
            }
        }
        return false;
    }

    /**
     * 删除文件夹下文件
     *
     * @param file       要删除的文件夹
     * @param ignoreName 忽略文件名
     * @return 删除的文件数量
     */
    public static long deleteFolderPath(File file, String ignoreName) {
        AtomicInteger i = new AtomicInteger();
        // 路径
        try (Stream<Path> stream = Files.walk(file.toPath())
                .filter(path -> !path.toFile().isDirectory() && !getIsNotLike(ignoreName, path.getFileName().toString()))
                .sorted(Comparator.reverseOrder())) {
            stream.forEach(path -> {
//                        try {
                        Files.delete(path);
//                            if (Files.deleteIfExists(path)) {
                        i.incrementAndGet();
//                            }
//                        } catch (IOException e) {
//                            throw new RuntimeException(e);
//                        }
                    }
            );
        } catch (IOException e) {
            e.printStackTrace();
        }
        return i.get();
    }

    /**
     * 删除文件夹下文件
     *
     * @param file       要删除的文件夹
     * @param ignoreName 忽略文件名
     * @return 删除的文件数量
     */
    public static long deleteFolder(File file, String ignoreName) {
        double nowTime = System.currentTimeMillis();
        AtomicInteger i = new AtomicInteger();
        // 路径
        try (Stream<Path> stream = Files.walk(file.toPath())
                .sorted(Comparator.reverseOrder())) {
            stream.forEachOrdered(path -> {
                try {
                    //最后修改时间
                    Date savaTime = new Date(path.toFile().lastModified());
                    double saveTimes = savaTime.getTime();
                    //获取非文件夹获取修改时间，因为删除文件时，会修改文件夹的最后修改时间，导致无法删除
                    if (!path.toFile().isDirectory() && !getIsNotLike(ignoreName, path.getFileName().toString()) && nowTime - saveTimes > (double) days * dayTimes) {
                        boolean deleteSuccess = Files.deleteIfExists(path);
                        if (deleteSuccess) {
                            i.incrementAndGet();
                        }
                    } else if (path.toFile().listFiles().length == 0) {
                        Files.deleteIfExists(path);
                    }
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            });
        } catch (IOException e) {
            e.printStackTrace();
        }
        return i.get();
    }

    /**
     * 转换日期格式，支持格式为：formats
     *
     * @param path 路径
     * @return LocalDate 转换后的日期
     */
    public static LocalDate dateConversion(String path, String rule) {
        String[] formats = {rule.replace("\\", "/"), rule.replace("/", "\\")};
        for (String format : formats) {
            try {
                LocalDate localDate = LocalDate.parse(path, DateTimeFormatter.ofPattern(format));
                if (localDate != null) {
                    return localDate;
                }
            } catch (DateTimeParseException e) {
                // 没有找到有效的日期
            }
        }
        return null;
    }
}

3. 问题调整

3.1 如需严格按照文件名称删除，在正则里添加必须按正则结尾去处理

例子：之前的代码会删除如 20240505-副本的文件夹，更新成新的后，将不会删除

Pattern PATH_RELE_PATTERN = Pattern.compile("(" + rule.replaceAll("[/\\\\]", "[/\\\\\\\\]").replace("yyyy", "(\\d{4})").replace("MM", "(\\d{2})").replace("dd", "(\\d{2})") + ")$");

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：mysql更改光标

下一篇：MLPRegressor原理详解

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯

java substring 年月字符串 截取年 java怎么截取日期的年月日

java substring 年月字符串 截取年 java怎么截取日期的年月日

1. 删除指定文件夹底下的文件夹及文件

1.1 使用FileUtils删除

1.1.1 引入依赖

1.1.2 使用

1.1.3 其他功能

2.1 参数

2.2 代码（单线程）

2.3 代码（线程池）

2.4 代码（流）

3. 问题调整

3.1 如需严格按照文件名称删除，在正则里添加必须按正则结尾去处理

51CTO博客

java substring 年月字符串截取年 java怎么截取日期的年月日

java substring 年月字符串截取年 java怎么截取日期的年月日