Tree aus XML Daten aufbauen

[Paladin]

Hi,

ich bekomme von einem fremden Programm die Daten aus einer XML Datei als ArrayList<ArrayList<String>> Objekt geliefert. Die Daten aus den ArrayLists würde ich gerne in einem JTree grafisch darstellen. In den ArrayLists sind die XML Daten wie in der Grafik dargestellt abgelegt.

Eigentlich müsste es doch möglich sein, diese ArrayLists mit einer Schleife auszulesen und daraus automatisch DefaultMutableTreeNodes zu erstellen(und entsprechend zu verknüpfen). Allerdings bekomme ich das nicht hin.

Habt ihr vielleicht einen Tipp für mich wie ich das hinbekomme?

Danke

Paladin

 

[Wildcard]

Hat recht wenig mit XML zu tun, daher verschieb ich das mal.
Hast du ein konkretes Problem dabei? Schon etwas versucht das du posten kannst?

 

[Paladin]

Zu diesem konkreten Problem habe ich noch nichts was ich zeigen kann.
Problem ist, dass ich aus diesen ArrayLists (z.B. über eine Schleife) eine Baumstruktur aus DefaultMutableTreeNodes bauen will. Aber mir fehlt hier einfach ein Ansatz wie ich an dieses Problem rangehen soll.

 

[Wildcard]

Das sehe ich ja jetzt erst, was ist denn das für eine Kreuzdämliche Art und Weise einen Baum darzustellen :shock:
Sind in den Listen lauter 'null', oder wie ist das zu verstehen?

 

[Paladin]

Ja, die Art den Baum darzustellen ist nicht toll. Aber darauf habe ich keinen Einfluss. Kann ich denn aus diesen Daten über eine Schleife eine Baumstruktur erstellen?

 

[Wildcard]

Kann man schon. Grundsätzlich wird es wohl auf die Kombination Rekursion + Schleife hinauslaufen. Entweder du gehst erst in die Tiefe, oder in die Breite, entsprechend sieht dann dein Algorithmus aus. Zerleg das ganze in Teilprobleme, bis du bei einem Trivialen Problem ankommst, so baust du dann deine Rekursion auf.
Wird vermutlich kein sehr hübscher Code, aber ist machbar.

 

[Capasso]

Also ich würde erstmal in eine Baumstruktur bringen und mir dann gedanken um die Visualiseirung machen.

Also erstmal ne klasse für jeden Knoten.
Dann den baum daraus aufbauen und anschließend dann visualisieren.

Evtl. helfen die folgende Klassen weiter

[highlight=Java]
public class MyTreeNode implements Visualizable {

private ArrayList<MyTreeNode> children;

private String identifier;

private boolean root;

public MyTreeNode (String ident, boolean _root){
children = new ArrayList<CharTreeNode>();
identifier = ident;
root = _root;
}

public String getIdentifier () {
return identifier;
}

public void setIdentifier (String ident) {
identifier = ident;
}

public MyTreeNode getChildrenWithIdentifier(String ident) {
for(MyTreeNode ctn : children) {
if (ctn.getIdentifier().equals(ident)) {
return ctn;
}
}
return null;
}


public MyTreeNode addAndGetChildrenWithIdentifier(String ident) {
CharTreeNode ctn = this.getChildrenWithIdentifier(ident);
if (ctn == null) {
ctn = new MyTreeNode(ident, false);
children.add(ctn);
}
return ctn;
}

// Methods from Visualizable Interface
//--------------------------------------------------------------------------------
@Override
public String getIdentifierAsVisualString() {
if (root) {
return "";
}
return String.valueOf(identifier);
}
@Override
public ArrayList<? extends Visualizable> getVisualizableChildren() {
return children;
}
}
[/highlight]

[highlight=Java]
public interface Visualizable extends TreeNodeInt {
/**
* Liefert den Textstring zum Knoten
*/
public String getIdentifierAsVisualString();

/**
* Liefert alle Kinder des Knoten die ebenfalls das Interface Visualizable implementieren
*/
public ArrayList<? extends Visualizable> getVisualizableChildren();

}
[/highlight]

[highlight=Java]
public class TreeVisualizer {

public static DefaultMutableTreeNode getVisualTreeNode(Visualizable node) {
String fullword = "";
if (node.isEnd()) {
fullword = " ("node.getIdentifierAsVisualString()+")";
}
DefaultMutableTreeNode curNode = new DefaultMutableTreeNode(node.getIdentifierAsVisualString());
for (Visualizable v:node.getVisualizableChildren()) {
curNode.add(TreeVisualizer.getVisualTreeNode(v);
}
return curNode;
}


}

[/highlight]

 

[Paladin]

Hi Capasso,

danke für die Hilfestellung. Ich versuche mal damit das Problem zu lösen.

Gruß

Paladin

 

[slawaweis]

Habt ihr vielleicht einen Tipp für mich wie ich das hinbekomme?

ich habe es jetzt zwar nicht direkt getestet, aber der Algorithmus sollte ungefähr so ablaufen:

[highlight="java"]
public processXMLTable()
{
DefaultMutableTreeNode root = new DefaultMutableTreeNode();
processNode(root, 0, 0);
}

public int processNode(DefaultMutableTreeNode parent, int x, int y)
{
// prüft, ob in der Zelle X und Y Daten vorhanden sind
if(hasData(x, y))
{
// falls ja, wird ein neuer Knoten mit den Daten aus X und Y an den Parent angehängt
DefaultMutableTreeNode node = new DefaultMutableTreeNode(getData(x, y));
parent.addNode(n);

// da es nur einen Knoten pro Zeile geben kann ...
int next_row = y+1;

// ... testen wir, ob in der nächsten Zeile ein Kindknoten vorkommt, also (x+1, y+1)
// und arbeiten den rekursiv ab, mit den node als Elternknoten.
next_row = processNode(node, x+1, next_row);

// ... testen wir, ob in der nächsten Zeile ein Nachfolger des node auf der selben Ebene ist,
// also (x, y+[Anzahl möglicher Kinder von node]+1) und arbeiten den rekursiv ab, mit dem
// parent als Elternknoten.
next_row = processNode(parent, x, next_row);

return next_row;
}

return y;
}

protected boolean hasData(int x, int y)
{
// prüft, ob X und Y überhaupt im Rahmen der List-Tabelle liegen
// und ob Daten an der Position vorhanden sind
}

protected Object getData(int x, int y)
{
// holt die Daten aus der List-Tabelle an der Position X und Y
}
[/highlight]

EDIT: mit einem Stack wäre auch eine reine Schleifenlösung möglich.

Slawa

 

[Saxony]

Hiho,

in meinem Kapitel zu Legay Code unter Java sieht man zufällig wie man durch einen kompletten XML Baum läuft. Du musst nur noch die System.out.println durch entsprechende TreeNode Erzeugung ersetzen und fertig.

Java Blog Buch : 07.06 Legacy Code

bye Saxony