Delete files created more than 10 days ago, saving the latest if everyone from the list has more than 10 days of creation

Question

I did this question where doubt was how to delete files with more than 10 days of creation. I recover them from a directory and the code has already been implemented and is functional.

However, I ended up with a problem that can make the code erase all the files, in case the program goes 10 days without running. I need to save the latest file if this occurs, but as I don’t know in what order java recovers that list from windows, I can’t consider that the latest (or the first ad list) would be the latest.

How do I save the latest file by keeping the code deletion structure below? Preferably using java native resources, because I have some limitations that can cause me problems if adding external libs.

public static void removeOldFiles() {

    try {
        //resgato o limite de dias de um arquivo mas
        //estou trabalhando com diasLimite = 10
        Propriedade prop = new Propriedade();
        int diasLimite = Integer.valueOf(prop.getDbBackupDelLimit());
        if (diasLimite > 0) {

            Date data = new Date();
            Calendar c = Calendar.getInstance();
            c.setTime(data);
            //seta a data limite de criação
            //dos backups antigos
            c.add(Calendar.DATE, - diasLimite);
            Date limit = c.getTime();
            //pego a URL da pasta
            File bkpPasta = new File(prop.getDatabaseURL() + prop.getDbBackupDir());
            //listo os arquivos contidos
            File[] arqs = bkpPasta.listFiles();

            for (File f : arqs) {
                //pego a data de ultima modificacao
                //para checar se tem mais de 10 dias 
                Date lastModified = new Date(f.lastModified());
                if (lastModified.before(limit)) {
                    f.delete();
                }
            }
        }
    } catch (IOException ex) {
        ex.printStackTrace();
    }
}

^{Note: Unfortunately I cannot use resources of java 8, because the application was made on top of JDK7.}

Answer 1

After having the files in an array:

• make your order in descending order of the modification date
• check if the modification date of the first item is more than 10 days old
  • if yes, go through the array, starting from the second item and delete all files.
  • if not, scroll through the array and remove files with modification date greater than 10 days.

Use this comparator

public class LastModifiedFileDescendingComparator implements Comparator<File>{

    @Override
    public int compare(File file1, File file2) {
        long result = file1.lastModified() - file2.lastModified();
        if (result < 0) {
            return 1;
        } else if (result > 0) {
            return -1;
        } else {
            return 0;
        }
    }
}

thus:

Arrays.sort(array, new LastModifiedFileDescendingComparator());

Your code, by using Array.sort() and the best way to calculate the deadline will be like this:

public static void removeOldFiles() {

    long daysToMilliseconds = 24 * 60 * 60 * 1000;

    //resgato o limite de dias de um arquivo mas
    //estou trabalhando com diasLimite = 10
    Propriedade prop = new Propriedade();
    int limiteDays = Integer.valueOf(prop.getDbBackupDelLimit());
    long limiteTime = new Date().getTime() - limitDays * daysToMilliseconds;

    File bkpPasta = new File(prop.getDatabaseURL() + prop.getDbBackupDir());
        //listo os arquivos contidos
    File[] arqs = bkpPasta.listFiles();

    if (limitDays > 0 && arqs.length > 0) {

        //Ordeno os arquivos 
        Arrays.sort(arqs, new LastModifiedFileDescendingComparator());

        //Se o arquivo mais recente estiver dentro do limite, apago a partir do segundo.
        if(shouldDeleteFile(arqs[0], limiteTime)){
            deleteOldFiles(arqs, 1, limiteTime);
        }else{//se não apago a partir do primeiro
            deleteOldFiles(arqs, 0, limiteTime);
        }
    }

}

private void deleteOldFiles(File[] files, int first, long limitTime){
    for (int i = first; i < files.length; i++) {
        if(shouldDeleteFile(files[i], limitTime)){
            files[i].delete();
        }
    }

}
private boolean shouldDeleteFile(File file, long limitTime){
    return file.lastModified() < limitTime;
}

public class LastModifiedFileDescendingComparator implements Comparator<File>{

    @Override
    public int compare(File file1, File file2) {
        long result = file1.lastModified() - file2.lastModified();
        if (result < 0) {
            return 1;
        } else if (result > 0) {
            return -1;
        } else {
            return 0;
        }
    }
}

Note that, using auxiliary methods, the main method became simple and easy to read.

Since removeOldFiles is responsible for getting the files to be deleted and being them files from backup, I would change your name to removeOldBackupFiles.

Answer 2

One option is to sort the list of files using the comparator:

import org.apache.commons.io.comparator.LastModifiedFileComparator;  

The function below sorts the array, ai you can delete from the second item.

File[] arqs = directory.listFiles();
Arrays.sort(arqs, LastModifiedFileComparator.LASTMODIFIED_COMPARATOR);
for (File file : arqs) {
    Date ultModificado = new Date(file.lastModified());        
}

Source: https://stackoverflow.com/a/24159031/1997073