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

B

Booyeoo

Mitglied
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:

Java:
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.
 
B

Booyeoo

Mitglied
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...


Java:
    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?
 
S

SlaterB

Gast
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
 
Zuletzt bearbeitet von einem Moderator:
B

Booyeoo

Mitglied
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
 
Zuletzt bearbeitet:
S

SlaterB

Gast
> 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
 
Zuletzt bearbeitet von einem Moderator:
B

Booyeoo

Mitglied
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.

Java:
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);
    }
 
Zuletzt bearbeitet:
Ähnliche Java Themen
  Titel Forum Antworten Datum
J ActionListener von JCheckBox im Knoten von JTree funktioniert nicht Java Basics - Anfänger-Themen 2
F Jtree kürzt Namen auf ... Java Basics - Anfänger-Themen 4
H Collections JTree remove zeigt keinen Effekt! Java Basics - Anfänger-Themen 8
H Best Practice Wo wird der rootNode eines JTree gespeichert... Java Basics - Anfänger-Themen 0
H Erste Schritte JTree: Instanzen einer Klasse speichern oder Namen/Strings... Java Basics - Anfänger-Themen 4
R JTree bewegen Java Basics - Anfänger-Themen 6
I JTree, Root-Name ändern Java Basics - Anfänger-Themen 4
N Dynamisch JTree erstellen Java Basics - Anfänger-Themen 3
D bestimmte dateiendungen in jtree rausfiltern Java Basics - Anfänger-Themen 7
P JTree aus txt Java Basics - Anfänger-Themen 8
M Warum wird mein Icon bei den JTree Nodes nicht angezeigt? Java Basics - Anfänger-Themen 7
JStickman JTree, JScrollPane, Liste mit graphischer Suchleiste - Dateimanager Java Basics - Anfänger-Themen 10
M JTree + JTab Java Basics - Anfänger-Themen 3
T JTree füllen Java Basics - Anfänger-Themen 3
B JTree knoten wird nicht übernommen Java Basics - Anfänger-Themen 4
S JTree Hilfe Java Basics - Anfänger-Themen 6
P Jtree MouseListener und NoCollapse Java Basics - Anfänger-Themen 2
M JTree ohne root anzeigen Java Basics - Anfänger-Themen 5
F JTree mit JSpinner Java Basics - Anfänger-Themen 2
I Liste von Dateien anzeigen/JTree Java Basics - Anfänger-Themen 4
G Zugriff auf JTree-Objekt Java Basics - Anfänger-Themen 2
K Problem: JTree mit integrierten JCheckboxen Java Basics - Anfänger-Themen 5
D JTree ich dreh durch :D Java Basics - Anfänger-Themen 2
T JTree root setzten Java Basics - Anfänger-Themen 13
G xml Datei in JTree Java Basics - Anfänger-Themen 2
S JTree, Problem mit View Update Java Basics - Anfänger-Themen 2
R Problem mit JTree und JTable Java Basics - Anfänger-Themen 16
A JTree drucken Java Basics - Anfänger-Themen 2
M JTree und ein Button mit ActionListener Java Basics - Anfänger-Themen 3
G Verständnisproblem --> JTree Java Basics - Anfänger-Themen 6
G Filesystem in JTree anzeigen Java Basics - Anfänger-Themen 4
A Jtree Aufbau Java Basics - Anfänger-Themen 5
G JTree ilstener Java Basics - Anfänger-Themen 3
G JTree Java Basics - Anfänger-Themen 2
G Erstellten JTree aus einer XML-Datei akktualisieren Java Basics - Anfänger-Themen 11
S jTree initialisierung Java Basics - Anfänger-Themen 4
F Doppelklick-Event auf JTree Java Basics - Anfänger-Themen 5
J ArrayListen mit Name und Vater an JTree übergeben Java Basics - Anfänger-Themen 3
G aussehen vom jtree wiederherstellen Java Basics - Anfänger-Themen 3
P JTree mit mehreren Wurzeln Java Basics - Anfänger-Themen 2
G Umbenennen im JTree Java Basics - Anfänger-Themen 5
G rechter Mausklick im JTree Java Basics - Anfänger-Themen 2
G Bilder im jTree Java Basics - Anfänger-Themen 3
G jTree Pfad merken Java Basics - Anfänger-Themen 2
S JTree aktualisieren Java Basics - Anfänger-Themen 4
M JTree aktualisieren Java Basics - Anfänger-Themen 3
E JTree - Element suchen Java Basics - Anfänger-Themen 5
G JTree Problem. Java Basics - Anfänger-Themen 5
G JTree Java Basics - Anfänger-Themen 2
E JTree - Verzeichnisbaum Java Basics - Anfänger-Themen 3
G JTree Frage Java Basics - Anfänger-Themen 5
G Ebene von JTree ermitteln? Java Basics - Anfänger-Themen 6
G Icons für JTree skalieren? Java Basics - Anfänger-Themen 3
G Standard JTree ausblenden? Java Basics - Anfänger-Themen 5
B JTree mit Verzeichnissen füllen Java Basics - Anfänger-Themen 17
G Object vor reload von JTree merken und danach wieder setzen? Java Basics - Anfänger-Themen 5
P Wert aus JTree in ComboBox setzen? Java Basics - Anfänger-Themen 2
G Problem mit Refresh von JTree Java Basics - Anfänger-Themen 11
lomtas Scrollbalken für JTree Java Basics - Anfänger-Themen 3
lomtas JTree Struktur im Nachhinein ändern Java Basics - Anfänger-Themen 2
K JTree verlinken Java Basics - Anfänger-Themen 3
T ArrayList mit Dateien in die richtigen Ordner eines JTree Java Basics - Anfänger-Themen 16
K JTree aus DB rekursiv füllen Java Basics - Anfänger-Themen 12
M Dateisystem in Jtree - Ordnericon darstellen Java Basics - Anfänger-Themen 4
G JTree vollständigen pfad anzeigen Java Basics - Anfänger-Themen 11
R JTree aus einer ArrayList Java Basics - Anfänger-Themen 9
J JTree Bilder Java Basics - Anfänger-Themen 2
G JTree.TreeListener Java Basics - Anfänger-Themen 12
S JTree valueChanged() Ausgabe leider immer mit Pfadangabe! Java Basics - Anfänger-Themen 4
S JTree aktualisieren bzw. komplett neu aufbauen Java Basics - Anfänger-Themen 6
G Scrollen im JTree Java Basics - Anfänger-Themen 17
G Hintergrundsfarbe für JTree Java Basics - Anfänger-Themen 15
F JTree-Knoten (DefaultMutableTreeNode) formatieren ? Java Basics - Anfänger-Themen 3
Y JTree: ein Knoten als Objekt Java Basics - Anfänger-Themen 2
J JTable / JTree: Unsichtbare Elemente Java Basics - Anfänger-Themen 4
G JTree Explorer Problem mit listRoots() Java Basics - Anfänger-Themen 9
V Jtree: Alle Verzeichnisse und Ordner anzeigen, aber wie? Java Basics - Anfänger-Themen 2
P Ein Objekt nach einem String durchsuchen? Java Basics - Anfänger-Themen 7
AlexVo String zu Java Anweisung getString("*** java code ***") Java Basics - Anfänger-Themen 19
O String mit Character vergleichen Java Basics - Anfänger-Themen 3
I String.split regex Frage Java Basics - Anfänger-Themen 2
H Methode über String Wert aufrufen Java Basics - Anfänger-Themen 8
F Java Programm, das kleine Buchstaben in einem String zählen soll und bei großen Buchstaben oder Sonderzeichen abbrechen soll. Java Basics - Anfänger-Themen 5
tobikoch String x= null Bedeutung Java Basics - Anfänger-Themen 9
GAZ String replace() Elemente tauschen Java Basics - Anfänger-Themen 13
R String in char-Array übertragen Java Basics - Anfänger-Themen 5
T Zeichen im String verschiebe Java Basics - Anfänger-Themen 9
J Verschieben von Buchstaben in einem String um vorgegebene Anzahl von Zeichen innerhalb eines weiteren String Java Basics - Anfänger-Themen 12
P Datentypen Array und String Java Basics - Anfänger-Themen 2
javapingu Hex String zu long Java Basics - Anfänger-Themen 2
D Attribut Telefonnummer - eigene Klasse oder String Java Basics - Anfänger-Themen 13
Vamecruft Compiler-Fehler public static void zu static String ändern Java Basics - Anfänger-Themen 2
O if Abfrage erkennt String nicht Java Basics - Anfänger-Themen 1
A eine neue normale String-Array von einer String-Array, die in for schleife ist, schaffen Java Basics - Anfänger-Themen 3
A keine Ergebnisse - String nummer in array nummer converting Java Basics - Anfänger-Themen 1
O Datentypen String teilen Java Basics - Anfänger-Themen 5
macle Rekursive String Methode, Gerade Zahlen rausfiltern Java Basics - Anfänger-Themen 10
B String to int Java Basics - Anfänger-Themen 11
D String value change listener Java Basics - Anfänger-Themen 2
I Wo am besten eine String Konstante initialisieren? Java Basics - Anfänger-Themen 5

Ähnliche Java Themen

Anzeige

Neue Themen


Oben