Finden Sie die 3 zuletzt geänderten Dateien in einer langen Liste von Dateien

Ich habe eine Datei in der Liste, die möchte ich Sortieren und extrahieren Sie die top 3 der letzten änderung.

Einschränkung: ich kann nicht mit Java 7 aufgrund von Kompatibilitätsproblemen auf den downstream-apps

Meine aktuellen Optionen

Lösung 1

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

Lösung 2

public static void sortFilesDesc(File[] files) {
  Arrays.sort(files, new Comparator() {
    public int compare(Object o1, Object o2) {
      if ((File)o1).lastModified().compareTo((File)o2).lastModified()) {
        return -1;
      } else if (((File) o1).lastModified() < ((File) o2).lastModified()) {
        return +1;
      } else {
        return 0;
      }
    }
  });
}

Problem

Den beiden oben genannten Lösung mehr Zeit braucht, um auszuführen, & Speicher. Meine Datei Liste besteht aus rund 300 tar-Dateien mit 200MB Größe jeder. so ist es verbraucht mehr Zeit & memory.

Gibt es irgendeinen Weg, um effizient zu handhaben?

Jeder Vergleichsoperation wird ein file-Objekt, das von hohen Speicher, ist es eine Möglichkeit, den Speicher freizugeben, und behandelt diese effektiv?

Ich denke, dass Ihr Speicher-und timing-Probleme werden nicht durch Ihre Sortierung von 300 items (die im Speicher sind, sowieso). Vielleicht sind Sie in der Durchführung der Sortierung mehr als einmal?
Nope, ich bin über eine der beiden oben genannten Lösungen. was du meinst mit dem "in Erinnerung sowieso" wie kann ich klar, dass sobald die operation abgeschlossen.
Ein File Objekt ist nicht eine teure Objekt! Es enthält nur den Dateinamen, nicht den Inhalt der Datei. Also die Größe der Datei ist völlig irrelevant.

InformationsquelleAutor Wills | 2013-01-17

Können Sie dies viel schneller tun.

Arrays.sort(...) verwendet "schnellen Sorte", die ~ n * ln(n) Operationen.

Diesem Beispiel wird nur eine iteration durch das gesamte array, die ~ n Operationen.

public static void sortFilesDesc(File[] files) {        
    File firstMostRecent = null;
    File secondMostRecent = null;
    File thirdMostRecent = null;
    for (File file : files) {
        if ((firstMostRecent == null)
                || (firstMostRecent.lastModified() < file.lastModified())) {
            thirdMostRecent = secondMostRecent;
            secondMostRecent = firstMostRecent;             
            firstMostRecent = file;
        } else if ((secondMostRecent == null)
                || (secondMostRecent.lastModified() < file.lastModified())) {
            thirdMostRecent = secondMostRecent;
            secondMostRecent = file;
        } else if ((thirdMostRecent == null)
                || (thirdMostRecent.lastModified() < file.lastModified())) {
            thirdMostRecent = file;
        }
    }
}

Einer kleinen Anzahl von Dateien, die Sie nicht sehen, viel Unterschied, aber selbst bei zig Dateien ist der Unterschied wesentlich, für größere zahlen - dramatisch.

Den code zu überprüfen, den Algorithmus (setzen Sie bitte in einem korrekten Dateien-Struktur):

package com.hk.basicjava.clasload.tests2;

import java.io.File;
import java.util.Date;


class MyFile extends File {

    private long time = 0; 

    public MyFile(String name, long timeMills) {
        super(name);
        time = timeMills;
    }
    @Override
    public long lastModified() {
        return time;
    }
}

public class Files {

    /**
     * @param args
     */
    public static void main(String[] args) {

        File[] files = new File[5]; 
        files[0] = new MyFile("File1", new Date(2013,1,15, 7,0).getTime());
        files[1] = new MyFile("File2", new Date(2013,1,15, 7,40).getTime());
        files[2] = new MyFile("File3", new Date(2013,1,15, 5,0).getTime());
        files[3] = new MyFile("File4", new Date(2013,1,15, 10,0).getTime());
        files[4] = new MyFile("File5", new Date(2013,1,15, 4,0).getTime());
        sortFilesDesc(files);
    }

    public static void sortFilesDesc(File[] files) {        
        File firstMostRecent = null;
        File secondMostRecent = null;
        File thirdMostRecent = null;
        for (File file : files) {
            if ((firstMostRecent == null)
                    || (firstMostRecent.lastModified() < file.lastModified())) {
                thirdMostRecent = secondMostRecent;
                secondMostRecent = firstMostRecent;             
                firstMostRecent = file;
            } else if ((secondMostRecent == null)
                    || (secondMostRecent.lastModified() < file.lastModified())) {
                thirdMostRecent = secondMostRecent;
                secondMostRecent = file;
            } else if ((thirdMostRecent == null)
                    || (thirdMostRecent.lastModified() < file.lastModified())) {
                thirdMostRecent = file;
            }
        }
        System.out.println("firstMostRecent : " + firstMostRecent.getName());
        System.out.println("secondMostRecent : " + secondMostRecent.getName());
        System.out.println("thirdMostRecent : " + thirdMostRecent.getName());
    } 

}

