Tree Component (JTree)

A tree can only have one parent node, and it can have zero or more children. By default, each node can have children, and it can be set to not have children.
Common construction methods:
public JTree() creates a default tree
public JTree(TreeNode root) creates a tree from the root node
public JTree(TreeModel newModel) creates a tree based on the specified tree model

DefaultMutableTreeNode
DefaultMutableTreeNode implements the TreeNode tree node interface, which is used to create the nodes of the tree.
Common construction methods:
public DefaultMutableTreeNode() creates a tree node with no parent and no child nodes, but it allows child nodes.
public DefaultMutableTreeNode(Object userObject) creates a node with a specified tag.
public DefaultMutableTreeNode(Object userObject,boolean allowsChildren) creates a node with the specified tag and specifies whether child nodes are allowed.

DefaultTreeModel
DefaultTreeModel implements the TreeModel interface.
Common construction methods:
The public DefaultTreeModel(TreeNode root) creates a tree model that uses the default way to determine whether a node is a leaf node or not.
The public DefaultTreeModel(TreeNode root,boolean asksAllowsChildren) creates a tree model that determines whether a node is a leaf node in a specified way.
Note: There are two ways to determine whether a node is a leaf node or not: 1. Default: if no child node exists for a node, it is a leaf node.2. According to whether a node allows children, as long as no children are allowed to be leaf nodes, if children are allowed, they are not leaf nodes even if they do not contain any children.When asksAllowsChildren is true, the second judgment is used.

Code example:
public class ExampleFrame_01 extends JFrame {
	private static final long serialVersionUID = 1L;
	public static void main(String args[]) {
		ExampleFrame_01 frame = new ExampleFrame_01();
		frame.setVisible(true);
	}
	
	public ExampleFrame_01() {
		super();
		setTitle("Simple Tree");
		setBounds(100, 100, 500, 375);
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		// Create Root Node
		DefaultMutableTreeNode root = new DefaultMutableTreeNode("root node");
		// Create a Level 1 Node
		DefaultMutableTreeNode nodeFirst = new DefaultMutableTreeNode(
				"First-level child nodes A");
		root.add(nodeFirst);// Add a first-level node to the root node
		DefaultMutableTreeNode nodeSecond = new DefaultMutableTreeNode(
				"Secondary Child Node", false);// Create secondary nodes that do not allow child nodes
		nodeFirst.add(nodeSecond);// Add a secondary node to a primary node
		root.add(new DefaultMutableTreeNode("First-level child nodes B"));// Create a Level 1 Node
		JTree treeRoot = new JTree(root);// Create a tree directly from the root node
		getContentPane().add(treeRoot, BorderLayout.WEST);
		// Use root node to create tree model, using default judgment
		DefaultTreeModel treeModelDefault = new DefaultTreeModel(root);
		// Creating a tree using a tree model
		JTree treeDefault = new JTree(treeModelDefault);
		getContentPane().add(treeDefault, BorderLayout.CENTER);
		// Create a tree model from the root node and use a non-default judgment
		DefaultTreeModel treeModelPointed = new DefaultTreeModel(root,
				true);
		JTree treePointed = new JTree(treeModelPointed);// Creating a tree using a tree model
		getContentPane().add(treePointed, BorderLayout.EAST);
	}
}

TreeSelectionModel
Tree selection mode can be set through the TreeSelectionModel interface

Select mode static constants:

TreeSelectionListener interface and TreeSelectionEvent
TreeSelectionListener interface:
Tree component registration listener: addTreeSelectionListener
Void valueChanged (TreeSelectionEvent): Triggered when a node is selected or cancelled
(Tree)e.getSource() is the tree object of the selected node.

TreePath class
TreePath represents the path of the tree node.TreePath is an array of Objects provided by TreeModel.Sort the elements of the array so that the root is always the first element of the array (index is 0).

Traverse Tree Nodes
1. Pre-order traversal
2. Post-order traversal
3. Width first traversal
4. Depth first traversal
The DefaultMutableTreeNode class provides two sets of relative traversals:

Note: Since post-order traversal and depth-first traversal are the same, the method depthFirstEnumeration() actually calls the method postorderEnumeration().

