DynamicTreeDemo

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.tree.DefaultMutableTreeNode;

public class DynamicTreeDemo extends JPanel implements ActionListener
{

    private int newNodeSuffix = 1;
    private static String ADD_COMMAND = "add";
    private static String REMOVE_COMMAND = "remove";
    private static String CLEAR_COMMAND = "clear";
    private static String RENAME_COMMAND = "rename";
    
    
    private DynamicTree treePanel;
    public DynamicTreeDemo()
    {
        super(new BorderLayout());
        
        // create the components.
        treePanel = new DynamicTree();
        populateTree(treePanel);
        
        JButton addButton = new JButton("Add");
        addButton.setActionCommand(ADD_COMMAND);
        addButton.addActionListener(this);
        
        JButton removeButton = new JButton("Remove");
        removeButton.setActionCommand(REMOVE_COMMAND);
        removeButton.addActionListener(this);
        
        JButton clearButton = new JButton("Clear");
        clearButton.setActionCommand(CLEAR_COMMAND);
        clearButton.addActionListener(this);
        
        JButton renameButton = new JButton("Rename");
        removeButton.setActionCommand(RENAME_COMMAND);
        renameButton.addActionListener(this);
        
        treePanel.setPreferredSize(new Dimension(300,150));
        add(treePanel,BorderLayout.CENTER);
        
        JPanel panel = new JPanel(new GridLayout(0,4));
        panel.add(addButton);
        panel.add(removeButton);
        panel.add(renameButton);
        panel.add(clearButton);
        add(panel,BorderLayout.SOUTH);
    }
    public void populateTree(DynamicTree treePanel)
    {
        String p1Name = new String("Parent 1");
        String p2Name = new String("Parent 2");
        String c1Name = new String("Child 1");
        String c2Name = new String("Child 2");
        
        DefaultMutableTreeNode p1,p2;
        p1 = treePanel.addObject(null,p1Name);
        p2 = treePanel.addObject(null,p2Name);
        
        treePanel.addObject(p1,c1Name);
        treePanel.addObject(p1,c2Name);
        
        treePanel.addObject(p2,c1Name);
        treePanel.addObject(p2,c2Name);
    }
    @Override
    public void actionPerformed(ActionEvent e)
    {
        String command = e.getActionCommand();
        if (ADD_COMMAND.equals(command)) {
            treePanel.addObject("New Node" + newNodeSuffix++);
        }else if (REMOVE_COMMAND.equals(command)) {
            treePanel.removeCurrentNode();
        } else if (CLEAR_COMMAND.equals(command)) {
            treePanel.clear();
        } else if ((RENAME_COMMAND).equals(command)) {
            treePanel.rename();
        }
    }
    private static void createAndShowGUI() {
        JFrame frame = new JFrame("DynamicTreeDemo");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        
        DynamicTreeDemo newContentPane = new DynamicTreeDemo();
        newContentPane.setOpaque(true); //content panes must be opaque
        frame.setContentPane(newContentPane);
        
        frame.pack();
        frame.setVisible(true);
    }
    public static void main(String[] args)
    {
        javax.swing.SwingUtilities.invokeLater(new Runnable(){

            @Override
            public void run()
            {
                createAndShowGUI();
            }
            
        });
    }
}

import java.awt.GridLayout;
import java.awt.Toolkit;

import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTree;
import javax.swing.event.TreeModelEvent;
import javax.swing.event.TreeModelListener;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.MutableTreeNode;
import javax.swing.tree.TreePath;
import javax.swing.tree.TreeSelectionModel;

public class DynamicTree extends JPanel
{
    /**
     * 
     */
    private static final long serialVersionUID = -807408453466014994L;
    protected DefaultMutableTreeNode rootNode;
    protected DefaultTreeModel treeModel;
    protected JTree tree;
    private Toolkit toolkit = Toolkit.getDefaultToolkit();

    public DynamicTree()
    {
        super(new GridLayout(1, 0));

        rootNode = new DefaultMutableTreeNode("Root Node");
        treeModel = new DefaultTreeModel(rootNode);
        treeModel.addTreeModelListener(new MyTreeModelListener());
        tree = new JTree(treeModel);
        tree.setEditable(true);
        tree.getSelectionModel().setSelectionMode(
                TreeSelectionModel.SINGLE_TREE_SELECTION);
        tree.setShowsRootHandles(true);
        JScrollPane scrollPane = new JScrollPane(tree);
        add(scrollPane);
    }

    /**
     * remove all children
     */
    public void clear()
    {
        rootNode.removeAllChildren();
        treeModel.reload();
    }
    
    public void rename() {
        TreePath currentSelection = tree.getSelectionPath();
        if (currentSelection != null){
            DefaultMutableTreeNode currentNode = (DefaultMutableTreeNode) (currentSelection
                    .getLastPathComponent());
            currentNode.setUserObject(currentNode.toString());
        }
    }

    public void removeCurrentNode()
    {
        TreePath currentSelection = tree.getSelectionPath();
        if (currentSelection != null)
        {
            DefaultMutableTreeNode currentNode = (DefaultMutableTreeNode) (currentSelection
                    .getLastPathComponent());
            MutableTreeNode parent = (MutableTreeNode) (currentNode.getParent());
            if (parent != null)
            {
                treeModel.removeNodeFromParent(currentNode);
                return;
            }
        }
        // 没有选中节点,或者选中的是根节点
        toolkit.beep();
    }

    public DefaultMutableTreeNode addObject(Object child)
    {
        DefaultMutableTreeNode parentNode = null;
        TreePath parentPath = tree.getSelectionPath();
        if (parentPath == null)
        {
            parentNode = rootNode;
        } else
        {
            parentNode = (DefaultMutableTreeNode) (parentPath
                    .getLastPathComponent());
        }
        return addObject(parentNode, child, true);
    }

    public DefaultMutableTreeNode addObject(DefaultMutableTreeNode parent,
            Object child)
    {
        return addObject(parent, child, false);
    }

    public DefaultMutableTreeNode addObject(DefaultMutableTreeNode parentNode,
            Object child, boolean shouldBeVisible)
    {

        DefaultMutableTreeNode childNode = new DefaultMutableTreeNode(child);

        if (parentNode == null)
        {
            parentNode = rootNode;
        }
        // //It is key to invoke this on the TreeModel, and NOT
        // DefaultMutableTreeNode
        treeModel.insertNodeInto(childNode, parentNode, parentNode
                .getChildCount());

        // Make sure the user can see the lovely new node.
        if (shouldBeVisible)
        {
            tree.scrollPathToVisible(new TreePath(childNode.getPath()));
        }
        return childNode;
    }
}

class MyTreeModelListener implements TreeModelListener
{

    @Override
    public void treeNodesChanged(TreeModelEvent e)
    {
        DefaultMutableTreeNode node;
        node = (DefaultMutableTreeNode) (e.getTreePath().getLastPathComponent());

        int index = e.getChildIndices()[0];
        System.out.println("The user has finished editing the node.");
        System.out.println("New value: " + node.getUserObject());
    }

    @Override
    public void treeNodesInserted(TreeModelEvent e)
    {
        // TODO Auto-generated method stub
    }

    @Override
    public void treeNodesRemoved(TreeModelEvent e)
    {
        // TODO Auto-generated method stub
    }

    @Override
    public void treeStructureChanged(TreeModelEvent e)
    {
        // TODO Auto-generated method stub
    }

}