¿Cómo puedo encontrar la última modificación del archivo en un directorio en java?

  • Estás preguntando cómo ordenar por fecha de la última modificación? O quieres un algoritmo que encuentre el máximo de tiempo de última modificación? Estas parecen ser las soluciones más obvias; lo que realmente pidiendo?
InformationsquelleAutor jumar | 2010-01-14

9 Comentarios

  1. 44
    private File getLatestFilefromDir(String dirPath){
        File dir = new File(dirPath);
        File[] files = dir.listFiles();
        if (files == null || files.length == 0) {
            return null;
        }
    
        File lastModifiedFile = files[0];
        for (int i = 1; i < files.length; i++) {
           if (lastModifiedFile.lastModified() < files[i].lastModified()) {
               lastModifiedFile = files[i];
           }
        }
        return lastModifiedFile;
    }
    • Pensaba que esto sería limpiador de usar un comparador, pero de esta manera es más rápido.
    • el uso de un comparador es una buena práctica, pero esto es sólo una tarea sencilla y que podría pasar sin ella.
    • no. el mayor es el valor de tipo long que es, que más tarde se modifica el archivo. Si esa fue la razón por la downvote, siéntase libre de deshacerlo 😉
    • el uso de un comparador no es más «buena práctica», que el uso de la int tipo es una «buena práctica». El más fuerte que se puede decir es que los comparadores son una buena (parcial) de la solución para muchos problemas de programación.
    • Usted puede obtener un índice fuera de los límites si el directorio está vacío. No se deben asignar los archivos[0] a lastModifiedFile fuera del bucle.
    • este código devuelve el nombre de directorio algunas veces

  2. 8

    Combinar estas dos:

    1. Usted puede obtener la hora de la última modificación de un Archivo mediante Archivo.lastModified().
    2. A la lista de todos los archivos en un directorio, utilice Archivo.listFiles().

    Tenga en cuenta que en Java el java.io.File objeto se utiliza para ambos directorios y archivos.

  3. 6
    import org.apache.commons.io.comparator.LastModifiedFileComparator;
    import org.apache.commons.io.filefilter.WildcardFileFilter;
    
    ...
    ...
    
    /* Get the newest file for a specific extension */
    public File getTheNewestFile(String filePath, String ext) {
        File theNewestFile = null;
        File dir = new File(filePath);
        FileFilter fileFilter = new WildcardFileFilter("*." + ext);
        File[] files = dir.listFiles(fileFilter);
    
        if (files.length > 0) {
            /** The newest file comes first **/
            Arrays.sort(files, LastModifiedFileComparator.LASTMODIFIED_REVERSE);
            theNewestFile = files[0]
        }
    
        return theNewestFile;
    }

    Esto funciona muy bien para mí

  4. 4

    Puede recuperar el tiempo de la última modificación de utilizar el Archivo.lastModified() método. Mi propuesta de solución sería implementar una costumbre Comparador de ese tipo en lastModified()-orden e insertar todos los Archivos en el directorio en un TreeSet que ordena el uso de este comparador.

    Probados ejemplo:

    SortedSet<File> modificationOrder = new TreeSet<File>(new Comparator<File>() {
        public int compare(File a, File b) {
            return (int) (a.lastModified() - b.lastModified());
        }
    });
    
    for (File file : myDir.listFiles()) {
        modificationOrder.add(file);
    }
    
    File last = modificationOrder.last();

    La solución sugerida por Bozho es probablemente más rápido si sólo se necesita el último archivo. Por otro lado, esto podría ser útil si usted necesita para hacer algo más complicado.

  5. 2

    Su problema es similar: Cómo llegar a sólo 10 última modificación de los archivos del directorio uso de Java?

    Acaba de cambiar el código del filtro para que sólo tiene un Archivo y aceptar método debe simplemente comparar los dos sellos de tiempo.

    Código no probado:

         class TopFileFilter implements FileFilter {
    
            File topFile;
    
            public boolean accept(File newF) {
                if(topFile == null)
                    topFile = newF;
                else if(newF.lastModified()>topFile.lastModified())
                    topFile = newF;
                return false;
            }
    
        }

    Ahora, llame a dir.listFiles con una instancia de este filtro como argumento. Al final, el filtro.topFile es el último archivo modificado.

  6. 1

    El comparador de Emil la solución estaría más limpio de esta manera

    public int compare(File a, File b) {
        if ((a.lastModified() < b.lastModified())) {
            return 1;
        } else if ((a.lastModified() > b.lastModified())) {
            return -1;
        } 
        return 0;
    }

    Casting (a.lastModified() - b.lastModified()) a int puede producir resultados inesperados.

  7. 1
        String path = "C:\Work\Input\";
    
        File dir = new File(path);
        File[] files = dir.listFiles();
    
        Arrays.sort(files, new Comparator<File>() {
            public int compare(File f1, File f2) {
                return Long.valueOf(f2.lastModified()).compareTo(
                        f1.lastModified());
            }
        });
    
        for (int index = 0; index < files.length; index++) {
            //Print out the name of files in the directory
            System.out.println(files[index].getName());
        }
    
    }
  8. 1

    Java 8

    Optional<Path> findLastModifiedFile(Path directory) throws IOException {
        return Files.list(directory)
                .max(this::compareLastModified);
    }
    
    int compareLastModified(Path p1, Path p2) {
        try {
            return Files.getLastModifiedTime(p1).compareTo(Files.getLastModifiedTime(p2));
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
  9. 1

    Supongamos que la variable thePath contiene el directorio en el que queremos buscar, el fragmento de código siguiente se devuelve el último archivo modificado en su interior:

    Files.walk(thePath)
    .sorted((f1, f2) -> -(int)(f1.toFile().lastModified() - f2.toFile().lastModified()))
    .skip(1)
    .findFirst()

    Lo que hace es:

    • primera ordenar los archivos por fecha de su última modificación vez a la inversa,
    • a continuación, omita el propio directorio,
    • y, finalmente, tomar el primer elemento de la secuencia (que es la última modificación de uno).
    • Mientras este fragmento de código puede ser la solución, incluyendo una explicación realmente ayuda a mejorar la calidad de tu post. Recuerde que usted está respondiendo a la pregunta para los lectores en el futuro, y esas personas pueden no saber las razones de su sugerencia de código.

Dejar respuesta

Please enter your comment!
Please enter your name here