Enumeration<?> enumeration; // Traverse all tree nodes in preceding order
		enumeration = root.preorderEnumeration();
		while (enumeration.hasMoreElements()) {
			DefaultMutableTreeNode node;
			node = (DefaultMutableTreeNode) enumeration.nextElement();
			if (!node.isLeaf()) {// Determine whether it is a leaf node
				// Path to create this node
				TreePath path = new TreePath(node.getPath());
				tree.expandPath(path);// Expand the node if not
			}

Custom Tree
1. Custom Root Node Effect: By default, the root node of the tree is displayed, but the root node handle is not displayed.This can be set by the following methods in the JTree class:

2. Custom Icons: Node icons can be modified by objects of the DefaultTreeCellRenderer class (implementation class for the TreeCellRenderer interface), which is obtained by the public TreeCellRenderer getCellRenderer() (forced) method of the JTree class, as follows:

3. Custom connection line effect: By default, connection lines are drawn between tree nodes, and the connection lines are drawn by public final void putClientProperty(Object key,Object value).Set the entry parameter key to "JTree.lineStyle".Value is None, which means no connection lines between nodes are drawn; Horizontal, which means drawing horizontal column lines; Angled, which means drawing connection lines between nodes, which is equivalent to the default setting.

4. By default, only the root node of the tree is expanded, and all other child nodes are collapsed.If you want a node of the tree to be expanded at the first run time, you need to pass in the path of the expanded node through the public void expandPath(TreePath path) method.

public class ExampleFrame_04 extends JFrame {
	private static final long serialVersionUID = 1L;
	private JTree tree;
	public static void main(String args[]) {
		ExampleFrame_04 frame = new ExampleFrame_04();
		frame.setVisible(true);
	}
	public ExampleFrame_04() {
		super();
		setTitle("Custom Tree");
		setBounds(100, 100, 200, 325);
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		DefaultMutableTreeNode root;
		root = new DefaultMutableTreeNode("Enterprise Personnel Management System");
		DefaultMutableTreeNode nodeFirstA;
		nodeFirstA = new DefaultMutableTreeNode("personnel management");
		nodeFirstA.add(new DefaultMutableTreeNode("Ledger Management"));
		nodeFirstA.add(new DefaultMutableTreeNode("Attendance management"));
		nodeFirstA.add(new DefaultMutableTreeNode("Reward and Punishment Management"));
		nodeFirstA.add(new DefaultMutableTreeNode("Training Management"));
		root.add(nodeFirstA);
		DefaultMutableTreeNode nodeFirstB;
		nodeFirstB = new DefaultMutableTreeNode("Treatment Management");
		nodeFirstB.add(new DefaultMutableTreeNode("Ledger management"));
		nodeFirstB.add(new DefaultMutableTreeNode("Personnel Settings"));
		nodeFirstB.add(new DefaultMutableTreeNode("Treatment Report"));
		root.add(nodeFirstB);
		DefaultMutableTreeNode nodeFirstC;
		nodeFirstC = new DefaultMutableTreeNode("system maintenance");
		nodeFirstC.add(new DefaultMutableTreeNode("Enterprise Architecture"));
		nodeFirstC.add(new DefaultMutableTreeNode("Basic Data"));
		nodeFirstC.add(new DefaultMutableTreeNode("System Initialization"));
		root.add(nodeFirstC);
		tree = new JTree(root);
		tree.setRootVisible(false);// Do not display the root node of the tree
		tree.setRowHeight(20);// The row height of the tree node is 20 pixels
		tree.setFont(new Font("Song Style", Font.BOLD, 14));// Set the font of the tree node
		// No connection lines between nodes
		tree.putClientProperty("JTree.lineStyle", "None");
		DefaultTreeCellRenderer treeCellRenderer;// Get the drawing object of the tree node
		treeCellRenderer = (DefaultTreeCellRenderer) tree
				.getCellRenderer();
		treeCellRenderer.setLeafIcon(null);// Set leaf nodes without icons
		treeCellRenderer.setClosedIcon(null);// Set node collapse without Icon
		treeCellRenderer.setOpenIcon(null);// Set the node to expand without icons
		Enumeration<?> enumeration; // Traverse all tree nodes in preceding order
		enumeration = root.preorderEnumeration();
		while (enumeration.hasMoreElements()) {
			DefaultMutableTreeNode node;
			node = (DefaultMutableTreeNode) enumeration.nextElement();
			if (!node.isLeaf()) {// Determine whether it is a leaf node
				// Path to create this node
				TreePath path = new TreePath(node.getPath());
				tree.expandPath(path);// Expand the node if not
			}
		}
		getContentPane().add(tree, BorderLayout.CENTER);
	}
}

Maintain tree model
1. Add a tree node (add a new node to the tree model)
2. Modify the tree node: The nodeChanged(TreeNode node) method in the DefaultTreeModel class is used to notify the tree model that a node has been modified. If the user object of the node is modified, the modified information will not be synchronized to the GUI interface.
3. Delete the tree node: Delete the specified node from the tree model.

1.Add Node
		addButton.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				DefaultMutableTreeNode node = new DefaultMutableTreeNode(
						textField.getText());// Create the node you want to add
				TreePath selectionPath = tree.getSelectionPath();// Get the selected parent node path
				DefaultMutableTreeNode parentNode = (DefaultMutableTreeNode) selectionPath.getLastPathComponent();// Get the selected parent node
				treeModel.insertNodeInto(node, parentNode, parentNode
						.getChildCount());// After inserting a node into all child nodes
				TreePath path = selectionPath.pathByAddingChild(node);// Get the path to the newly added node
				if (!tree.isVisible(path))
					tree.makeVisible(path);// Make this node visible if it is not visible
			}
		});
		
