Найкращий спосіб переліку файлів на Java, відсортованих за датою зміни?

Я хочу отримати список файлів у каталозі, але хочу сортувати його таким чином, щоб найстаріші файли були першими. Моє рішення було зателефонувати на File.listFiles і просто вдатися до списку на основі File.lastModified, але мені було цікаво, чи є кращий спосіб.

Редагувати: Моє поточне рішення, як пропонується, полягає у використанні анонімного компаратора:

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

Я думаю, що ваше рішення - єдиний розумний спосіб. Єдиний спосіб отримати список файлів - це використовувати File.listFiles (), і в документації зазначено, що це не дає гарантій щодо порядку повернення файлів. Тому вам потрібно написати компаратор, який використовує File.lastModified (), і передати це разом з масивом файлів до Arrays.sort () .

Це може бути швидше, якщо у вас багато файлів. При цьому використовується шаблон оформлення-сортування-підкреслення, так що остання змінена дата кожного файлу отримується лише один раз, а не кожен раз, коли алгоритм сортування порівнює два файли. Це потенційно зменшує кількість викликів вводу / виводу з O (n log n) до O (n).

Однак це більше коду, тому його слід використовувати лише в тому випадку, якщо ви в основному переймаєтеся швидкістю, і це помітно швидше на практиці (що я не перевіряв).

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;

Елегантне рішення з Java 8:

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

Або, якщо ви хочете це у низхідному порядку, просто переверніть його:

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

Що стосується подібного підходу, але без боксу до Довгих об'єктів:

File[] files = directory.listFiles();

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

Ви також можете поглянути на IO apache commons , він має вбудований останній модифікований компаратор та багато інших приємних утиліт для роботи з файлами.

На Java 8:

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

Імпорт:

org.apache.commons.io.comparator.LastModifiedFileComparator

Apache Commons

Код:

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

    }

Якщо файли, які Ви сортуєте, можна одночасно змінювати або оновлювати, то сортування виконується:

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

Обидва ці рішення створюють тимчасову структуру даних карт, щоб заощадити постійний останній змінений час для кожного файлу в каталозі. Причиною, що нам потрібно зробити це, є те, що якщо ваші файли оновлюються або змінюються під час виконання сортування, то ваш компаратор буде порушувати вимогу про транзитивність загального контракту інтерфейсу компаратора, оскільки останні порівнянні часи можуть змінюватися під час порівняння.

Якщо, з іншого боку, ви знаєте, що файли не будуть оновлюватися чи змінюватися під час вашого сортування, ви можете отримати майже будь-яку іншу відповідь, подану на це запитання, з якої я частково:

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

Примітка. Я знаю, що ви можете уникнути перекладу до та з Файлових об’єктів у наведеному вище прикладі, використовуючи файл Files :: getLastModifiedTime api в режимі відсортованого потоку, однак тоді вам потрібно мати справу з перевіреними винятками IO всередині вашої лямбда, що завжди є болем . Я б сказав, якщо продуктивність достатньо критична, що переклад неприйнятний, то я б або мав справу з перевіреною IOException в лямбда, розповсюджуючи її як UncontIOException, або я б відмовився від файлів api і працював лише з об'єктами 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());
        }
    });

де listFilesзнаходиться колекція всіх файлів у ArrayList

Ви можете спробувати замовити гуаву :

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

Ви можете використовувати бібліотеку 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;
}

Я прийшов на цю посаду, коли шукав ту саму проблему, але в android . Я не кажу, що це найкращий спосіб отримати відсортовані файли за останньою зміненою датою, але це найпростіший спосіб, який я знайшов поки.

Нижче код може бути корисним для когось,

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
    }

Дякую

Існує дуже простий і зручний спосіб вирішити проблему без зайвого порівняння. Просто введіть модифіковану дату в String з назвою файлу, відсортуйте її та пізніше зніміть.

Використовуйте рядок фіксованої довжини 20, введіть у неї змінену дату (довгу) та заповніть провідними нулями. Потім просто додайте ім'я файлу до цього рядка:

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

Що відбувається, це ось що:

Ім'я файлу1: C: \ data \ file1.html Остання зміна: 1532914451455 Остання зміна 20 цифр: 00000001532914451455

Ім'я файлу1: C: \ data \ file2.html Остання зміна: 1532918086822 Остання зміна 20 цифр: 00000001532918086822

перетворює імена файлів у:

Назва файлу1: 00000001532914451455C: \ data \ file1.html

Ім'я файлу2: 00000001532918086822C: \ data \ file2.html

Потім ви можете просто сортувати цей список.

Все, що вам потрібно зробити, - це знімати 20 символів знову пізніше (у Java 8 ви можете знімати його для всього масиву лише одним рядком за допомогою функції .replaceAll)

Існує також зовсім інший спосіб, який може бути ще простішим, оскільки ми не маємо справу з великою кількістю.

Замість того, щоб сортувати весь масив після того, як ви отримали всі назви файлів і дати останнього модифікації, ви можете просто вставити кожне ім’я файлу відразу після того, як ви знайдете його в потрібному місці списку.

Ви можете це зробити так:

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

Після того, як ви додасте object2 у позицію 2, він перемістить object3 у позицію 3.