Usuń pliki starsze niż x dni

Question

Jak mogę się dowiedzieć, kiedy plik został utworzony za pomocą java, ponieważ chcę usunąć pliki starsze niż pewien okres czasu, obecnie usuwam wszystkie pliki z katalogu, ale to nie jest idealne :

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(); 
    } 
} 

Powyżej jest mój bieżący kod, próbuję teraz dodać if że usunie tylko pliki starsze niż powiedzmy tydzień.

Edycja:

@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(); 
     } 
    } 

Dodanie pętli się.

EDIT

zauważyłem podczas testowania powyższy kod otrzymuję ostatnio modyfikowana w:

INFO: Date Modified : 1361635382096 

Jak mam Kodeksu jeśli pętla powiedzieć, jeśli jest starszy niż 7 dni go usunąć, gdy to jest w powyższym formacie?

Answer 1

Możesz użyć File.lastModified(), aby uzyskać ostatni czas modyfikacji pliku/katalogu.

Może być stosowany tak:

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

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

które usuwa pliki starsze niż x (e int) dni.

Answer 2

Można uzyskać datę utworzenia pliku, używając NIO, po to sposób:

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

Więcej informacji można znaleźć tutaj: http://docs.oracle.com/javase/tutorial/essential/io/fileAttr.html

Answer 3

Commons IO posiada wbudowane wsparcie dla filtrowania plików według wieku z numerem AgeFileFilter. Twój DeleteFiles może po prostu wyglądać następująco:

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(); 
    } 
} 

Aktualizacja: Aby użyć wartości podanych w swojej edycji, zdefiniować thresholdDate jak:

Date tresholdDate = new Date(1361635382096L); 

Answer 4

Korzystanie Apache utils jest chyba najprostszy. Oto najprostsze rozwiązanie, jakie mogłem wymyślić.

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 
} 

Answer 5

Przykład używając Java 8 czas API

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); 
} 

Answer 6

Dla JDK 8 roztworze przy użyciu obu Nio strumienie plików i JSR-310

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 
      } 
     }); 

sucky rzeczą tutaj jest potrzeba obsługi wyjątki w obrębie każdego lambda. Byłoby wspaniale, gdyby interfejs API miał przeciążenia UncheckedIOException dla każdej metody IO.Z pomocników zrobić ten jeden mógł napisać:

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); 
     } 
    } 

} 

Answer 7

Korzystanie z Apache Commons IO i Joda:

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

Answer 8

zwracamy uwagę błąd na pierwszym roztworze wymienionych, x * 24 * 60 * 60 * 1000 będzie miało maksymalną wartość int, jeśli x jest duże. Więc trzeba oddać go do długiej wartości

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

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

Answer 9

Innym podejściem z Apache Commons IO i 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... 
     } 
    } 
} 

Answer 10

Oto kod, aby usunąć pliki, które nie zostały zmodyfikowane od sześciu miesięcy & również stworzyć plik dziennika.

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(); 
    } 
} 

Answer 11

Korzystanie lambdy (Java 8+)

opcję Non rekurencyjnej, aby usunąć wszystkie pliki w bieżącym folderze, które są starsze niż N dni (ignoruje podfoldery):

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 
     } 
    }); 
} 

Opcja rekursywna przechodząca przez podfoldery i usuwająca wszystkie pliki starsze niż N dni:

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 
      } 
     } 
    }); 
} 

Answer 12

Korzystanie Java NIO plików z lambdas & Commons IO

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

listy wszystkich znalezionych plików i katalogów:

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

lub usunąć znalezione pliki z FileUtils:

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