wake-up-neo.net

Löschen Sie Dateien, die älter als x Tage sind

Wie kann ich herausfinden, wann eine Datei mit Java erstellt wurde, da ich Dateien löschen möchte, die älter als ein bestimmter Zeitraum sind? Derzeit lösche ich alle Dateien in einem Verzeichnis. Dies ist jedoch nicht ideal:

public void DeleteFiles() {
    File file = new File("D:/Documents/NetBeansProjects/printing~Subversion/fileupload/web/resources/pdf/");
    System.out.println("Called deleteFiles");
    DeleteFiles(file);
    File file2 = new File("D:/Documents/NetBeansProjects/printing~Subversion/fileupload/Uploaded/");
    DeleteFilesNonPdf(file2);
}

public void DeleteFiles(File file) {
    System.out.println("Now will search folders and delete files,");
    if (file.isDirectory()) {
        for (File f : file.listFiles()) {
            DeleteFiles(f);
        }
    } else {
        file.delete();
    }
}

Oben ist mein aktueller Code. Ich versuche jetzt, eine if -Anweisung hinzuzufügen, in der nur Dateien gelöscht werden, die älter sind als etwa eine Woche. 

BEARBEITEN:

@ViewScoped
@ManagedBean
public class Delete {

    public void DeleteFiles() {
        File file = new File("D:/Documents/NetBeansProjects/printing~Subversion/fileupload/web/resources/pdf/");
        System.out.println("Called deleteFiles");
        DeleteFiles(file);
        File file2 = new File("D:/Documents/NetBeansProjects/printing~Subversion/fileupload/Uploaded/");
        DeleteFilesNonPdf(file2);
    }

    public void DeleteFiles(File file) {
        System.out.println("Now will search folders and delete files,");
        if (file.isDirectory()) {
            System.out.println("Date Modified : " + file.lastModified());
            for (File f : file.listFiles()) {
                DeleteFiles(f);
            }
        } else {
            file.delete();
        }
    }

Eine Schleife hinzufügen.

BEARBEITEN

Beim Testen des obigen Codes habe ich festgestellt, dass ich die letzte Änderung erhalten habe:

INFO: Date Modified : 1361635382096

Wie soll ich die if-Schleife codieren, um zu sagen, ob sie älter als 7 Tage ist, wenn sie im obigen Format gelöscht wird?

30
user2065929

Sie können mit File.lastModified() den letzten Änderungszeitpunkt einer Datei/eines Verzeichnisses ermitteln.

Kann wie folgt verwendet werden:

long diff = new Date().getTime() - file.lastModified();

if (diff > x * 24 * 60 * 60 * 1000) {
    file.delete();
}

Dadurch werden Dateien gelöscht, die älter als x (eine int) Tage sind.

40

Commons IO bietet integrierte Unterstützung für das Filtern von Dateien nach Alter mit ihrem AgeFileFilter . Ihre DeleteFiles könnte einfach so aussehen:

import Java.io.File;
import org.Apache.commons.io.FileUtils;
import org.Apache.commons.io.filefilter.AgeFileFilter;
import static org.Apache.commons.io.filefilter.TrueFileFilter.TRUE;

// a Date defined somewhere for the cutoff date
Date thresholdDate = <the oldest age you want to keep>;

public void DeleteFiles(File file) {
    Iterator<File> filesToDelete =
        FileUtils.iterateFiles(file, new AgeFileFilter(thresholdDate), TRUE);
    for (File aFile : filesToDelete) {
        aFile.delete();
    }
}

Update: Um den in Ihrer Bearbeitung angegebenen Wert zu verwenden, definieren Sie die Variable thresholdDate als:

Date tresholdDate = new Date(1361635382096L);
23
Ryan Stewart

Beispiel mit der Time API von Java 8

LocalDate today = LocalDate.now();
LocalDate eailer = today.minusDays(30);

Date threshold = Date.from(eailer.atStartOfDay(ZoneId.systemDefault()).toInstant());
AgeFileFilter filter = new AgeFileFilter(threshold);

File path = new File("...");
File[] oldFolders = FileFilterUtils.filter(filter, path);

for (File folder : oldFolders) {
    System.out.println(folder);
}
10
MadProgrammer

Die Verwendung von Apache-Utils ist wahrscheinlich die einfachste. Hier ist die einfachste Lösung, die ich finden könnte.

public void deleteOldFiles() {
    Date oldestAllowedFileDate = DateUtils.addDays(new Date(), -3); //minus days from current date
    File targetDir = new File("C:\\TEMP\\archive\\");
    Iterator<File> filesToDelete = FileUtils.iterateFiles(targetDir, new AgeFileFilter(oldestAllowedFileDate), null);
    //if deleting subdirs, replace null above with TrueFileFilter.INSTANCE
    while (filesToDelete.hasNext()) {
        FileUtils.deleteQuietly(filesToDelete.next());
    }  //I don't want an exception if a file is not deleted. Otherwise use filesToDelete.next().delete() in a try/catch
}
9
MattC

Für eine JDK 8-Lösung, die sowohl NIO-Dateistreams als auch JSR-310 verwendet

long cut = LocalDateTime.now().minusWeeks(1).toEpochSecond(ZoneOffset.UTC);
Path path = Paths.get("/path/to/delete");
Files.list(path)
        .filter(n -> {
            try {
                return Files.getLastModifiedTime(n)
                        .to(TimeUnit.SECONDS) < cut;
            } catch (IOException ex) {
                //handle exception
                return false;
            }
        })
        .forEach(n -> {
            try {
                Files.delete(n);
            } catch (IOException ex) {
                //handle exception
            }
        });

Das Dumme daran ist die Notwendigkeit, Ausnahmen innerhalb jedes Lambda zu behandeln. Es wäre großartig gewesen, wenn die API UncheckedIOException-Überladungen für jede IO - Methode hätte. Mit Helfern dazu könnte man schreiben:

public static void main(String[] args) throws IOException {
    long cut = LocalDateTime.now().minusWeeks(1).toEpochSecond(ZoneOffset.UTC);
    Path path = Paths.get("/path/to/delete");
    Files.list(path)
            .filter(n -> Files2.getLastModifiedTimeUnchecked(n)
                    .to(TimeUnit.SECONDS) < cut)
            .forEach(n -> {
                System.out.println(n);
                Files2.delete(n, (t, u)
                              -> System.err.format("Couldn't delete %s%n",
                                                   t, u.getMessage())
                );
            });
}


private static final class Files2 {

