Determina la data di creazione del file in Java

C'è un'altra domanda simile alla mia su StackOverflow ( come ottenere la data di creazione di un file in Java ), ma la risposta non è davvero lì poiché l'OP aveva una necessità diversa che poteva essere risolta tramite altri meccanismi. Sto cercando di creare un elenco dei file in una directory che può essere ordinata per età, da qui la necessità della data di creazione del file.

Non ho trovato alcun buon modo per farlo dopo molte ricerche sul web. Esiste un meccanismo per ottenere le date di creazione dei file?

BTW, attualmente su un sistema Windows, potrebbe aver bisogno di questo per funzionare anche su un sistema Linux. Inoltre, non posso garantire che venga seguita una convenzione di denominazione dei file in cui la data / ora di creazione è incorporata nel nome.

Java nio ha opzioni per accedere a creationTime e altri metadati fintanto che il filesystem lo fornisce. Controllare questo link out

Ad esempio (fornito in base al commento di @ ydaetskcoR):

Path file = ...;
BasicFileAttributes attr = Files.readAttributes(file, BasicFileAttributes.class);

System.out.println("creationTime: " + attr.creationTime());
System.out.println("lastAccessTime: " + attr.lastAccessTime());
System.out.println("lastModifiedTime: " + attr.lastModifiedTime());

Ho risolto questo problema usando JDK 7 con questo codice:

package FileCreationDate;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.Date;
import java.util.concurrent.TimeUnit;

public class Main
{
    public static void main(String[] args) {

        File file = new File("c:\\1.txt");
        Path filePath = file.toPath();

        BasicFileAttributes attributes = null;
        try
        {
            attributes =
                    Files.readAttributes(filePath, BasicFileAttributes.class);
        }
        catch (IOException exception)
        {
            System.out.println("Exception handled when trying to get file " +
                    "attributes: " + exception.getMessage());
        }
        long milliseconds = attributes.creationTime().to(TimeUnit.MILLISECONDS);
        if((milliseconds > Long.MIN_VALUE) && (milliseconds < Long.MAX_VALUE))
        {
            Date creationDate =
                    new Date(attributes.creationTime().to(TimeUnit.MILLISECONDS));

            System.out.println("File " + filePath.toString() + " created " +
                    creationDate.getDate() + "/" +
                    (creationDate.getMonth() + 1) + "/" +
                    (creationDate.getYear() + 1900));
        }
    }
}

In seguito a questa domanda - poiché si riferisce specificamente al tempo di creazione e discute come ottenerlo tramite le nuove classi nio - sembra che in questo momento nell'implementazione di JDK7 tu sia sfortunato. Addendum: lo stesso comportamento è in OpenJDK7.

Su filesystem Unix non è possibile recuperare il timestamp di creazione, si ottiene semplicemente una copia dell'ora dell'ultima modifica. Così triste, ma purtroppo vero. Non sono sicuro del motivo, ma il codice lo fa specificamente come dimostrerà di seguito.

import java.io.IOException;
import java.nio.file.*;
import java.nio.file.attribute.*;

public class TestFA {
  static void getAttributes(String pathStr) throws IOException {
    Path p = Paths.get(pathStr);
    BasicFileAttributes view
       = Files.getFileAttributeView(p, BasicFileAttributeView.class)
              .readAttributes();
    System.out.println(view.creationTime()+" is the same as "+view.lastModifiedTime());
  }
  public static void main(String[] args) throws IOException {
    for (String s : args) {
        getAttributes(s);
    }
  }
}

Questo è un esempio di base di come ottenere la data di creazione di un file Java, utilizzando la BasicFileAttributesclasse:

   Path path = Paths.get("C:\\Users\\jorgesys\\workspaceJava\\myfile.txt");
    BasicFileAttributes attr;
    try {
    attr = Files.readAttributes(path, BasicFileAttributes.class);
    System.out.println("Creation date: " + attr.creationTime());
    //System.out.println("Last access date: " + attr.lastAccessTime());
    //System.out.println("Last modified date: " + attr.lastModifiedTime());
    } catch (IOException e) {
    System.out.println("oops error! " + e.getMessage());
}

L'API di java.io.Filesupporta solo il recupero dell'ultima ora modificata . E anche su questo argomento Internet è molto silenzioso.

A meno che non mi sia perso qualcosa di significativo, la libreria Java così com'è (fino a, ma non include ancora Java 7) non include questa funzionalità. Quindi, se tu fossi disperato per questo, una soluzione sarebbe scrivere del codice C (++) per chiamare le routine di sistema e chiamarlo usando JNI. La maggior parte di questo lavoro sembra essere già fatto per te in una libreria chiamata JNA , però.

Potrebbe comunque essere necessario eseguire un po 'di codifica specifica del sistema operativo in Java per questo, tuttavia, poiché probabilmente non troverai le stesse chiamate di sistema disponibili in Windows e Unix / Linux / BSD / OS X.

Su un sistema Windows, puoi utilizzare la libreria FileTimes gratuita .

Questo sarà più facile in futuro con Java NIO.2 (JDK 7) e il pacchetto java.nio.file.attribute .

Ma ricorda che la maggior parte dei filesystem Linux non supporta i timestamp per la creazione di file .

in java1.7 + Puoi usare questo codice per ottenere l'ora di creazione del file!

private static LocalDateTime getCreateTime(File file) throws IOException {
        Path path = Paths.get(file.getPath());
        BasicFileAttributeView basicfile = Files.getFileAttributeView(path, BasicFileAttributeView.class, LinkOption.NOFOLLOW_LINKS);
        BasicFileAttributes attr = basicfile.readAttributes();
        long date = attr.creationTime().toMillis();
        Instant instant = Instant.ofEpochMilli(date);
        return LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
    }