Ordner schnell durchlesen

[itbuilder07]

Morgen liebes Forum,

ich habe ein Problem. Ich möchte gern ein Ordner durchlesen, der innerhalb sehr viele Dateien enthält. Wir reden hier von 300 weiteren Ordnern und ungefähr 2800 Dateien. Zurzeit mache ich das mit einer zweifachen Schleife und mit der listfiles()- Methode.
Zweifachen Schleife um im 1.Schritt die Ordner und im 2. Schritt innerhalb jedes Ordners die Dateien einzulesen. Ziel ist es bestimmte Dateien die eine gewisse Endung haben zu finden und sofort zu verarbeiten.
Ich habe schon geschaut die Verarbeitung der Dateien geht in bruchteilen von sekunden.
Die Analyse und Findung der Dateien mit einer bestimmten Endung kann durchaus dauern.

Ich habe mal die Zeit gestoppt, die Verarbeitungsdauer dauert ca. 20 sek +/-.
Natürlich ist das nicht gerade langsam in Betracht der Menge, dennoch gibt es eventuell eine effizientere und schnellere Lösung?

Vielen Dank schon mal 😀

 

[ssoul26]

Wie sieht dein Code momentan aus? Wäre nicht schlecht den zu sehen! Dann können wir evtl. Optimierungsvorschläge geben! 😉

 

[itbuilder07]