    public static FileTime getLastModifiedTimeUnchecked(Path path,
            LinkOption... options)
            throws UncheckedIOException {
        try {
            return Files.getLastModifiedTime(path, options);
        } catch (IOException ex) {
            throw new UncheckedIOException(ex);
        }
    }

    public static void delete(Path path, BiConsumer<Path, Exception> e) {
        try {
            Files.delete(path);
        } catch (IOException ex) {
            e.accept(path, ex);
        }
    }

}
5
Brett Ryan

Lambdas verwenden (Java 8+)

Nicht rekursive Option zum Löschen aller Dateien im aktuellen Ordner, die älter als N Tage sind (Unterordner werden ignoriert):

public static void deleteFilesOlderThanNDays(int days, String dirPath) throws IOException {
    long cutOff = System.currentTimeMillis() - (days * 24 * 60 * 60 * 1000);
    Files.list(Paths.get(dirPath))
    .filter(path -> {
        try {
            return Files.isRegularFile(path) && Files.getLastModifiedTime(path).to(TimeUnit.MILLISECONDS) < cutOff;
        } catch (IOException ex) {
            // log here and move on
            return false;
        }
    })
    .forEach(path -> {
        try {
            Files.delete(path);
        } catch (IOException ex) {
            // log here and move on
        }
    });
}

Rekursive Option, die Unterordner durchläuft und alle Dateien löscht, die älter als N Tage sind:

public static void recursiveDeleteFilesOlderThanNDays(int days, String dirPath) throws IOException {
    long cutOff = System.currentTimeMillis() - (days * 24 * 60 * 60 * 1000);
    Files.list(Paths.get(dirPath))
    .forEach(path -> {
        if (Files.isDirectory(path)) {
            try {
                recursiveDeleteFilesOlderThanNDays(days, path.toString());
            } catch (IOException e) {
                // log here and move on
            }
        } else {
            try {
                if (Files.getLastModifiedTime(path).to(TimeUnit.MILLISECONDS) < cutOff) {
                    Files.delete(path);
                }
            } catch (IOException ex) {
                // log here and move on
            }
        }
    });
}
3
rouble

Hier ist Java 8-Version mit Time API. Es wurde getestet und in unserem Projekt verwendet:

