Cara terbaik untuk membuat daftar file di Jawa, disortir berdasarkan Tanggal Dimodifikasi?

Saya ingin mendapatkan daftar file dalam direktori, tetapi saya ingin menyortirnya sehingga file terlama adalah yang pertama. Solusi saya adalah memanggil File.listFiles dan hanya menggunakan daftar berdasarkan File.lastModified, tapi saya bertanya-tanya apakah ada cara yang lebih baik.

Sunting: Solusi saya saat ini, seperti yang disarankan, adalah dengan menggunakan Pembanding anonim:

File[] files = directory.listFiles();

Arrays.sort(files, new Comparator<File>(){
    public int compare(File f1, File f2)
    {
        return Long.valueOf(f1.lastModified()).compareTo(f2.lastModified());
    } });

Saya pikir solusi Anda adalah satu-satunya cara yang masuk akal. Satu-satunya cara untuk mendapatkan daftar file adalah dengan menggunakan File.listFiles () dan dokumentasi menyatakan bahwa ini tidak membuat jaminan tentang urutan file yang dikembalikan. Oleh karena itu Anda perlu menulis Comparator yang menggunakan File.lastModified () dan meneruskannya, bersama dengan array file, ke Arrays.sort () .

Ini mungkin lebih cepat jika Anda memiliki banyak file. Ini menggunakan pola menghias-sort-undecorate sehingga tanggal modifikasi terakhir dari setiap file diambil hanya sekali daripada setiap kali algoritma sortir membandingkan dua file. Ini berpotensi mengurangi jumlah panggilan I / O dari O (n log n) ke O (n).

Ini lebih banyak kode, jadi ini hanya boleh digunakan jika Anda terutama mementingkan kecepatan dan lebih cepat terukur dalam praktiknya (yang belum saya periksa).

class Pair implements Comparable {
    public long t;
    public File f;

    public Pair(File file) {
        f = file;
        t = file.lastModified();
    }

    public int compareTo(Object o) {
        long u = ((Pair) o).t;
        return t < u ? -1 : t == u ? 0 : 1;
    }
};

// Obtain the array of (file, timestamp) pairs.
File[] files = directory.listFiles();
Pair[] pairs = new Pair[files.length];
for (int i = 0; i < files.length; i++)
    pairs[i] = new Pair(files[i]);

// Sort them by timestamp.
Arrays.sort(pairs);

// Take the sorted pairs and extract only the file part, discarding the timestamp.
for (int i = 0; i < files.length; i++)
    files[i] = pairs[i].f;

Solusi elegan sejak Java 8:

File[] files = directory.listFiles();
Arrays.sort(files, Comparator.comparingLong(File::lastModified));

Atau, jika Anda menginginkannya dalam urutan menurun, balikkan saja:

File[] files = directory.listFiles();
Arrays.sort(files, Comparator.comparingLong(File::lastModified).reversed());

Bagaimana dengan pendekatan yang serupa, tetapi tanpa tinju ke objek Panjang:

File[] files = directory.listFiles();

Arrays.sort(files, new Comparator<File>() {
    public int compare(File f1, File f2) {
        return Long.compare(f1.lastModified(), f2.lastModified());
    }
});

Anda juga dapat melihat apache commons IO , ia memiliki komparator modifikasi terakhir dan banyak utilitas bagus lainnya untuk bekerja dengan file.

Di Jawa 8:

Arrays.sort(files, (a, b) -> Long.compare(a.lastModified(), b.lastModified()));

Impor:

org.apache.commons.io.comparator.LastModifiedFileComparator

Apache Commons

Kode:

public static void main(String[] args) throws IOException {
        File directory = new File(".");
        // get just files, not directories
        File[] files = directory.listFiles((FileFilter) FileFileFilter.FILE);

        System.out.println("Default order");
        displayFiles(files);

        Arrays.sort(files, LastModifiedFileComparator.LASTMODIFIED_COMPARATOR);
        System.out.println("\nLast Modified Ascending Order (LASTMODIFIED_COMPARATOR)");
        displayFiles(files);

        Arrays.sort(files, LastModifiedFileComparator.LASTMODIFIED_REVERSE);
        System.out.println("\nLast Modified Descending Order (LASTMODIFIED_REVERSE)");
        displayFiles(files);

    }