Ja klar entschuldige völlig vergessen 🙂

			String eingabePfad = args[0];
			String ausgabePfad = args[1];
			File pfad = new File(eingabePfad);
			if (pfad.exists()) {
				File[] ordnerArray = pfad.listFiles();
				for (int i = 0; i < ordnerArray.length; i++) {

					String[] ordnerUnterArray = ordnerArray[i].list();
					for (int j = 0; j < ordnerUnterArray.length; j++) {
						if (ordnerUnterArray[j].endsWith("xx.xx")) {
							new copyLesen(ordnerUnterArray[j],ordnerArray[i],
									ausgabePfad);
						} else if (ordnerUnterArray[j].endsWith("xx.xx")) {
							new DateiLesen(ordnerUnterArray[j],ordnerArray[i],
									ausgabePfad);
						}
					}
				}

Die Begriffe in der If Bedingung hab ich abgeändert. Da steht normal was sinnvolles ^^

 

[ssoul26]

Guck dir mal das an, und überprüfe ob es schneller ist und vllt. geeigneter. Hier erfolgt die Suche "Rekursiv".

public class Files {
   /**
    * @param args
    */
   public static void main(String[] args) {
      File f = new File("C://");
      searchFile(f, ".doc");
   }

   private static void searchFile(File root, String ending) {
      File[] files = root.listFiles();
      for (File f : files) {
         if (f.isDirectory()) {
            searchFile(f, ending);
         } else {
            String path = f.getAbsolutePath();
            if (path.endsWith(ending)) {
               System.out.println(path);
            }
         }
      }
   }
}

 

[arilou]

Da ist wohl kaum eine Beschleunigung machbar.
Ggf könntest du
new copyLesen(...);
und
new DateiLesen(...);
ersetzen durch (static) Methodenaufrufe - das Erzeugen neuer Objekte ist Rechenzeit-teuer.
Evtl. ist auch das Lesen/Schreiben selbst noch beschleunigbar, aber an .listFiles() und den beiden Schleifen kommst' wohl kaum vorbei.

 

[ssoul26]

Da ist wohl kaum eine Beschleunigung machbar.
Ggf könntest du
new copyLesen(...);
und
new DateiLesen(...);
ersetzen durch (static) Methodenaufrufe - das Erzeugen neuer Objekte ist Rechenzeit-teuer.
Evtl. ist auch das Lesen/Schreiben selbst noch beschleunigbar, aber an .listFiles() und den beiden Schleifen kommst' wohl kaum vorbei.

Welche beiden Schleifen meinst du denn, die unentbehrlich sind? Rekursiv bräuchtest du nur eine Schleife. Siehe oben.

 

[Thallius]

Du sagst selber das Ermitteln dauernt nicht lange sondern das Verarbeiten, zeigst uns aber nur den Code der ermittelt. Optimieren müssen wirst du ja wohl oder übel in den beiden Konstruktoren copyLesen und DateiLesen.

Mal ganz davon abgesehen, dass es nach Konventio auch CopyLesen heissen müßte finde ich doie Namen ziemlich gruselig.

Gruß

Claus

 

[jgh]

lass doch deine Klassen "copyLesen" und "DateiLesen" das Runnable-Interface implementieren und starte damit jeweils einen neuen Thread.

 

[Flown]

Also ich würde NIO.2 verwenden (Java 8):

Spoiler: FileSearch

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;
import java.util.stream.Collectors;

public class FileSearch {
    
    private static final String ENDING = ".rgb";
    
    public static void main(String[] args) {
        new FileSearch();
    }
    
    public FileSearch() {
        Path start = Paths.get("parent");
        try {
            
            List<Path> files = Files.find(start, Integer.MAX_VALUE, (path, attribute) -> path.toString().endsWith(ENDING)).collect(Collectors.toList());
            System.out.println(files.size());
            files.forEach(e -> doStuff(e));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private void doStuff(Path e) {
//        System.out.println(e.toString());
    }

}

 

[arilou]

Welche beiden Schleifen meinst du denn, die unentbehrlich sind? Rekursiv bräuchtest du nur eine Schleife. Siehe oben.

Er scheint zu wissen, dass die erste Dateisystem-Ebene nur Unterverzeichnisse beinhaltet, und darin dann nur einfache Dateien sind - damit kann er sich .isDirectory()-Tests sparen.

Rekursiv werden aus den zwei Schleifen dann (implizit) eine Rekursionstiefe von 2 (sowie implizit zwei Fälle - Directory vs. einfache Datei).

 

[arilou]

lass doch deine Klassen "copyLesen" und "DateiLesen" das Runnable-Interface implementieren und starte damit jeweils einen neuen Thread.

Bringt vmtl. nichts, kann sogar kontraproduktiv sein.
Wenn 2 (oder mehr) Threads Dateien einlesen, zerschießen sie sich gerne gegenseitig die Caches.
Alternativ dreht die HDD hohl, weil sie plötzlich "fragmentiert" lesen soll - für die Festplatte geht's "wild durcheinander".
Solange man in der Verarbeitung einen Flaschenhals hat, sollte man bzgl. diesem schön -hm- strukturiert/linearisiert/serialisiert bleiben, das ist meist am schnellsten.

 

[osion]

Morgen liebes Forum,

ich habe ein Problem. Ich möchte gern ein Ordner durchlesen, der innerhalb sehr viele Dateien enthält. Wir reden hier von 300 weiteren Ordnern und ungefähr 2800 Dateien. Zurzeit mache ich das mit einer zweifachen Schleife und mit der listfiles()- Methode.
Zweifachen Schleife um im 1.Schritt die Ordner und im 2. Schritt innerhalb jedes Ordners die Dateien einzulesen. Ziel ist es bestimmte Dateien die eine gewisse Endung haben zu finden und sofort zu verarbeiten.
Ich habe schon geschaut die Verarbeitung der Dateien geht in bruchteilen von sekunden.
Die Analyse und Findung der Dateien mit einer bestimmten Endung kann durchaus dauern.

Ich habe mal die Zeit gestoppt, die Verarbeitungsdauer dauert ca. 20 sek +/-.
Natürlich ist das nicht gerade langsam in Betracht der Menge, dennoch gibt es eventuell eine effizientere und schnellere Lösung?

Vielen Dank schon mal 😀

Frage:

1. Was für ein Prozessor hast du drin ? (wie alt ist der Computer?)
2. Wo befinden sich die Dateien?
3. Total hast du 300 Ordner +2800 Dateien?
4. Warum machst du keine Threads?
---
Was ist der Sinn des Programms?