File Tree rekursiv

[Laren]

Hi,

Wollte einen File Tree programmieren, hab aber ein Problem, dass ich immer einen "java.lang.StackOverflowError" bekomme, was wohl an der rekursiven Methode "TreeAktualMethode" liegt, aber warum und wie lös ich das Problem?

Grüße

 public static void SetRoot() {
        //Root setzen

        oben = new DefaultMutableTreeNode("Verzeichnisse");
        tree.setModel(new DefaultTreeModel(oben));
        TreeAktualMethode(datei);
    }

    /**
     * rekursive Anwendung
     * @param datei
     *
     */
    public static void TreeAktualMethode(File datei) {
        TreeAktual aktual = new TreeAktual(datei);
        aktual.start();
        File[] drives = datei.listRoots();


        {


            for (int i = 0; i < drives.length; i++) {
                if (drives[i].isDirectory()) {
                    TreeAktualMethode(drives[i]);
                }
            }
            aktual.stop();

        }
    }

hier ist noch der Thread "TreeAktual"

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package dateiuebersicht;

import java.io.File;
import javax.swing.tree.DefaultMutableTreeNode;

/**
 *
 * @author René Hauck
 */
public class TreeAktual extends Thread {

    private static DefaultMutableTreeNode oben = DateiUebersichtView.oben;
    File datei;
    File[] drives;

    /**
     * Konstruktor
     */
    public TreeAktual(File datei) {
        this.datei = datei;
        drives = datei.listRoots();
    }

    @Override
    public void run() {
        for (int i = 0; i < drives.length; i++) {
            DefaultMutableTreeNode root = new DefaultMutableTreeNode(drives[i]);
            oben.add(root);
        }
    }
}

 

[SlaterB]

indem du dir anschaust, was du da überhaupt programmierst?!
weißt du wozu der ganze Code gut ist, weißt du was eine Datei ist, was die rekursive Methode dann ungefähr anstellen soll?
dann schaue doch nach ob sich das Programm auch nach diesen Vorgaben verhält,

logge/ untersuche den rekursiven Aufruf mit Debugger oder simplen System.out.println(),
schau nach was listRoots() jeweilse an (neuen oder doch nicht neuen?) Dateien liefert, ob diese korrekt der Reihe nach abgearbeitet werden usw.,

verwende am Anfang ein leeres Verzeichnis oder eines bei dem wenig Rekursion zu erwarten ist,
dass es doch wegen Fehler zu tausenden Aufrufen kommt weißt du schon, wenn du System.out.println() verwendest und zuviele Ausgaben auf einmal siehst, dann baue Thread.sleep(500); ein zur Verlansamung, mit try/catch drumherum

 

[André Uhres]

Ersetze zuerst mal listRoots durch listFiles .

Gruß,
André

 

[Laren]

Hi,

Hab jetzt mal nochmal drüber geschaut und es wird besser^^
Er listet jetzt die Ordner auf, aber ich weis nicht wie ich jedesmal einen Unterzweig erzeugen kann(bei mir packt er alles in einen Zweig), und er listet jetzt immer alles 2 mal ab.

package dateiuebersicht;

import java.io.File;
import javax.swing.tree.DefaultMutableTreeNode;


public class TreeAktual extends Thread {

    private static DefaultMutableTreeNode oben = DateiUebersichtView.unten;
    File datei;
    File[] drives;

    /**
     * Konstruktor
     */
    public TreeAktual(File datei) {
        this.datei = datei;
        drives = datei.listFiles();
    }

    @Override
    public void run() {

        for (int i = 0; i < drives.length; i++) {
            if(drives[i].isDirectory())
            {
            DefaultMutableTreeNode root = new DefaultMutableTreeNode(drives[i]);
            oben.add(root);
            TreeAktual aktual = new TreeAktual(drives[i]);
            aktual.start();
            }
        }
    }
}

  public static void SetRoot() {
        //Root setzen

        oben = new DefaultMutableTreeNode("Verzeichnisse");
        tree.setModel(new DefaultTreeModel(oben));
        TreeAktualMethode(datei);
    }

    /**
     * rekursive Anwendung
     * @param datei
     *
     */
    public static void TreeAktualMethode(File datei) {
       
       
        File[] drives = datei.listRoots();
        for (int i = 0; i<drives.length;i++)
        {

        unten = new DefaultMutableTreeNode(drives[i]);
        oben.add(unten);
        TreeAktual aktual = new TreeAktual(drives[i]);
        aktual.start();
       
        }
        
    }

 