Jika file yang Anda sortir dapat dimodifikasi atau diperbarui pada saat yang sama, sortir dilakukan:

Java 8+

private static List<Path> listFilesOldestFirst(final String directoryPath) throws IOException {
    try (final Stream<Path> fileStream = Files.list(Paths.get(directoryPath))) {
        return fileStream
            .map(Path::toFile)
            .collect(Collectors.toMap(Function.identity(), File::lastModified))
            .entrySet()
            .stream()
            .sorted(Map.Entry.comparingByValue())
//            .sorted(Collections.reverseOrder(Map.Entry.comparingByValue()))  // replace the previous line with this line if you would prefer files listed newest first
            .map(Map.Entry::getKey)
            .map(File::toPath)  // remove this line if you would rather work with a List<File> instead of List<Path>
            .collect(Collectors.toList());
    }
}

Java 7

private static List<File> listFilesOldestFirst(final String directoryPath) throws IOException {
    final List<File> files = Arrays.asList(new File(directoryPath).listFiles());
    final Map<File, Long> constantLastModifiedTimes = new HashMap<File,Long>();
    for (final File f : files) {
        constantLastModifiedTimes.put(f, f.lastModified());
    }
    Collections.sort(files, new Comparator<File>() {
        @Override
        public int compare(final File f1, final File f2) {
            return constantLastModifiedTimes.get(f1).compareTo(constantLastModifiedTimes.get(f2));
        }
    });
    return files;
}

Kedua solusi ini membuat struktur data peta sementara untuk menghemat waktu modifikasi terakhir konstan untuk setiap file dalam direktori. Alasan kami perlu melakukan ini adalah bahwa jika file Anda sedang diperbarui atau dimodifikasi saat pengurutan Anda dilakukan maka komparator Anda akan melanggar persyaratan transitivitas dari kontrak umum antarmuka komparator karena waktu modifikasi terakhir dapat berubah selama perbandingan.

Jika, di sisi lain, Anda tahu file tidak akan diperbarui atau diubah selama pengurutan Anda, Anda bisa lolos dengan cukup banyak jawaban lain yang dikirimkan ke pertanyaan ini, yang sebagian saya:

Java 8+ (Tidak ada modifikasi bersamaan saat penyortiran)

private static List<Path> listFilesOldestFirst(final String directoryPath) throws IOException {
    try (final Stream<Path> fileStream = Files.list(Paths.get(directoryPath))) {
        return fileStream
            .map(Path::toFile)
            .sorted(Comparator.comparing(File::lastModified))
            .map(File::toPath)  // remove this line if you would rather work with a List<File> instead of List<Path>
            .collect(Collectors.toList());
    }
}

Catatan: Saya tahu Anda dapat menghindari terjemahan ke dan dari objek File dalam contoh di atas dengan menggunakan File :: getLastModifiedTime api dalam operasi aliran yang diurutkan, namun, maka Anda harus berurusan dengan pengecualian IO yang dicentang di dalam lambda Anda yang selalu menyusahkan. . Saya akan mengatakan jika kinerjanya cukup kritis sehingga terjemahannya tidak dapat diterima maka saya akan berurusan dengan IOException yang dicentang di lambda dengan menyebarkannya sebagai UncheckedIOException atau saya akan mengabaikan api File sama sekali dan hanya berurusan dengan objek File:

final List<File> sorted = Arrays.asList(new File(directoryPathString).listFiles());
sorted.sort(Comparator.comparing(File::lastModified));

public String[] getDirectoryList(String path) {
    String[] dirListing = null;
    File dir = new File(path);
    dirListing = dir.list();

    Arrays.sort(dirListing, 0, dirListing.length);
    return dirListing;
}