2.Modify Node
		updButton.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				// Get the selected path to modify the node
				TreePath selectionPath = tree.getSelectionPath();
				DefaultMutableTreeNode node = (DefaultMutableTreeNode) selectionPath
						.getLastPathComponent();// Get the selected node to modify
				node.setUserObject(textField.getText());// Modify the user label of a node
				treeModel.nodeChanged(node);// Notification tree model The node has been modified
				tree.setSelectionPath(selectionPath);// Select the modified node
			}
		});
		
3.Delete Node
		delButton.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent e) {
				DefaultMutableTreeNode node = (DefaultMutableTreeNode) tree
						.getLastSelectedPathComponent();// Get the selected node to delete
				// Check to see if the node you want to delete is a root node, the root node does not allow deletion
				if (!node.isRoot()) {
					DefaultMutableTreeNode nextSelectedNode = node
							.getNextSibling();// Get the next sibling node to select
					if (nextSelectedNode == null)// Check for sibling nodes
						nextSelectedNode = (DefaultMutableTreeNode) node
								.getParent();// Select its parent if it does not exist
					treeModel.removeNodeFromParent(node);// Delete Node
					tree.setSelectionPath(new TreePath(nextSelectedNode
							.getPath()));// Selected Node
				}
			}
		});

Handle Expanded Node Events
1.TreeWillExpandListener interface and TreeExpansionEvent
2.TreeExpansionListener interface and TreeExpansionEvent

Monitoring interface method and instructions:
1.TreeWillExpandListener interface:
Can be used to require user permissions to be verified, and tree nodes are not allowed to expand if the user does not have permission to view the child nodes contained in the node.

2.TreeExpansionListener interface:

3.TreeExpansionEvent

Examples are as follows:
tree.addTreeWillExpandListener(new TreeWillExpandListener() {
	// Triggered when the tree node is about to be collapsed
	public void treeWillCollapse(TreeExpansionEvent e) {
		TreePath path = e.getPath();// Get the path of the node to be collapsed
		DefaultMutableTreeNode node = (DefaultMutableTreeNode) path
				.getLastPathComponent();// Get the node that will be collapsed
		System.out.println("Node "" + node + ""Will be folded!");
	}
	
	// Triggered when the tree node is about to be expanded
	public void treeWillExpand(TreeExpansionEvent e) {
		TreePath path = e.getPath();// Get the path of the node to be expanded
		DefaultMutableTreeNode node = (DefaultMutableTreeNode) path
				.getLastPathComponent();// Get the node that will be expanded
		System.out.println("Node "" + node + ""Will be expanded!");
	}
});
// Capture events where tree nodes have been expanded or collapsed
tree.addTreeExpansionListener(new TreeExpansionListener() {
	// Triggered when the tree node has collapsed
	public void treeCollapsed(TreeExpansionEvent e) {
		TreePath path = e.getPath();// Get the path of a node that has been collapsed
		DefaultMutableTreeNode node = (DefaultMutableTreeNode) path
				.getLastPathComponent();// Get a node that has been collapsed
		System.out.println("Node "" + node + ""Folded!");
		System.out.println();
	}
	
	// Triggered when the tree node has been expanded
	public void treeExpanded(TreeExpansionEvent e) {
		TreePath path = e.getPath();// Get the path of the node that has been expanded
		DefaultMutableTreeNode node = (DefaultMutableTreeNode) path
				.getLastPathComponent();// Get the expanded node
		System.out.println("Node "" + node + ""Already expanded!");
		System.out.println();
	}
});