[SlaterB]

du brauchst doch nicht für jeden rekursiven Aufruf einen neuen Thread, wenn dann reicht dir einer,
darin meinetwegen neue Objekte statt üblichen rekursiven Aufruf, kannst notfalls sogar neue TreeAktual-Thread-Objekte nehmen,
aber bitte run() davon aufrufen, nicht start(), dann wird die run()-Methode wie eine normale Methode ausgeführt, kein separater Thread gestartet
(Achtung: allgemein ein schlechter Tipp, häufiger Fehler wenn ein Thread dann scheinbar wie ein Thread läuft aber doch nicht richtig nebenläufig)

----

die neuen Objekte solltest du im jeweiligen zugehörigen parent einfügen, bisher wirfst du alles in den einen statischen oben-Node

 DefaultMutableTreeNode root = new DefaultMutableTreeNode(drives[i]);
 oben.add(root);
 TreeAktual aktual = new TreeAktual(drives[i]);

hier musst du dafür sorgen, dass der rekursive Aufruf, das aktual-Objekt, seine Objekte in den gerade erzeugten root-Node einfügt, nicht auch in 'oben', übergib z.B. den neuen Node root als Parameter genau wie das File-Objekt drives,

übrigens wäre es besser, du würdes das File[] in TreeAktual nicht drives nennen, denn es sind ja keine Laufwerke, nicht mal unbedingt Directories/ Verzeichnisse, Dateien/ files wäre ein unverfänglicher Name,

wegen doppelt sehe ich persönlich noch nicht unbedingt einen Grund,
wenn sich das nicht nebenher findet oder von selber verschwindet, dann poste bitte bisschen mehr Code so dass man es möglichst ausprobieren kann

 

[Laren]

hier musst du dafür sorgen, dass der rekursive Aufruf, das aktual-Objekt, seine Objekte in den gerade erzeugten root-Node einfügt, nicht auch in 'oben', übergib z.B. den neuen Node root als Parameter genau wie das File-Objekt drives,

ok, aber wenn jetzt mein übergebenes Parameter wieder mehrer Unterordner hat? Mit deiner Methode komme ich dann doch auch nur bis Unterordner 3 oder(bei meiner nur bis Unterordner 2 )?

 

[SlaterB]

eine Rekursion ist in ihren Ebenen nahezu unbegrenzt, nur die JVM kann in einer Tiefe von ein paar Tausend dann StackOverflowError werfen,
jeder Aufruf bekommt als Parameter das aktuelle Verzeichnis und eben den Node dazu, was praktisch dasselbe ist,
dies ist nicht von der Tiefe oder Position oder sonst etwas abhängig

edit: die von mir zitierte Code-Stelle existiert in deinem Code zweimal, wobei sie sich auch leicht unterscheiden (root vs unten),
ich meine eben die andere, die in der richtigen Rekursion

 

[Laren]

Das Problem ist eigentlich, dass ich ja immer wieder einen neuen "DefaultMutableTreeNode" erstellen muss, ich aber nicht weis wieviel Unterordner vorhanden sind.
Ich hoffe ich kann mein Problem erläutern

