JTree model.nodechanged (Node) verliert Daten

Question

Ich teste einige Code mit JTree, und ich bemerkte, dass model.reload() gibt andere Ausgabe als model.nodeChanged(currentNode). Die korrekte Ausgabe wird von model.reload() erhalten. Hier sind meine zwei Ausgänge für den gleichen Code:

Mein Code ist wie folgt:

public class test { 

    private JFrame frame; 
    JTree tree; 
    DefaultMutableTreeNode root; 
    DefaultTreeModel model; 
    private Map<String, DefaultMutableTreeNode> treeMap; 

    public static void main(String[] args) { 
     test t = new test(); 
     try { 
      Thread.sleep(1000 * 5); 
     } catch (Exception e) { 

     } 
     t.add_new_folder("Data", "trial 0"); 
     t.add_new_folder("Data/trial 0", "trial 1"); 
     t.add_new_folder("Data/trial 0/trial 1", "trial 2"); 
     t.add_new_folder("Data", "trial 1"); 

     try { 
      Thread.sleep(1000 * 5); 
     } catch (Exception e) { 

     } 
     t.add_new_folder("Data/trial 1", "trial 2"); 
     t.add_new_folder("Data", "trial 2"); 
    } 

    public test() { 
     frame = new JFrame("using reload"); 
     tree = new JTree(); 
     root = new DefaultMutableTreeNode("Data"); 
     model = new DefaultTreeModel(root); 
     tree.setModel(model); 
     frame.getContentPane().add(tree, BorderLayout.WEST); 
     frame.setVisible(true); 
     frame.setSize(500, 500); 
     treeMap = new HashMap<>(); 
     treeMap.put("Data", root); 
    } 

    public void add_new_folder(String path, String name) { 
     DefaultMutableTreeNode currentNode = treeMap.get(path); 
     DefaultMutableTreeNode childNode = new DefaultMutableTreeNode(name); 
     currentNode.add(childNode); 
     treeMap.put(path + "/" + name, childNode); 
     model.reload(); 
     //model.nodeChanged(currentNode); 
    } 
} 

Ich brauche auch model.nodeChanged() zu verwenden, wie es Wege das gleiche im Gegensatz zu model.reload erweitert hält. Irgendeine Erklärung und wie man repariert?

Answer 1

Irgendeine Idee, warum dieses Problem mich mit der Tree konfrontiert?

Wie unten gezeigt, sind die Ergebnisse korrekt, wenn sie korrekt synchronized sind. Wie in der Abbildung here gezeigt, können Sie die Sichtbarkeit mithilfe von expandRow() und scrollPathToVisible() steuern. Die Verwendung von Thread.sleep() blockiert einfach den Thread, auf dem es aufgerufen wird. Da Swing single-threaded ist, sind die Ergebnisse unvorhersehbar. Verwenden Sie stattdessen java.swing.Timer oder SwingWorker nach Bedarf.

Versuchen Sie etwas Ruhe zwischen Hinzufügen von Knoten und erweitern Sie einen beliebigen Pfad und in der Continue-Code wird das Problem angezeigt, wie in meiner Frage angegeben.

Aus den Gründen mentioned sind Ergebnisse mit Thread.sleep() nicht zuverlässig. Die Verwendung von java.swing.Timer zeigt das Problem: nodeChanged() spiegelt Änderungen an dem Knoten selbst wider. Da Sie die untergeordneten Elemente des Knotens geändert haben, rufen Sie stattdessen nodeStructureChanged() auf.

import java.awt.BorderLayout; 
import java.awt.EventQueue; 
import java.awt.event.ActionEvent; 
import java.awt.event.ActionListener; 
import java.util.HashMap; 
import java.util.Map; 
import javax.swing.JFrame; 
import javax.swing.JTree; 
import javax.swing.Timer; 
import javax.swing.tree.DefaultMutableTreeNode; 
import javax.swing.tree.DefaultTreeModel; 

public class Test { 

    private final JFrame frame; 
    private final JTree tree; 
    private final DefaultMutableTreeNode root; 
    private final DefaultTreeModel model; 
    private final Map<String, DefaultMutableTreeNode> treeMap; 
    private final boolean reload; 
    private int index; 
    private final String[] folders = { 
     "Data", "trial 0", 
     "Data/trial 0", "trial 1", 
     "Data/trial 0/trial 1", "trial 2", 
     "Data", "trial 1", 
     "Data/trial 1", "trial 2", 
     "Data", "trial 2" 
    }; 

    public static void main(String[] args) { 
     EventQueue.invokeLater(() -> { 
      new Test(true); 
      new Test(false); 
     }); 
    } 

    public Test(boolean reload) { 
     this.reload = reload; 
     frame = new JFrame(String.valueOf(reload)); 
     frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
     treeMap = new HashMap<>(); 
     root = new DefaultMutableTreeNode("Data"); 
     model = new DefaultTreeModel(root); 
     tree = new JTree(model); 
     treeMap.put("Data", root); 
     frame.add(tree, BorderLayout.WEST); 
     frame.pack(); 
     frame.setLocationRelativeTo(null); 
     frame.setVisible(true); 
     Timer t = new Timer(100, new ActionListener() { 
      @Override 
      public void actionPerformed(ActionEvent e) { 
       if (index < folders.length) { 
        addNewFolder(folders[index++], folders[index++]); 
        for (int i = 0; i < tree.getRowCount(); i++) { 
         tree.expandRow(i); 
        } 
        frame.pack(); 
       } 
      } 
     }); 
     t.start(); 
    } 

    private void addNewFolder(String path, String name) { 
     DefaultMutableTreeNode currentNode = treeMap.get(path); 
     DefaultMutableTreeNode childNode = new DefaultMutableTreeNode(name); 
     currentNode.add(childNode); 
     treeMap.put(path + "/" + name, childNode); 
     if (reload) { 
      model.reload(); 
     } else { 
      model.nodeStructureChanged(currentNode); 
     } 
    } 
}