# Baumstruktur erzeugen



## dralban7 (23. Jul 2008)

Hi,

hallo an Alle. Als Neuer in der Java-Welt habe ich eine Frage bzgl. Baumstrukturen.

Ich habe einiges im Google über JTree gelesen, aber ich brauche kein UI, sondern will die Baumstruktur
zur Laufzeit in einem Objekt halten. Desweiteren habe ich über binäre Bäume gelesen, aber das scheint
mir nicht ganz zu helfen. Treeset und TreeMap scheinen auch nicht das Richtige sein...

Hoffe habe da nichts übersehen, aber vielleicht könnt ihr mir sagen, was ich für eine Klasse am besten
für mein unten stehende Aufgabe nehmen soll?

Gibt es in Java nicht eine Klasse, wo ich eine Baumstruktur erzeugen kann, um dann später diese abzufragen,
d.h. z.B. eine Abfrage, wie z.B. "gebe mir das Kind vom Knoten A".

So soll mein Baum aussehen:
Root (hat 2 Kinder, nämlich A und B)
- A
--A1
---A11
--A2
--A3
-B
--B1
--B2
--B3
---B31 
---B32

usw...
D.h.  B hat 3 Kinder, nämlich B1, B2 und B3. 
B3 hat hingegen 2 Kinder, nämlich B31 und B32.
B32 könnte z.B.  dann 7 Kinder haben usw...

Vielen Dank für eure Hilfe.

G
Karl


----------



## didjitalist (23. Jul 2008)

Baumstrukturen werden in vielen Javaklassen verwendet, aber eine allgemeine Klasse gibt es dafür nicht. Deshalb ist es eigentlich niemals eine schlechte Idee, sich einmal hinzusetzen, und sich so eine allgemeine Struktur zu schreiben.


----------



## Saxony (23. Jul 2008)

Hiho,

musste wohl oder übel selber schreiben:


```
import java.util.Vector;

public class TreeNode {
	
    private Vector<TreeNode> children = new Vector<TreeNode>();
	
    private Object data;
	
    public TreeNode(Object aData) {
		
        this.data = aData;
    }
	
    public void addChildren(TreeNode... aChildren) {
		
        for (TreeNode child : aChildren)		
            this.children.add(child);
    }
	
    public Object getData() {
		
        return this.data;
    }
    
    public Vector<TreeNode> getChildren() {
		
        return this.children;
    }
}
```


```
public class Tree {
	
    private TreeNode root;
	
    public Tree(TreeNode aRoot) {
		
        this.root = aRoot;
    }
	
	
    public void printTree() {
		
        this.print(this.root);
    }
	
    private void print(TreeNode aRoot) {
		
        System.out.println(aRoot.getData().toString());
        for(int i = 0; i < aRoot.getChildren().size(); i++) {
			
            this.print(aRoot.getChildren().get(i));
        }
    }
	
    public static void main(String[] args) {
		
        TreeNode n1 = new TreeNode("Root");
        TreeNode n2 = new TreeNode("A");
        TreeNode n3 = new TreeNode("B");
        TreeNode n4 = new TreeNode("A1");
        TreeNode n5 = new TreeNode("A2");
        TreeNode n6 = new TreeNode("A3");
        TreeNode n7 = new TreeNode("B1");
        TreeNode n8 = new TreeNode("B2");
		
        n1.addChildren(n2, n3);
		
        n2.addChildren(n4, n5, n6);
		
        n3.addChildren(n7, n8);

        Tree tree = new Tree(n1);
		
        tree.printTree();
    }
}
```

[edit]
Hab mal addChild(TreeNode) auf addChildren(TreeNode...) umgeschrieben.
[/edit]

bye Saxony


----------



## Final_Striker (23. Jul 2008)

> Ich habe einiges im Google über JTree gelesen, aber ich brauche kein UI, sondern will die Baumstruktur
> zur Laufzeit in einem Objekt halten. Desweiteren habe ich über binäre Bäume gelesen, aber das scheint
> mir nicht ganz zu helfen. Treeset und TreeMap scheinen auch nicht das Richtige sein...



kannst ja trotzdem jtree verwenden, ist doch auch nur ein objekt. :wink:


----------



## Saxony (23. Jul 2008)

Final_Striker hat gesagt.:
			
		

> > Ich habe einiges im Google über JTree gelesen, aber ich brauche kein UI, sondern will die Baumstruktur
> > zur Laufzeit in einem Objekt halten. Desweiteren habe ich über binäre Bäume gelesen, aber das scheint
> > mir nicht ganz zu helfen. Treeset und TreeMap scheinen auch nicht das Richtige sein...
> 
> ...



Alleine schon die Verwendung von


```
import javax.swing.JTree;
```

in meinem model package hält mich von dieser Verwendung ab.  :shock: 

bye Saxony


----------



## AlArenal (23. Jul 2008)

Ich glaube ich frug letztens schonmal ergebnislos in einem anderen Thread: Was ist so verwerflich an der Verwendung vom TreeModel? Nichts und niemand nötigt mich dies nur im Kontext eines JTree zu verwenden (das würde ja auch dem Sinn eines Model widersprechen).


----------



## Saxony (23. Jul 2008)

Ja man kann DefaultTreeModel in Verbindung mit DefaultMutableTreeNode verwenden.