Collections.sort(listFiles, new Comparator<File>() {
        public int compare(File f1, File f2) {
            return Long.compare(f1.lastModified(), f2.lastModified());
        }
    });

di mana listFileskoleksi semua file di ArrayList

Anda dapat mencoba Pemesanan jambu biji :

Function<File, Long> getLastModified = new Function<File, Long>() {
    public Long apply(File file) {
        return file.lastModified();
    }
};

List<File> orderedFiles = Ordering.natural().onResultOf(getLastModified).
                          sortedCopy(files);

Anda dapat menggunakan perpustakaan Apache LastModifiedFileComparator

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


File[] files = directory.listFiles();
        Arrays.sort(files, LastModifiedFileComparator.LASTMODIFIED_COMPARATOR);
        for (File file : files) {
            Date lastMod = new Date(file.lastModified());
            System.out.println("File: " + file.getName() + ", Date: " + lastMod + "");
        }

private static List<File> sortByLastModified(String dirPath) {
    List<File> files = listFilesRec(dirPath);
    Collections.sort(files, new Comparator<File>() {
        public int compare(File o1, File o2) {
            return Long.compare(o1.lastModified(), o2.lastModified());
        }
    });
    return files;
}

Saya datang ke pos ini ketika saya mencari masalah yang sama tetapi di android. Saya tidak mengatakan ini adalah cara terbaik untuk mendapatkan file yang diurutkan berdasarkan tanggal modifikasi terakhir, tetapi ini adalah cara termudah yang saya temukan.

Kode di bawah ini dapat membantu seseorang-

File downloadDir = new File("mypath");    
File[] list = downloadDir.listFiles();
    for (int i = list.length-1; i >=0 ; i--) {
        //use list.getName to get the name of the file
    }

Terima kasih

Ada cara yang sangat mudah dan nyaman untuk menangani masalah tanpa pembanding tambahan. Hanya kode tanggal yang diubah ke dalam String dengan nama file, urutkan, dan kemudian lepas lagi.

Gunakan String dengan panjang tetap 20, masukkan tanggal yang dimodifikasi (panjang) ke dalamnya, dan isi dengan nol di depannya. Kemudian tambahkan saja nama file ke string ini:

String modified_20_digits = ("00000000000000000000".concat(Long.toString(temp.lastModified()))).substring(Long.toString(temp.lastModified()).length()); 

result_filenames.add(modified_20_digits+temp.getAbsoluteFile().toString());

Apa yang terjadi adalah ini di sini:

Nama file1: C: \ data \ file1.html Terakhir Dimodifikasi: 1532914451455 Dimodifikasi Terakhir 20 Digit: 00000001532914451455

Nama file1: C: \ data \ file2.html Terakhir Dimodifikasi: 1532918086822 Terakhir Dimodifikasi 20 Digit: 00000001532918086822

mengubah nama file menjadi:

Nama file1: 00000001532914451455C: \ data \ file1.html

Namafile2: 00000001532918086822C: \ data \ file2.html

Anda kemudian dapat mengurutkan daftar ini.

Yang perlu Anda lakukan adalah mengupas 20 karakter lagi nanti (di Java 8, Anda dapat menghapusnya untuk seluruh Array hanya dengan satu baris menggunakan fungsi .replaceAll)

Ada juga cara yang sama sekali berbeda yang mungkin lebih mudah, karena kita tidak berurusan dengan jumlah besar.

Alih-alih menyortir seluruh array setelah Anda mengambil semua nama file dan tanggal modifikasi terakhir, Anda bisa memasukkan setiap nama file saja setelah Anda mengambilnya di posisi yang tepat dari daftar.

Anda dapat melakukannya seperti ini:

list.add(1, object1)
list.add(2, object3)
list.add(2, object2)

Setelah Anda menambahkan object2 ke posisi 2, itu akan memindahkan object3 ke posisi 3.