Java-不要删除与任何数组值匹配的文件

我有一个文件列表（大约500个或更多文件），其中文件名包含日期

文件\u 20180810

文件_19950101

文件号：20180809

等等

我要做的是删除超过存储周期的文件。 到目前为止，我已经提出了以下逻辑

~获取有效存储期的日期（即，如果存储期为5天，今天的日期为20180810，则在数组中存储日期值20180810、20180809、20180808、20180807、20180806、20180805

~检查目录中的每个文件是否包含以下日期。如果包含日期，则不删除，否则删除

我这里的问题是，如果文件名确实包含一个日期，并且我使用循环来删除一个文件，那么它可能也会删除其他具有有效日期的文件。为了以代码形式显示我要执行的操作，它是这样的：

 if (!fileName.contains(stringDate1) && 
 !fileName.contains(stringDate2) && 
 !fileName.contains(stringDate3)) //...until storage period
 {//delete file}

有没有更好的方法来表达这一点？有没有解决方法的建议？

---

请并感谢您。

如果您使用的是ES6，您可以使用array includes并返回true或false进行验证

['a', 'b', 'c'].includes('b')

---

您可以尝试使用Regex提取每个文件的实际日期，并检查是否包含在有效期内

Pattern p = Pattern.compile("file_(?<date>\d{6})");
foreach(File f : filelist){
    Matcher m = p.matcher(f.filename());
    if(m.find()){
        Date fileDate = new Date(m.group("date"));
        if(fileDate.before(periodStartDate)){
            file.delete();
        }
    }
}

Pattern p=Pattern.compile（“file_（？\d{6}）”；
foreach（文件f:filelist）{
Matcher m=p.Matcher（f.filename（））；
if（m.find（））{
日期文件日期=新日期（m.group（“日期”））；
if（文件日期之前（周期开始日期））{
delete（）；
}
}
}

---

代码不精确，不应编译，请检查

日期

对象创建和比较，但主要思想大致如下。

从文件名解析日期。以下是一个示例：

import java.time.*;
import java.util.regex.*;

public class MyClass {
    public static void main(String args[]) {
        LocalDate today = LocalDate.now();
        long storagePeriod = 5L;
        String fileName = "file_20180804";
        int year = 0;
        int month = 0;
        int day = 0;

        String pattern = "file_(\\d{4})(\\d{2})(\\d{2})";
        Pattern r = Pattern.compile(pattern);
        Matcher m = r.matcher(fileName);

        if (m.find()) {
            year = Integer.parseInt(m.group(1));
            month = Integer.parseInt(m.group(2));
            day = Integer.parseInt(m.group(3));
        }

        LocalDate fileDate = LocalDate.of(year, month, day);

        if (fileDate.isBefore(today.minusDays(storagePeriod))) {
            System.out.println("Delete this file");
        }
    }
}

---

您只能删除不在阵列中的文件，如（已测试，正在工作）：

---

String path=“”；//以下是一些示例代码，演示了如何根据提供的一组日期字符串（例如“20180810”）验证输入文件列表（文件名字符串，例如“file_20180810”），并对其执行操作（如删除文件）

import java.util.*；
导入java.io.*；
公共类文件测试{
私有静态final int DATE_STRING_LENGTH=8；//长度为20180809
公共静态void main（字符串[]args）{
列表过滤器=Arrays.asList（“20180810”、“20180808”、“20180809”、“20180807”、“20180806”、“20180805”）；
List files=Arrays.asList（新文件（“文件”20180810）、新文件（“文件”19950101）、新文件（“文件”）20180809）；
用于（文件：文件）{
字符串fileDateStr=getDateStringFromFileName（file.getName（））；
if（filter.contains（fileDateStr））{
//用它做点什么
//删除文件-如果存在
System.out.println（file.toString（））；
}
}
}
私有静态字符串getDateStringFromFileName（字符串文件名）{
int fileLen=fileName.length（）；
int dateStrPos=fileLen—日期字符串长度；
返回fileName.substring（dateStrPos）；
}
}
Java，不是Javascript.Argh！我很抱歉。不过，请考虑一下这个概念。创建一个字符串数组。循环遍历在字符串数组中找到或未找到的值。将其与目标字符串进行比较。返回true或false。除非我遗漏了什么，否则您的方法似乎有些过火。我会使用类似的方法（伪代码）：
foreach file:if file.name

    String path = ""; // <- Folder we want to clean.

    DateFormat df = new SimpleDateFormat("yyyyMMdd"); // <- DateFormat to convert the Calendar dates into our format.
    Calendar cal = Calendar.getInstance(); // <- Using Calendar to get the days backwards.
    ArrayList<String> dr = new ArrayList<String>(); // <- Save the dates we want to remove.    dr = don't remove

    dr.add(df.format(cal.getTime())); // <- add the actual date to List
    for(int i = 0; i < 5; i++) { // <- Loop 5 Times to get the 5 Last Days
        cal.add(Calendar.DATE, -1); // <- remove 1 day from actual Calendar date
        dr.add(df.format(cal.getTime())); // <- add the day before to List
    }

    for(File file : new File(path).listFiles()) { // <- loop through all the files in the folder
        String filename = file.getName().substring(0, file.getName().lastIndexOf(".")); // <- name of the file without extension

        boolean remove = true; // <- Set removing to "yes"
        for(String s : dr) { // <- loop through all the allowed dates
            if(filename.contains(s)) { // <- when the file contains the allowed date
                remove = false; // <- Set removing to "no"
                break; // <- Break the loop for better performance
            }
        }

        if(remove) { // <- If remove is "yes"
            file.delete(); // <- Delete the file because it's too old for us!
        }
    }

    String path = ""; // <- Folder we want to clean.
    Date today = new Date();
    DateFormat df = new SimpleDateFormat("yyyyMMdd"); // <- Dateformat you used in the files
    long maxage = 5 * 24 * 60 * 60 * 1000; // <- Calculate how many milliseconds ago we want to delete

    for(File file : new File(path).listFiles()) { // <- loop through all the files in the folder
        String fds = file.getName().split("_")[1]; // <- Date from the filename as string
        try {
            Date date = df.parse(fds); // Convert the string to a date

            if(date.getTime() - today.getTime() <= maxage) { // <- when the file is older as 5 days 
                file.delete(); // <- Delete the file
            }

        } catch (ParseException e) {
            e.printStackTrace();
        }
    }

import java.util.*;
import java.io.*;
public class FilesTesting {
    private static final int DATE_STRING_LENGTH = 8; //  length of 20180809
    public static void main(String [] args) {
        List<String> filter = Arrays.asList("20180810", "20180808", "20180809", "20180807", "20180806", "20180805");
        List<File> files = Arrays.asList(new File("file_20180810"), new File("file_19950101"), new File("file_20180809"));
        for (File file : files) {
            String fileDateStr = getDateStringFromFileName(file.getName());
            if (filter.contains(fileDateStr)) {
                // Do something with it
                // Delete file - if it exists
                System.out.println(file.toString());
            }
        }
    }
    private static String getDateStringFromFileName(String fileName) {
        int fileLen = fileName.length();
        int dateStrPos = fileLen - DATE_STRING_LENGTH;
        return fileName.substring(dateStrPos);
    }
}