```
public static void main(String[] args) {
		
		DefaultMutableTreeNode n1 = new DefaultMutableTreeNode("Root");
		DefaultMutableTreeNode n2 = new DefaultMutableTreeNode("A");
		DefaultMutableTreeNode n3 = new DefaultMutableTreeNode("B");
		DefaultMutableTreeNode n4 = new DefaultMutableTreeNode("A1");
		DefaultMutableTreeNode n5 = new DefaultMutableTreeNode("A2");
		DefaultMutableTreeNode n6 = new DefaultMutableTreeNode("A3");
		DefaultMutableTreeNode n7 = new DefaultMutableTreeNode("B1");
		DefaultMutableTreeNode n8 = new DefaultMutableTreeNode("B2");
		
		n1.add(n2);
		n1.add(n3);
		
		n2.add(n4);
		n2.add(n5);
		n2.add(n6);
		
		n3.add(n7);
		n3.add(n8);
		
		DefaultTreeModel mdl = new DefaultTreeModel(n1);
		
		MyClass.printTree((DefaultMutableTreeNode)mdl.getRoot());
	}
	
	private static void printTree(DefaultMutableTreeNode aNode) {
		
		System.out.println(aNode.toString());
		
		Enumeration<DefaultMutableTreeNode> e = aNode.children();
		
		while(e.hasMoreElements()) {
			
			MyClass.printTree(e.nextElement());
		}
	}
```



Allerdings habe ich dann wieder javax.swing imports in meinen Model Packages und das will ich nicht! 

bye Saxony


----------



## AlArenal (23. Jul 2008)

Saxony hat gesagt.:
			
		

> Allerdings habe ich dann wieder javax.swing imports in meinen Model Packages und das will ich nicht!



Warum, hat Schäuble da nen Trojaner drin?


----------



## SlaterB (23. Jul 2008)

der Code ist nicht mehr nach J2ME portierbar


----------



## Saxony (23. Jul 2008)

Hiho,



			
				Wikipedia hat gesagt.:
			
		

> Bei Swing handelt es sich um eine Programmierschnittstelle und Grafikbibliothek zum Programmieren von grafischen Benutzeroberflächen.



In Model hat UI nix zu suchen - Basta!

bye Saxony


----------



## AlArenal (23. Jul 2008)

Saxony hat gesagt.:
			
		

> In Model hat UI nix zu suchen - Basta!



Im TreeModel ist auch kein UI drin. Es ist ein MODEL!

In einem Atlas sind auch keine kleinen Flugzeuge und Leute drin, die einem zuwinken, wenn man mit der Lupe rangeht...


----------



## Saxony (23. Jul 2008)

Hiho,

na dann nimm du *javax.swing*.tree.DefaultTreeModel und ich was selbst gebautes!

Mich stören winkende - sowie auch nicht winkende - Leute!

bye Saxony


----------



## AlArenal (23. Jul 2008)

Saxony hat gesagt.:
			
		

> Mich stören winkende - sowie auch nicht winkende - Leute!



Dann musst du wohl ins Land der Ohne-Arme-Geborenen auswandern.


----------



## Saxony (23. Jul 2008)

Na die winken ja dann nicht und stören wieder! 

bye Saxony


----------



## maki (23. Jul 2008)

Einen Tree selbst zu schreiben ist nicht schwer, man lernt dabei das eine oder andere Entwurfsmuster kennen (Kompositium, Visitor, etc) und kann spezielle Funktionen hinzufügen, zB. eine Kaskadennummer erstellen lassen für textuelle Darstellungen des Trees.

Das hier 





> ROOT
> - A
> --A1
> ---A11
> ...



könnte dann so aussehen:

```
1          ROOT
1.1        A
1.1.1      A1
1.1.1.1    A11
1.1.2      A2
1.1.3      A3
1.2        B
1.2.1      B1
1.2.2      B2
1.2.3      B3
1.2.3.1    B31
1.2.3.2    B32
```


----------



## dralban7 (23. Jul 2008)

Super, vielen Dank für diese vielen Antworten...

Also, sieht so aus, daß ich entweder selber was bauen kann oder javax.swing.JTree nehme.
Ich stimme da zu, daß im Model UI nichts zu suchen hat, aber darüber kann man vielleicht hier endlos streiten.
Die Objekte in javax.swing.JTree könnte man natürlich nutzen, aber bevor wir das vertiefen...

...finde ich diesen Punkt nicht ganz unwichtig:
SlaterB schrieb: "Der Code ist nicht mehr nach J2ME portierbar"

Bei so genannten »embedded consumer products« wie etwa Mobiltelefone oder PDAs würde man
dann schlecht aus sehen.

Aber, wie gesagt...
Verstanden habe ich, daß ich bei Bedarf sogar javax.swing.JTree nutzen könnten oder mir etwas selber baue.

Bis hierhin vielen Dank für die vielen Infos.

G
Karl


----------



## Saxony (23. Jul 2008)

Hiho,

JTree ist die visuelle Komponente! Es ging hier eigentlich eher um das TreeModel. 

bye Saxony


----------



## dralban7 (23. Jul 2008)

Yes, danke...

Meinte natürlich javax.swing generell, d.h. damit auch TreeModel
javax.swing.tree.TreeModel...

G
Karl


----------



## AlArenal (24. Jul 2008)

Saxony hat gesagt.:
			
		

> Na die winken ja dann nicht und stören wieder!



Wie diskriminierend!


----------

