Einen einfachen JTree anhand eines Arrays aufbauen

[Fabian85]

Hallo,
ich hänge gerade den ganzen Tag an einer Aufgabe und komme einfach weiter und nun bin ich auf dieses Forum gestoßen. Es geht um folgendes: Gegeben ist ein Array mit den folgenden Beispiel Einträgen:

static final String [] folderPathNames = {
"Dateien/Musik/Rock/Abba",
"Dateien/Musik/Rock/Zappa",
"Dateien/Musik/Jazz",
"Dateien/Bilder/Februar 2008",
"Dateien/Bilder/März 2008",
"Dateien/Bilder/April 2008",
"Dateien/Bilder/April 2008/bis 15.04.",
"Dateien/Bilder/April 2008/ab 15.04."
};

Anhand dieses Arrays, in welchem einzelne Ordnerpfade gespeichert sind, soll nun ein JTree aufgebaut werden.
Dazu ist in der Methode buildTree() das Array entsprechend auszuwerten und mit Hilfe von DefaultMutableTreeNodes in einen JTree einzufügen. Sämtliche Ansätze hatten einfach nicht hingehaut. Irgendwo ist dann immer ein Haken :-(
Ich bin zwar noch ziemlicher Anfänger, aber es ärgert mich doch sehr, dass ich diese Aufgabe nun einfach nicht lösen kann.
Meine Idee war eigentlich, dass ich zunächst einen Wurzelknoten erzeuge,dann alles einfach an diese Wurzel hänge und diese schließlich dem Tree übergebe. Das Problem ist aber, dass ich einfach nicht herausfinden kann, welche Knoten nun an welchen gehängt werden soll. Kann mir bitte jemand auf die Sprünge helfen ? Vielen Dank im voraus!
Im Anhang ist mein aktueller, verzweifelter Stand ... Im Kopf des Programms ist die Musterausgabe des Baumes.

Gruß
Fabian

import javax.swing.*;
import javax.swing.tree.DefaultMutableTreeNode;

/**
 * 
 * Beispielausgabe:
 * 
 * Dateien
 * 		Musik
 * 			Rock
 * 				Abba
 *              Zappa
 *          Jazz
 *      Bilder
 *           Februar 2008
 *           März 2008
 *           April 2008   
 *               bis 15.04.
 *               ab 15.04  
 *    
 **/

public class BuildingAJTree extends JFrame {
	
   static final String [] folderPathNames = {
            "Dateien/Musik/Rock/Abba",
            "Dateien/Musik/Rock/Zappa",
            "Dateien/Musik/Jazz",
            "Dateien/Bilder/Februar 2008",
            "Dateien/Bilder/März 2008",
            "Dateien/Bilder/April 2008",
            "Dateien/Bilder/April 2008/bis 15.04.",
            "Dateien/Bilder/April 2008/ab 15.04."	             
   };

  public static void main( String[] argv ) {
    new BuildingAJTree("Simple Tree");
  }

  public BuildingAJTree(String title) {
    super( title );    
    buildTree();
    pack();
    setLocationRelativeTo(null);
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    setVisible( true );
  }

  private void buildTree() {

	//TODO build up the Tree
	  DefaultMutableTreeNode root = new DefaultMutableTreeNode("Dateien");
	  root.setParent(null);
	  
	  for (int i = 0;i<folderPathNames.length;i++) {
		  DefaultMutableTreeNode groupNode = new DefaultMutableTreeNode(folderPathNames[i]);
		  //alle einträge zwischen '/' teilen
		  String [] folders = folderPathNames[i].split("/");
		  for (String string : folders) {
			  DefaultMutableTreeNode child = new DefaultMutableTreeNode(string);			  
			  groupNode.add(child);
		}
		  root.add(groupNode);	  
		
	  }	  
	  
    JScrollPane js = new JScrollPane( new JTree(root));
    add(js);
  }
}

 

[hdi]

Viel zu bitter :autsch: Ich saß grad über eine Stunde daran und hab auch nix gescheites
hinbekommen. Irgendwie hängt er mir die Dinge immer sonst wo rein, diese setParent() Methode
funktioniert irgendwie nicht richtig, und wenn man sich den Breitendurchlauf geben will, returned
er immer "null", obwohl Elemente drin sind... Voll der sch*** :?

 

[Marco13]

Nur schnell hingehackt.... das "split" wird sau-oft gemacht, und könnte bei großen Hierarchien zum Bottleneck werden, aber ... hey, um die Uhrzeit... :roll:

// Recursive Function for [url]http://www.java-forum.org/de/viewtopic.php?t=82143&highlight=&sid=f94f4bae1ce91bb152edc32d5fb2b1d2[/url]

import javax.swing.*;
import javax.swing.tree.DefaultMutableTreeNode;
import java.util.*;

/**
*
* Beispielausgabe:
*
* Dateien
*       Musik
*          Rock
*             Abba
*              Zappa
*          Jazz
*      Bilder
*           Februar 2008
*           März 2008
*           April 2008
*               bis 15.04.
*               ab 15.04
*
**/

public class BuildingAJTree extends JFrame {

   static final String [] folderPathNames = {
            "Dateien/Musik/Rock/Abba",
            "Dateien/Musik/Rock/Zappa",
            "Dateien/Musik/Jazz",
            "Dateien/Bilder/Februar 2008",
            "Dateien/Bilder/März 2008",
            "Dateien/Bilder/April 2008",
            "Dateien/Bilder/April 2008/bis 15.04.",
            "Dateien/Bilder/April 2008/ab 15.04."
   };

  public static void main( String[] argv ) {
    new BuildingAJTree("Simple Tree");
  }

  public BuildingAJTree(String title) {
    super( title );
    buildTree();
    pack();
    setLocationRelativeTo(null);
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    setVisible( true );
  }

  private void buildTree() {

   //TODO build up the Tree
     DefaultMutableTreeNode root = new DefaultMutableTreeNode("Dateien");
     root.setParent(null);

     HashMap<String, DefaultMutableTreeNode> map = new HashMap<String, DefaultMutableTreeNode>();
     map.put("Dateien", root);

     doIt(1, map);
     JScrollPane js = new JScrollPane( new JTree(root));
     add(js);
  }


    private void doIt(int level, Map<String, DefaultMutableTreeNode> map)
    {
        boolean finished = true;
        for (int i = 0;i<folderPathNames.length;i++)
        {
            String folders[] = folderPathNames[i].split("/");
            if (folders.length > level)
            {
                DefaultMutableTreeNode child = map.get(folders[level]);
                if (child == null)
                {
                    child = new DefaultMutableTreeNode(folders[level]);
                    map.put(folders[level], child);
                    DefaultMutableTreeNode parent = map.get(folders[level-1]);
                    parent.add(child);
                    finished = false;
                }
            }
        }
        if (!finished)
        {
            doIt(level+1, map);
        }
    }


}

 

[Fabian85]

Halleluja,

immerhin ein kleiner Trost, dass es doch nicht so leicht ist. Dennoch, ich fand das einfach viel zu schwer für einen Anfänger. :-( Jetzt muss ich erstmal die Lösung nachvollziehen, ich bin beeindruckt. Besten Dank, find ich klasse, dass ihr euch die Mühe gemacht habt
:toll:

Gruß
Fabian

 

[Gast]

Habs gestern Abend auch 20 min. versucht, ohne Erfolg. Ohne Rekursion oder Umstrukturieren des Arrays wirds schwierig. Und ich bin kein Anfänger

 

[Ebenius]

Der Ansatz von Marco klappt leider nicht, wenn man solche Eingaben hat:

• Dateien/Bilder/Gabi/Omas Geburtstag
• Dateien/Musik/Gabi/Lieblingslieder

Ich würde sowas machen:

private static DefaultMutableTreeNode buildTreeNodes(
      String[] flat,
      String delimn) {
  final DefaultMutableTreeNode root = new DefaultMutableTreeNode("root");
  for (int i = 0; i < flat.length; i++) {
    final String row = flat[i];
    final StringTokenizer tokenizer = new StringTokenizer(row, delimn);
    DefaultMutableTreeNode node = root;
    tokenizer: while (tokenizer.hasMoreTokens()) {
      final String s = tokenizer.nextToken();
      final Enumeration<?> children = node.children();
      while (children.hasMoreElements()) {
        final DefaultMutableTreeNode child =
              (DefaultMutableTreeNode) children.nextElement();
        if (s.equals(child.getUserObject())) {
          // node already exists
          node = child;
          continue tokenizer;
        }
      }

      final DefaultMutableTreeNode child = new DefaultMutableTreeNode(s);
      node.add(child);
      node = child;
    }
  }

  return (DefaultMutableTreeNode) (root.getChildCount() == 1 ? root
        .getChildAt(0) : root);
}

Aufrufen mit

buildTreeNodes(myArray, "/");

Ebenius

 

[Marco13]

Der Ansatz von Marco klappt leider nicht, wenn man solche Eingaben hat:

Häch... hab' mir schon so oft vorgenommen, nach 24:00 keine Antworten mehr zu schreiben, bei denen man nachdenken muss

Ein Alternativversuch, bei dem man ggf. auch nachträglich noch Knoten in den Baum einfügen kann (schon wieder so eine Art Bijektion ???:L ) : Es gibt die "insert"-Methode, die sich ganz pragmatisch den Baum entlanghangelt, und mit der man irgendeine Ordnerstruktur in den Baum einfügen kann - ähnlich wie wenn etwas in einen RS-Baum oder eine TreeMap eingefügt wird...

    private static void doItReally(DefaultMutableTreeNode root)
    {
        for (int i = 0;i<folderPathNames.length;i++)
        {
            String folders[] = folderPathNames[i].split("/");
            insert(root, folders, 1);
        }
    }

    private static void insert(DefaultMutableTreeNode node, String folders[], int index)
    {
        if (index < folders.length)
        {
            DefaultMutableTreeNode child = null;
            for (int i=0; i<node.getChildCount(); i++)
            {
                DefaultMutableTreeNode c = (DefaultMutableTreeNode) node.getChildAt(i);
                if (c.getUserObject().equals(folders[index]))
                {
                    child = c;
                    break;
                }
            }
            if (child == null)
            {
                child = new DefaultMutableTreeNode(folders[index]);
                node.add(child);
            }
            insert(child, folders, index+1);
        }
    }

Ist jetzt aber wahrscheinlich ziemlich "äquivalent" zur Lösung von Ebenius...

 

[Ebenius]

Ohne es geprüft zu haben, nehme ich an, dass mein Ansatz schneller ist, weil nicht rekursiv und weil ich keine regulären Ausdrücke verwende. Bin ja gespannt, wer das ausprobiert. :-D

 

[Marco13]

Da verweise ich mal auf mehrere Dinge:
1. Rekursion ist (speziell bei dieser geringen Tiefe) kein wirklicher Hemmschuh für Performance
2. Man kann bei mir dediziert mit einer Methode neue LMNT einfügen (ja, überflüssig, vielleicht aber doch hübsch )
3. In der Zeit, die man braucht, um diese Ordnerstruktur einzulesen, könnte man wahrscheinlich zig-Tausend solcher JTrees erstellen....
4. Deine Signatur :wink:

 

[Ebenius]

Alles richtig. Ging nur um die Theorie. Meine Signatur hat recht. :-D

BTW: Noch viel schneller geht's übrigens, wenn man vorher einfach das Array sortiert. dann fällt die ganze innere Schleife weg und man prüft nur noch gegen den Vorgänger.

Wenn ich das für mich implementieren würde, würde ich ohnehin TreeModel selber implementieren. Allerdings empfehle ich das keinem, weil ich weiß, wie lange ich für mein erstes gebraucht habe. TableModels sind dagegen trivial.

Ebenius