Java JTree延迟加载扩展

希望你做得很好

我有一个JTree，我使用数据库查询（每个节点）惰性地加载它。我在屏幕上有一个按钮，当用户单击该按钮时，我在数据库中执行一些

插入/更新/删除

，然后使用SQL将模型添加回

Jtree

，仅使用根目录及其直接子目录（这会折叠树和选择，并且所有扩展节点都会折叠，因为它是一个延迟加载的树）

我想完成的是，在用户单击按钮插入/更新/删除之前，我读取所有展开的状态并将其保存在内存中，然后当我重新初始化

JTree

时，我通过这些展开的子节点循环调用

JTree.expandPath

，但它不展开节点：（

我甚至添加了一个

TreeWillExpandListener

，在

treeWillExpand

事件中，我添加了代码以从数据库中获取节点的子节点，我看到确实执行了查询以获取子目录，但

JTree

仍然显示为已折叠

我真的需要你的帮助。请建议。这是代码片段

package marketdatagui;

import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTree;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreeModel;
import javax.swing.tree.TreePath;
import javax.swing.event.TreeModelListener;
import javax.swing.event.TreeModelEvent;
import javax.swing.event.EventListenerList;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
import java.io.File;
import java.io.Serializable;
import java.io.ObjectOutputStream;
import java.io.ObjectInputStream;


public class StressGroupModel
    implements TreeModel,Serializable, Cloneable
{
    protected EventListenerList listeners;

    private static final Object LEAF = new Serializable() { };

    private Map map;

    private NodeData root;

    private class NodeData{
        String id;
        String name;

        public String toString(){
            return name;
        }
    }

    public StressGroupModel()
    {
        this.root = new NodeData();
        root.id = "Root";
        root.name = "Root";

        this.listeners = new EventListenerList();

        this.map = new HashMap();

        List rootChildren = new ArrayList();

        NodeData d1 = new NodeData();
        d1.id = "5000007";
        d1.name = "Name5000007";

        rootChildren.add(d1);

        NodeData d2 = new NodeData();
        d2.id = "10000054";
        d2.name = "Name10000054";

        rootChildren.add(d2);
        map.put(root.id, rootChildren);
    }


    public Object getRoot()
    {
        return root;
    }

    public boolean isLeaf(Object node)
    {
        return map.get(node) == LEAF;
    }

    public int getChildCount(Object node)
    {
        List children = children(node);

        if (children == null)
            return 0;

        return children.size();
    }

    public Object getChild(Object parent, int index)
    {
        return children(parent).get(index);
    }

    public int getIndexOfChild(Object parent, Object child)
    {
        return children(parent).indexOf(child);
    }

    protected List children(Object node)
    {
        NodeData s = (NodeData)node;

        Object value = map.get(s.id);

        if (value == LEAF)
            return null;

        List children = (List)value;

        if (!"Root".equals(s.id))
        {
            String[][] dbData = getChildren(s.id);

            if (dbData != null)
            {
                children = new ArrayList(dbData.length);
                for (int i = 0; i < dbData.length; i++)
                {
                    NodeData d = new NodeData();
                    d.id = dbData[i][1];
                    d.name = dbData[i][1] + "Name";
                    children.add(d);
                    if ("R".equals(dbData[i][2]))
                        map.put(d, LEAF);
                }
            }
            else
                children = new ArrayList(0);

            map.put(s.id, children);       
        }

        return children;
    }

    private String[][] getChildren(String parent_uid){
        String sql = "select parent_uid,child_uid,child_type from stress_groups_mapping "
              + " where parent_uid="+ parent_uid
              +" order by parent_uid, child_uid";

        return Util.getTableData(sql);
    }

    public void valueForPathChanged(TreePath path, Object value)
    {
    }

    public void addTreeModelListener(TreeModelListener l)
    {
        listeners.add(TreeModelListener.class, l);
    }

    public void removeTreeModelListener(TreeModelListener l)
    {
        listeners.remove(TreeModelListener.class, l);
    }

    public Object clone()
    {
        try
        {
            StressGroupModel clone = (StressGroupModel)super.clone();

            clone.listeners = new EventListenerList();

            clone.map = new HashMap(map);

            return clone;
        }
        catch (CloneNotSupportedException e)
        {
            throw new InternalError();
        }
    }

}

• 下面是我如何保存扩展状态的

枚举路径=jtree.getExpandedDescendats（新 树路径（jtree.getModel（）.getRoot（））

• 是否插入/更新/删除数据库内容
• 现在重新初始化模型并添加回JTree（因此它选择最新的 来自数据库的值）
• 现在我循环并调用expand来扩展用户扩展的节点 在他点击按钮但不幸的是，按钮一直处于折叠状态之前：(

jtree.setModel（新的StressGroupModel（））； while（path.hasMoreElements（））{

我找到了解决办法

在我的NodeData类中需要equals方法和hashCode，问题是在设置新模型后，当我尝试扩展路径时equals返回false，因为equals的默认实现执行“浅比较”，即仅比较引用，我必须重写hashCode和equals方法并执行“深比较”用相等的方法

---

感谢

尽快提供更好的帮助，发布一篇文章。我在一个自定义节点类中遇到了类似的问题-结果证明我的

equals

方法不太正确。哇。我花了几个小时，不明白expandPath（）为什么不起作用。访问这么多论坛并阅读相同的建议真是令人沮丧：（使用“expandPath（），setSelectionPath（）“等等）。但它根本不起作用。谢谢！！！

JFrame f = new JFrame("Tree Dragging Tester");
          DefaultMutableTreeNode root = new DefaultMutableTreeNode(new Object());
          jtree = new JTree(new StressGroupModel());
          TreeWillExpandListener treeWillExpandListener = new TreeWillExpandListener() {
                public void treeWillCollapse(TreeExpansionEvent treeExpansionEvent)
                    throws ExpandVetoException {


                }

                public void treeWillExpand(TreeExpansionEvent treeExpansionEvent) throws ExpandVetoException {
                    TreePath path = treeExpansionEvent.getPath();
                    Object node =  path.getLastPathComponent();
                    ((StressGroupModel)jtree.getModel()).getChildCount(node);
                  }


          };

          jtree.addTreeWillExpandListener(treeWillExpandListener);

          f.getContentPane().add(jtree, BorderLayout.CENTER);
          f.setSize(300, 200);
          f.setVisible(true);
}

            TreePath treePath = (TreePath) paths.nextElement();

            try {

            jtree.expandPath(treePath);
            jtree.setSelectionPath(treePath);

            }
            catch(Exception ex){

            }

        }