    public static int deleteFiles(final Path destination,
        final Integer daysToKeep) throws IOException {

    final Instant retentionFilePeriod = ZonedDateTime.now()
            .minusDays(daysToKeep).toInstant();

    final AtomicInteger countDeletedFiles = new AtomicInteger();
    Files.find(destination, 1,
            (path, basicFileAttrs) -> basicFileAttrs.lastModifiedTime()
                    .toInstant().isBefore(retentionFilePeriod))
            .forEach(fileToDelete -> {
                try {
                    if (!Files.isDirectory(fileToDelete)) {
                        Files.delete(fileToDelete);
                        countDeletedFiles.incrementAndGet();
                    }
                } catch (IOException e) {
                    throw new UncheckedIOException(e);
                }
            });

    return countDeletedFiles.get();
}
3
Erikson

Ein weiterer Ansatz mit Apache Commons-Io und Joda:

private void deleteOldFiles(String dir, int daysToRemainFiles) {
    Collection<File> filesToDelete = FileUtils.listFiles(new File(dir),
            new AgeFileFilter(DateTime.now().withTimeAtStartOfDay().minusDays(daysToRemainFiles).toDate()),
            TrueFileFilter.TRUE);    // include sub dirs
    for (File file : filesToDelete) {
        boolean success = FileUtils.deleteQuietly(file);
        if (!success) {
            // log...
        }
    }
}
3
Isaace

Sie können das Erstellungsdatum der Datei mit NIO abrufen. Gehen Sie folgendermaßen vor:

BasicFileAttributes attrs = Files.readAttributes(file, BasicFileAttributes.class);
System.out.println("creationTime: " + attrs.creationTime());

Mehr darüber finden Sie hier: http://docs.Oracle.com/javase/tutorial/essential/io/fileAttr.html

2
vikasing

Hier ist der Code zum Löschen von Dateien, die seit sechs Monaten nicht geändert wurden, und erstellt außerdem die Protokolldatei.

package deleteFiles;

import Java.io.File;
import Java.io.IOException;
import Java.util.ArrayList;
import Java.util.Calendar;
import Java.util.Date;
import Java.util.logging.FileHandler;
import Java.util.logging.Logger;
import Java.util.logging.SimpleFormatter;

public class Delete {
    public static void deleteFiles()
    {
        int numOfMonths = -6;
        String path="G:\\Files";
        File file = new File(path);
        FileHandler fh;
        Calendar sixMonthAgo = Calendar.getInstance();
        Calendar currentDate = Calendar.getInstance();
        Logger logger = Logger.getLogger("MyLog");
        sixMonthAgo.add(Calendar.MONTH, numOfMonths);
        File[] files = file.listFiles();
        ArrayList<String> arrlist = new ArrayList<String>();

        try {
            fh = new FileHandler("G:\\Files\\logFile\\MyLogForDeletedFile.log");
            logger.addHandler(fh);
            SimpleFormatter formatter = new SimpleFormatter();
            fh.setFormatter(formatter);

            for (File f:files)
            {
                if (f.isFile() && f.exists())
                {
                    Date lastModDate = new Date(f.lastModified());
                    if(lastModDate.before(sixMonthAgo.getTime()))
                    {
                        arrlist.add(f.getName());
                        f.delete();
                    }
                }
            }
            for(int i=0;i<arrlist.size();i++)
                logger.info("deleted files are ===>"+arrlist.get(i));
        }
        catch ( Exception e ){
            e.printStackTrace();
            logger.info("error is-->"+e);
        }
    }
    public static void main(String[] args)
    {
        deleteFiles();
    }
}
0
Pankaj Dagar

Müssen Sie einen Fehler in der ersten aufgelisteten Lösung aufzeigen, wird der Wert von x * 24 * 60 * 60 * 1000 max out sein, wenn x groß ist. Also muss es zu lang wert sein

long diff = new Date().getTime() - file.lastModified();

if (diff > (long) x * 24 * 60 * 60 * 1000) {
    file.delete();
}
0
Feng Zhang

Verwenden von Java-NIO-Dateien mit Lambdas & Commons IO

final long time = new Date().getTime();
// Only show files & directories older than 2 days
final long maxdiff = TimeUnit.DAYS.toMillis(2);

Alle gefundenen Dateien und Verzeichnisse auflisten:

Files.newDirectoryStream(Paths.get("."), p -> (time - p.toFile().lastModified()) < maxdiff)
.forEach(System.out::println);

Oder löschen Sie gefundene Dateien mit FileUtils :

Files.newDirectoryStream(Paths.get("."), p -> (time - p.toFile().lastModified()) < maxdiff)
.forEach(p -> FileUtils.deleteQuietly(p.toFile()));
0
socona

Verwenden von Apache Commons-Io und Joda:

        if ( FileUtils.isFileOlder(f, DateTime.now().minusDays(30).toDate()) ) {
            f.delete();
        }
0