从字符串构建JTree

Question

我有两个字符串 node1/node2/node3/node4“和”node1/node2/node5/node6“。...我怎样才能从这个字符串中构建一个摇摆的JTree？这是我构建一个字符串的代码....

import java.awt.*;  
import java.util.ArrayList;

import javax.swing.*;  
import javax.swing.tree.*;  

public class PathTest  
{  
    public PathTest()  
    {  

    DefaultMutableTreeNode   node = buildNodeFromString();   


        DefaultTreeModel model = new DefaultTreeModel(node);  
        JTree tree = new JTree(model);  
        JFrame f = new JFrame();  
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
        f.add(tree);  
        f.setSize(300,300);  
        f.setLocation(200,200);  
        f.setVisible(true);  
    }  

private DefaultMutableTreeNode buildNodeFromString() {



String qqq= "node1/node2/node3/node4";
DefaultMutableTreeNode node, lastNode = null, root = null;

    String[] s = qqq.split("/");
    for (String str : s) {
    node = new DefaultMutableTreeNode(str);     
    if (root == null)
        root = node;
    if (lastNode != null)
        lastNode.add(node);
    lastNode = node;
    }

return root;
}

    public static void main(String[] args)  
    {  
        new PathTest();  
    }  
}  

Answer 1

for (String str : s) {
    node = new DefaultMutableTreeNode(str);     
    if (root == null)
         root = node;
    if (lastNode != null)
        lastNode.add(node);
    lastNode = node;
}

在代码段中，检查lastNode是否已经有同名的子节点，而不是创建新的DefaultMutableTreeNode实例。

Answer 2

试试这个，这段代码为树创建一个根，然后开始在它下面添加字符串，如果你不想让那个根显示，只需调用< code > tree . setrootvisible(false)；

import java.util.Enumeration;

import javax.swing.JFrame;
import javax.swing.JTree;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;

public class PathTest {
    public PathTest() {
        // Create the root node, I'm assuming that the delimited strings will have
        // different string value at index 0
        DefaultMutableTreeNode root = new DefaultMutableTreeNode("ROOT");

        // Create the tree model and add the root node to it
        DefaultTreeModel model = new DefaultTreeModel(root);

        // Create the tree with the new model
        JTree tree = new JTree(model);

        // Build the tree from the various string samples
        buildTreeFromString(model, "Node 1/Node 2/Node 3/Node 4");
        buildTreeFromString(model, "Node 1/Node 2/Node 3/Node 5");
        buildTreeFromString(model, "Node 1/Node 2/Node 3/Node 6");
        buildTreeFromString(model, "Node 1/Node 2/Node 4/Node 5");
        buildTreeFromString(model, "Node 1/Node 1/Node 3/Node 5");

        // UI
        JFrame f = new JFrame();
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.add(tree);
        f.setSize(300, 300);
        f.setLocation(200, 200);
        f.setVisible(true);
    }

    /**
     * Builds a tree from a given forward slash delimited string.
     * 
     * @param model The tree model
     * @param str The string to build the tree from
     */
    private void buildTreeFromString(final DefaultTreeModel model, final String str) {
        // Fetch the root node
        DefaultMutableTreeNode root = (DefaultMutableTreeNode) model.getRoot();

        // Split the string around the delimiter
        String [] strings = str.split("/");

        // Create a node object to use for traversing down the tree as it 
        // is being created
        DefaultMutableTreeNode node = root;

        // Iterate of the string array
        for (String s: strings) {
            // Look for the index of a node at the current level that
            // has a value equal to the current string
            int index = childIndex(node, s);

            // Index less than 0, this is a new node not currently present on the tree
            if (index < 0) {
                // Add the new node
                DefaultMutableTreeNode newChild = new DefaultMutableTreeNode(s);
                node.insert(newChild, node.getChildCount());
                node = newChild;
            }
            // Else, existing node, skip to the next string
            else {
                node = (DefaultMutableTreeNode) node.getChildAt(index);
            }
        }
    }

    /**
     * Returns the index of a child of a given node, provided its string value.
     * 
     * @param node The node to search its children
     * @param childValue The value of the child to compare with
     * @return The index
     */
    private int childIndex(final DefaultMutableTreeNode node, final String childValue) {
        Enumeration<DefaultMutableTreeNode> children = node.children();
        DefaultMutableTreeNode child = null;
        int index = -1;

        while (children.hasMoreElements() && index < 0) {
            child = children.nextElement();

            if (child.getUserObject() != null && childValue.equals(child.getUserObject())) {
                index = node.getIndex(child);
            }
        }

        return index;
    }

    public static void main(String[] args) {
        new PathTest();
    }
}

希望这有帮助。