Bitte entfernen Sie den "fast 6-mal" - argument. Sie kann nicht vergleichen die Laufzeiten für verschiedene algorithmen, die durch einfügen von Ziffern in die Komplexität der Formel. Die Schlussfolgerung ist richtig, aber das argument ist fehlerhaft.
Ich Stimme zu, das ist nicht ganz richtig; das ist nur um die Leute "fühlen Sie den Unterschied".
Danke @AlexKreutznaer. Ihre Lösung funktioniert nicht für alle case-Szenarien betrachten Sie Beispielsweise die unten und Spurenelemente, die er für Ihren Algorithmus. Dateiname : FXXXXXXXXX Geändert, 07:00 UHR Dateiname : FXXXXXXXXX Geändert, 07:40 UHR Datei-name : MXXXXXXXXX Geändert, 05:00 UHR Dateiname : YXXXXXXXXX Geändert 10:00 UHR<\code> Datei-name : YXXXXXXXXX Geändert, 04:00 UHR
Warum es nicht funktioniert? Es wird perfekt funktionieren. Können Sie erklären, warum SIE denken, es wird nicht funktionieren? Es gibt nichts in Ihr Beispiel, was Sie machen wird es nicht funktionieren.
Hast du Spur der Algorithmus? Können Sie uns das Ergebnis Ihrer Spur? Ich bin sicher, es ist ein Fehler in deinem trace. Die Aufgabe ist sehr einfach.
Bitte abgeben. kann jemand verschieben diese Diskussion chat bitte ? Ich habe nicht genug Punkte, um es zu bewegen
Ich habe den code, um zu überprüfen, wie es funktioniert in meiner Antwort. Sie hat Ihre Daten. Einfach den code auszuführen.
Ja ich denke mal der neue code sollte es tun . Nochmals vielen Dank . Hochgeladen habe ich die Spur von Ihrem alten code hier txtup.net/bsdXV.

InformationsquelleAutor Alex Kreutznaer

Müssen Sie die lastModified jeder Datei, die Sie nicht ändern können, dass. Was Sie nicht tun müssen, ist zu Sortieren alle Elemente, nur um mit den top-3. Wenn Sie verwenden können, Guave, Sie könnte verwenden Mit der Bestellung.greatestOf (die verwendet einen guten Algorithmus):

Ordering<File> ordering = Ordering.from( new Comparator(){
        public int compare(File f1, File f2)
        {
            return Long.valueOf(f1.lastModified()).compareTo(f2.lastModified());
        });

List<File> max3 = ordering.greatestOf(Arrays.asList(directory.listFiles()), 3);

InformationsquelleAutor Aleksander Blomskøld

0

Ich bin für Lösung 1, mit einigen Verbesserungen
```
Arrays.sort(files, new Comparator<File>() {
        public int compare(File f1, File f2) {
            long d1 = f1.lastModified();
            long d2 = f2.lastModified();
            return d1 > d2 ? 1 : d1 < d2 ? -1 : 0;
        }
    });
```
zur Vermeidung unnötiger Objekte der Schöpfung, weil der Lange.valueOf(long).

File nicht halten /Lesen, Datei-Daten, sondern nur den Pfad der Datei, gibt es keine performance /Speicher-Problem mit es. Den nur zeitaufwändiger Vorgang hier liest das änderungsdatum von Datei-system, die nicht vermieden werden können.
- Lange.vergleichen Sie kamen in Java 7, und die Frage für einen nicht-Java-7-Lösung.
- Jetzt haben Sie verändert den code, um etwas, das nicht kompiliert (inkompatible Typen, int/long).
- Warum ist dies eine Verbesserung im Vergleich zu den original-code?
- Das ganze Thema ist um Effizienz, meine Verbesserung ist über das loswerden der Erstellung 2 Lange Gegenstände.
InformationsquelleAutor Evgeniy Dorofeev
0

Dein problem ist, dass das abrufen des Datums der letzten änderung ist eine relativ teure operation, da es sich um Betriebssystem-Logik. Also, wenn Sie nichts dagegen haben, um die neuesten up-to-date-Werte, könnten Sie wickeln Sie Ihre Dateien in einer vergleichbaren Klasse.
```
public class LastModifiedFile implements Comparable<LastModifiedFile> {

    private final File file;
    private final Date lastModified;

    public LastModifiedFile(File file) {
        this.file = file;
        lastModified = file.lastModified();
    }

    public int compareTo(LastModifiedFile other) {
        return lastModified.compareTo(other.lastModified);
    }
}
```
Beachten Sie, dass eine änderung des Datums der letzten änderung während Ihre Sortierung wird nicht definiertes Verhalten zur Folge, die für viele Sortier-algorithmen. Java-7s Tim Sortieren Umsetzung, wird eine Ausnahme ausgelöst, wenn ein Datum der letzten änderung ändert und damit Vergleiche andere Werte ergeben.

InformationsquelleAutor SpaceTrucker

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.