Es funktioniert, wie ich es hier gemacht habe, aber das Problem ist wieder, dass ich nur bis zum 2 ten Unterordner gelange.(diesmal ohne Thread)

   public static void SetAnfang() {
        //Root setzen

        oben = new DefaultMutableTreeNode("Verzeichnisse");
        tree.setModel(new DefaultTreeModel(oben));
        SetRoot(datei);
    }

    public static void SetRoot(File datei) {
        File[] laufwerke = datei.listRoots();
        for (int i = 0; i < laufwerke.length; i++) {
            roots = new DefaultMutableTreeNode(laufwerke[i]);
            oben.add(roots);
            TreeAktualMethode(laufwerke[i]);
        }

    }

    public static void TreeAktualMethode(File datei) {
        File[] dateien = datei.listFiles();
        if (dateien != null) {
            for (int i = 0; i < dateien.length; i++) {
                if (dateien[i].isDirectory()) {
                    DefaultMutableTreeNode dateiRoots = new DefaultMutableTreeNode(dateien[i]);
                    roots.add(dateiRoots);
                }
            }
        }
}

 

[SlaterB]

schreibe Methoden bitte klein, das ist ja langsam unlesbar,

diesmal hast du den rekursiven Aufruf weggelassen, ohne den gehts aber nicht, das ist die Grundlage,
im neuesten Code muss nach Zeile 25 ein rekursiver Aufruf, Punkt, Ende, keine Diskussion

ansonsten sieht es wie zuvor aus: du fügst die Nodes in ein statisches Attribut oder in ein Klassenattribut,
das mag mit einem Root-Element funktionieren und jetzt mit einer Liste der obersten drives immer noch,
aber wie zuvor gesagt: wenn du einen kompletten schicken Baum beliebiger Ebenen haben willst, musst du den Parent-Node als Parameter an die rekursive Methode übergeben (und dort dann natürlich auch neue Nodes einfügen)

das ist der Schlüssel zum Sieg, auch wenn du es so abstrakt noch nicht siehst probiere einfach irgendetwas in der Richtung aus,
muss ja noch nicht gleich funktionieren, wenn du dann was postest mit begründeten Problemen, kann ich wieder korrigieren bzw. allgemeine Hinweise geben

 

[Laren]

sorry, ich komme einfach nicht drauf, es ist so gut wie fertig, aber ich komme immer noch nur in 2 Unterordner. Ich weis nicht was ich übergeben soll. Hier meine Idee(ich habe einen Zaehler eingebaut, sonnst würde ja ein test ewig bauen)

   public static void setAnfang() {
        //Root setzen

        oben = new DefaultMutableTreeNode("Verzeichnisse");
        tree.setModel(new DefaultTreeModel(oben));
        setRoot(datei);
    }

    /**
     * rekursive Anwendung
     * @param datei
     *
     */
    public static void setRoot(File uebergabe) {
        File[] laufwerke = uebergabe.listRoots();
        for (int i = 0; i < laufwerke.length; i++) {
            roots = new DefaultMutableTreeNode(laufwerke[i]);
            oben.add(DateiUebersichtView.roots);
            treeAktualMethode(laufwerke[i], roots);


        }
    }

    public static void treeAktualMethode(File uebergabe, DefaultMutableTreeNode wurzel) {

        zaehler++;
        System.out.print(zaehler);
        File[] dateien = uebergabe.listFiles();
        if (dateien != null) {
            for (int i = 0; i < dateien.length; i++) {
                if (dateien[i].isDirectory()) {

                    wurzel.add(new DefaultMutableTreeNode(dateien[i]));
                    if(zaehler <50)
                        treeAktualMethode(dateien[i], new DefaultMutableTreeNode(dateien[i]));
                  
                }

            }
        }
    }

 

[SlaterB]

der rekursive Aufruf hat jetzt einen richtigen Parameter wie von mir gedacht, du fügst auch in dieses wurzel ein, gut,
nur leider erzeugst du nun in Zeile 34 und 36 zwei Nodes zum aktuellen Eintrag, das kann doch unter keiner Vorstellung einen Sinn ergeben?

statt

                    wurzel.add(new DefaultMutableTreeNode(dateien[i]));
                    if(zaehler <50)
                        treeAktualMethode(dateien[i], new DefaultMutableTreeNode(dateien[i]));

selbstverständlich eher

   Node n = new DefaultMutableTreeNode(dateien[i]);
                    wurzel.add(n);
                    if(zaehler <50)
                        treeAktualMethode(dateien[i], n);

bzw. ähnlich

so wie du es in Zeile 17 bis 19 doch auch in etwa hast