OOP Jtree aus TreeMap<String, String[]> erstellen?

[Booyeoo]

Hallo Zusammen,

ich habe gerade einen Knoten im Kopf und mein Herz rast vor wahnsinn.
Ist es denn so kompliziert ein JTree aus einer TreeMap zu erstellen.

Ich habe einen Körperaufbau in meiner TreeMap gespeichert und möchte den hierarchischen Aufbau nun in dem JTree realisieren.
Ich kann aber nicht für jedes Item dynamisch eine neue Variable erzeugen in java. Oder ist das nicht nötig?


Legende:

Aufbau der TreeMap stm:
root, [root,rechtesch,linkesch,hals]
hals, [hals, kopf]
rechtesch, [rechtesch, rarm]
usw... (das heißt der key steht auch immer am anfang im array)

trHierarchy: ist mein JTree.

Der Rest ergibt sich aus dem Code.


Folgendes Problem:

public void createHierarchy(TreeMap<String,String[]> stm){
        String[] tempArray = stm.get("root");
        DefaultMutableTreeNode child, parent, root = new DefaultMutableTreeNode("root");
        
        trHierarchy.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
        trHierarchy.setShowsRootHandles(true);
        
        for (int i=1;i<tempArray.length;i++){
            child=new DefaultMutableTreeNode(tempArray[i]);
            root.add(child);
        }
        DefaultTreeModel trModel = new DefaultTreeModel(root);
        //trModel.insertNodeInto(parent, child, parent.getChildCount());
        
        for (String key : stm.keySet()){
            if (!(key.equals("root"))){
                parent= new DefaultMutableTreeNode(stm.get(key)[0]);
                for (int i=1;i<tempArray.length;i++){
                    child=new DefaultMutableTreeNode(tempArray[i]);
                    parent.add(child);
                }
                
            }
        trHierarchy.setModel(trModel);
        }
        

        //trHierarchy.scrollPathToVisible(new TreePath(parent.getPath()));

Nun habe ich parent und child, aber wie gehts nun weiter?
Wie stelle ich jetzt zwischen root und parent die Verknüpfung her?

How to Use Trees (The Java™ Tutorials > Creating a GUI With JFC/Swing > Using Swing Components)
hier habe ich auch leider keine richtige Hilfe gefunden, oder geht das irgendwie über lazy loading?

Ich hoffe das Problem wird deutlich...ansonsten um Rückmeldung bitte.
Danke für jede Antwort.

 

[SlaterB]

noch aktuell?

 

[Booyeoo]

leider ja. das ist das was ich bisher hab:

so funktioniert es halt, aber die knoten werden einfach alle dem root knoten hinzugefügt ohne hierarchie.. das ist natürlich nur temporär schön...

    public void createHierarchy(TreeMap<String, String[]> stm) {
        String[] tempArray = stm.get("root");
        DefaultMutableTreeNode child, parent, root = new DefaultMutableTreeNode("root");
        Set<DefaultMutableTreeNode> hs = new HashSet<DefaultMutableTreeNode>();

        trHierarchy.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
        trHierarchy.setShowsRootHandles(true);

//        for (int i=1;i<tempArray.length;i++){
//            child=new DefaultMutableTreeNode(tempArray[i]);
//            root.add(child);
//        }
//
        //trModel.insertNodeInto(parent, child, parent.getChildCount());

        for (String key : stm.keySet()) {
            if (!(key.equals("root"))) {
                parent = new DefaultMutableTreeNode(stm.get(key)[0]);
                tempArray = stm.get(key);
                for (int i = 1; i < tempArray.length; i++) {
                    child = new DefaultMutableTreeNode(tempArray[i]);
                    parent.add(child);
                }
                hs.add(parent);
                root.add(parent);
                //System.out.println(parent.getFirstChild().toString());
            }
        }
//        boolean change = true;
//        String nodeName = "";
//        int indexroot, indexchild, indexsearch;
//        DefaultMutableTreeNode actualChild = new DefaultMutableTreeNode(), actualParent = new DefaultMutableTreeNode(),
//                actualSearch = new DefaultMutableTreeNode();
//
//        while (change) {
//            change = false;
//            for (indexroot = 0; indexroot < root.getChildCount(); indexroot++) {
//                actualParent = (DefaultMutableTreeNode) root.getChildAt(indexroot);
//                if (actualParent.getChildCount() > 0) {
//                    for (indexchild = 0; indexroot < actualParent.getChildCount(); indexchild++) {
//                        actualChild = (DefaultMutableTreeNode) actualParent.getChildAt(indexchild);
//                        for (indexsearch = 0; indexsearch < root.getChildCount(); indexsearch++) {
//                            actualSearch = (DefaultMutableTreeNode) root.getChildAt(indexchild);
//                            if ((actualSearch.toString().equals(actualChild.toString()))) {
//                            }
//                        }
//                    }
//                }
//
//            }
//        }



        DefaultTreeModel trModel = new DefaultTreeModel(root);
        trHierarchy.setModel(trModel);


        //trHierarchy.scrollPathToVisible(new TreePath(parent.getPath()));

    }

hast du denn eine idee slater?

 

[SlaterB]

ich nehme an, die Key-Strings in der Map sind zum Teil auch im String[] anderer Keys enthalten und so entfaltet sich die Baubstruktur?

dann brauchst du eine weitere Map String -> Node, in der du jeden Node mit seinem Namen einfügst,

für jeden Key X in stm {
Node zu Key suchen, sonst neuen Node erstellen, in Map merken
(nicht bei root als Child einfügen, Parent bisher unbekannt)

für jeden SubKey im zugehörigen Array {
wiederum Node suchen, sonst neuen Node erstellen, in Map merken,
Node als Child bei X einfügen
}

}


fertig ist die Node-Baum-Struktur, nun nur noch einen Node wählen, der root sein soll oder Child des root-Elements,
wenn einer der Keys root hat, dann den, sonst wie auch immer


edit: sehe gerade die Legende, da scheint ja ein Element im Array immer doppelt zu sein,
wenn das so sein muss und auch drin bleiben soll wirds mit den eindeutigen Keys für die Map String -> Node etwas schwer,
notfalls temporär umbenennen

 

[Booyeoo]

hi slater, danke erstmal für deine mühe.

meine erste frage wäre, welchen import soll ich für "Node" nutzen: import javax.xml.soap.Node; ?

deine annahme war völlig richtig. die keys sind auch immer das erste element im array, das kann ich aber entfernen.

aber so ähnlich hatte ich das schonmal vor in dem auskommentierten text. und als ich dann zu dem punkt gekommen bin wo es dann in die 3.te ebene geht, da habe ich festgestellt, dass das so keinen sinn hatte.

also wenn ich dann so eine struktur habe A --> B B--> C,D D --> E. dann hatte ich das problem dass ich dann für D nicht den Eintrag für E bekommen hätte. also für jeden key im array da wären wir beim A --> B... danach würden wir dann subarray durchschauen dann wären wir beim B --> C und B --> D aber wann wären wir beim D --> E ?
ich müsste quasi vorher schon die tiefe der hierarchie kennen und dann entsprechend viele schleifen machen oder nicht. oder übersehe ich etwas und denke zu kompliziert?


das ist übrigens die konkrete zu parsende hierarchie:
:hierarchy
begin
root lhipjoint rhipjoint lowerback
lhipjoint lfemur
lfemur ltibia
ltibia lfoot
lfoot ltoes
rhipjoint rfemur
rfemur rtibia
rtibia rfoot
rfoot rtoes
lowerback upperback
upperback thorax
thorax lowerneck lclavicle rclavicle
lowerneck upperneck
upperneck head
lclavicle lhumerus
lhumerus lradius
lradius lwrist
lwrist lhand lthumb
lhand lfingers
rclavicle rhumerus
rhumerus rradius
rradius rwrist
rwrist rhand rthumb
rhand rfingers
end
grüße

 

[SlaterB]

> meine erste frage wäre, welchen import soll ich für "Node" nutzen: import javax.xml.soap.Node; ?

du hast doch schon Code, DefaultMutableTreeNode oder so,
ich wollte keine anderen Klassen empfehlen, es geht nur darum wer mit wem verknüpft wird

> oder übersehe ich etwas und denke zu kompliziert?

ich glaube zu kompliziert, es wird schon laufen,
wenn erst A -> B drankommt
dann sind in der Map A und B drin, B an A rangehängt,
kommt nun B -> D, so wird das vorhandene B verwendet (wenn man vorher in der Map nachschaut), D dort eingefügt und auch in die Map

erscheint andersrum zuerst B -> D so werden diese beiden verknüpft und in die Map eingefügt,
kommt danach A -> B, so wird A neu erstellt, als B aber der vorhandene Node aus der Map verwendet und in A als Child eingefügt,

wie man es dreht und wendet, am Ende wird A das Child B haben, B enthält D usw.,
die Map enthält alle Nodes, am Ende aber nicht mehr benötigt 😉

------

> beim A --> B... danach würden wir dann subarray durchschauen dann wären wir beim B --> C und B --> D aber wann wären wir beim D --> E ?

eine Informationsmenge ist nur A -> B
wenn man das Subarray mit B durchläuft erhält man nur die Info dass diese mit A verkünpft sind,
nicht gleichzeitig drüber nachdenken, was nun die Kinder von B sind, und dann deren Kinder usw.,
das würde tatsächlich immer neue Schleifen erfordern, aber so geht man nicht vor,
dass B dann auf D verweist kommt in einem anderen Schritt der Hauptschleife nämlich für den Key B mit Subarray C, D

 

[Booyeoo]

DANKE Slater, habs die einfachheit des problems mit deiner hilfe erkannt.
habe jetzt keine andere treemap genommen sondern einen weiteren baum der die evtl enstandenen teilbäume beinhaltet welche am ende zusammengefügt werden.

Hier als dankeschön für die leute die es vielleicht mal brauchen werden

Den temp teil kann man sich übrigens schenken wenn die hierarchie in der richtigen reihenfolge von der zu parsenden Datei geliefert wird.

public void createHierarchy(LinkedHashMap<String, String[]> stm) {
        String[] tempArray = stm.get("root");
        DefaultMutableTreeNode tmpNode = null, child, node, element, element2, root = new DefaultMutableTreeNode("root");


        trHierarchy.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
        trHierarchy.setShowsRootHandles(true);

        // für jeden schlüsselwert (knoten)
        for (String key : stm.keySet()) {
            //falls root hänge kinder direkt am anfang an hauptknoten dran
            if (key.equals("root")) {
                tempArray = stm.get(key);
                node = new DefaultMutableTreeNode(key);
                for (int i = 1; i < tempArray.length; i++) {
                    child = new DefaultMutableTreeNode(tempArray[i]);
                    root.add(child);
                }
                continue;
            }
            // suche mit breitensuche nach key im baum
            Enumeration rootElements = root.breadthFirstEnumeration();
            boolean found = false;
            while (rootElements.hasMoreElements()) {
                element = (DefaultMutableTreeNode) rootElements.nextElement();
                // wenn gefunden
                if (key.equals(element.toString())) {
                    //füge entsprechende kinder zu diesem knoten hinzu
                    tempArray = stm.get(key);
                    node = new DefaultMutableTreeNode(key);
                    for (int i = 1; i < tempArray.length; i++) {
                        child = new DefaultMutableTreeNode(tempArray[i]);
                        element.add(child);
                    }
                    found = true;
                    continue;
                }
            }
            // wenn nicht gefunden, füge knoten mit kindern zu temp hierarchie hinzu
            if (!(found)) {
                if (tmpNode!=null){
                Enumeration tempElements = tmpNode.breadthFirstEnumeration();
                while (tempElements.hasMoreElements()) {
                    element = (DefaultMutableTreeNode) tempElements.nextElement();
                    // wenn gefunden
                    if (key.equals(element.toString())) {
                        //füge entsprechende kinder zu diesem knoten hinzu
                        tempArray = stm.get(key);
                        node = new DefaultMutableTreeNode(key);
                        for (int i = 1; i < tempArray.length; i++) {
                            child = new DefaultMutableTreeNode(tempArray[i]);
                            element.add(child);
                        }
                        found = true;
                        continue;
                    }
                }
                // wenn es wiederrum in der tempmap keinen eintrg gibt erstelle ihn neu
                if (!(found)) {
                    tempArray = stm.get(key);
                    node = new DefaultMutableTreeNode(key);
                    for (int i = 1; i < tempArray.length; i++) {
                        child = new DefaultMutableTreeNode(tempArray[i]);
                        node.add(child);
                    }
                    tmpNode.add(node);
                }
                }
                else{
                    // falls noch nix im tempknoten drin ist
                    tempArray = stm.get(key);
                    node = new DefaultMutableTreeNode(key);
                    for (int i = 1; i < tempArray.length; i++) {
                        child = new DefaultMutableTreeNode(tempArray[i]);
                        node.add(child);                            
                    }
                    tmpNode = new DefaultMutableTreeNode(node);
                }
            }
        }
        
        // verknüpfe die knoten richtig miteinander falls die hierarchie in der asf nicht richtig eingetragen wurde
        Enumeration rootElements = root.breadthFirstEnumeration();
        if (tmpNode!=null){
        Enumeration tempElements = tmpNode.breadthFirstEnumeration();
        while (tempElements.hasMoreElements()) {
            element = (DefaultMutableTreeNode) tempElements.nextElement();
                while (rootElements.hasMoreElements()) {
                   element2 = (DefaultMutableTreeNode) rootElements.nextElement();
                   // suche für jeden temporären knoten entsprechenden knoten im rootbaum
                   // füge den teilbaum in den rootbaum ein
                   if (element.toString().equals(element2.toString())) {
                       for (int i = 0; i < element.getChildCount(); i++) {
                            child = (DefaultMutableTreeNode) element.getChildAt(i);
                            element2.add(child);
                        }
                       break;
                   }
                }
            }
        }
        
        // füge den rootknoten in das trModel ein
        DefaultTreeModel trModel = new DefaultTreeModel(root);
        trHierarchy.setModel(trModel);
    }