Composants d'arbre de balançoire
La structure arborescente est une forme d'expression d'information couramment utilisée, elle peut afficher intuitivement la structure hiérarchique d'un groupe d'informations. La classe JTree dans Swing est utilisée pour créer des arbres.
Premièrement, créez un arbre simple
JTree a trois méthodes de construction courantes pour créer des arbres.
| Méthode de construction | La description |
|---|---|
| JTree () | Créer une arborescence par défaut |
| JTree (racine TreeNode) | Créer une arborescence basée sur le nœud racine spécifié |
| JTree (TreeModel newModel) | Créer un arbre basé sur le modèle d'arbre spécifié |
La classe DefaultMutableTreeNode implémente l'interface TreeNode, qui est utilisée pour créer des nœuds d'arborescence. Une arborescence ne peut avoir qu'un seul nœud parent et elle peut avoir 0 ou plusieurs nœuds enfants. Utilisez la méthode add (MutableTreeNode newChild) de la classe DefaultMutableTreeNode pour ajouter des nœuds enfants au nœud. Un nœud avec des nœuds enfants est appelé nœud parent et un nœud sans nœud parent est appelé nœud racine.
Méthodes de construction couramment utilisées de la classe DefaultMutableTreeNode
| Méthode de construction | La description |
|---|---|
| DefaultMutableTreeNode () | Créer un nœud par défaut, autorisant les nœuds enfants par défaut |
| DefaultMutableTreeNode (objet userObject) | Créer un nœud avec l'étiquette spécifiée |
| DefaultMutableTreeNode (Object userObject, boolean allowChildren) | Créez un nœud avec une étiquette spécifiée et spécifiez s'il faut autoriser les nœuds enfants |
Créez un arbre simple, le code est le suivant:
package study.czm;
import java.awt.Container;
import javax.swing.JFrame;
import javax.swing.JTree;
import javax.swing.tree.DefaultMutableTreeNode;
public class Study {
public static void main(String[] args) {
JFrame jf = new JFrame();
jf.setTitle("表格组件");
jf.setSize(500, 400);
jf.setLocationRelativeTo(null);
jf.setDefaultCloseOperation(jf.EXIT_ON_CLOSE);
Container c = jf.getContentPane();
// 创建根节点
DefaultMutableTreeNode root = new DefaultMutableTreeNode("根节点");
// 创建一级子节点
DefaultMutableTreeNode root1 = new DefaultMutableTreeNode("一级子节点1");
DefaultMutableTreeNode root2 = new DefaultMutableTreeNode("一级子节点2");
DefaultMutableTreeNode root3 = new DefaultMutableTreeNode("一级子节点3");
// 创建二级子节点
DefaultMutableTreeNode root11 = new DefaultMutableTreeNode("二级子节点1");
DefaultMutableTreeNode root12 = new DefaultMutableTreeNode("二级子节点2");
DefaultMutableTreeNode root21 = new DefaultMutableTreeNode("二级子节点3");
// 根节点添加一级子节点
root.add(root1);
root.add(root2);
root.add(root3);
// 一级子节点添加二级子节点
root1.add(root11);
root1.add(root12);
root2.add(root21);
JTree tree = new JTree(root);
c.add(tree);
jf.setVisible(true);
}
}
résultat courant:
Deuxièmement, gérez l'événement de nœud sélectionné
Les nœuds de l'arborescence peuvent être sélectionnés et désélectionnés. En capturant les événements de sélection de nœuds, les opérations correspondantes peuvent être traitées. Il existe trois modes de sélection d'arborescence. Le mode de sélection d'arborescence peut être défini par des objets de la classe TreeSelectionModel.
La constante statique représentant le mode de sélection dans la classe TreeSelectionModel
| Constante statique | La description |
|---|---|
| SINGLE_TREE_SELECTION | N'en autorisez qu'un seul à être sélectionné |
| CONTIGUOUS_TREE_SELECTION | Autoriser plusieurs sélections à la suite |
| DISCONTIGUOUS_TREE_SELECTION | Autoriser plusieurs sélections, le mode par défaut |
La classe TreePath représente le chemin du nœud d'arbre, c'est-à-dire que le nœud parent auquel appartient le nœud enfant et le nœud parent auquel appartient le nœud parent peut être obtenu via cette classe, jusqu'au nœud racine du numéro.
Méthodes courantes de la classe TreePath
| méthode | La description |
|---|---|
| getPath () | Renvoie les objets de tous les nœuds du chemin sous la forme d'un tableau Object, l'ordre dans le tableau va du nœud racine aux nœuds enfants |
| getLastPathComponent () | Récupère l'objet du dernier nœud du chemin |
| getParentPath () | Récupère le chemin sauf le dernier nœud du chemin |
| pathByAddingChild (objet enfant) | Obtenez le chemin après avoir ajouté le nœud spécifié au chemin |
| getPathCount () | Obtenez le nombre de nœuds inclus dans le chemin |
| getPathComponent (élément int) | Récupère l'objet nœud à la position d'index spécifiée dans le chemin |
Trois, traversez les nœuds de l'arbre
Il existe quatre méthodes pour parcourir les nœuds d'arbre, traverser en pré-ordre, traverser en post-ordre, traverser d'abord avec la largeur et traverser d'abord avec la profondeur. Les méthodes de parcours spécifiques du parcours post-ordre et du parcours profondeur d'abord sont les mêmes.
Traverser en pré-ordre: Traverser
en post-ordre: traverser
avec la largeur en premier: traverser
avec la profondeur en premier:
Grâce à la méthode children () de la classe DefaultMutableTreeNode, vous pouvez obtenir un objet d'énumération qui ne contient que les nœuds enfants du nœud pour parcourir rapidement les nœuds enfants du nœud.
Méthodes courantes de la classe DefaultMutableTreeNode
| méthode | La description |
|---|---|
| getLevel () | Obtenez la valeur de niveau du nœud par rapport au nœud racine, telle que la valeur de niveau du nœud enfant du nœud est 1 |
| getDepth () | Obtenez la profondeur du nombre avec ce nœud comme nœud racine. Si le nœud n'a pas d'enfants, la profondeur est 0 |
| getParent () | Récupère l'objet de nœud parent du nœud |
| getChildCount () | Obtenez le nombre de nœuds enfants que le nœud a |
| getFirstChild () | Récupère le premier objet nœud enfant du nœud |
| getSiblingCount () | Obtenez le nombre de nœuds frères appartenant au nœud |
| getNextSibing () | Obtenir le nœud frère suivant du nœud |
| getPreviousSibling | Obtenir le nœud frère précédent du nœud |
| getPath () | Obtenez le chemin du nœud |
| isRoot () | Déterminez si le nœud est le nœud racine |
| isLeaf () | Déterminez si le nœud est un nœud feuille |
Quatrièmement, l'arbre personnalisé
Lorsque vous utilisez une arborescence, il est souvent nécessaire d'effectuer une série de paramètres sur l'arborescence, tels que les icônes de nœud, les lignes de connexion entre les nœuds et l'état d'expansion de l'arborescence. Utilisez les méthodes de première ligne de la classe JTree pour personnaliser l'arborescence.
1. Paramètre de poignée du nœud racine
Paramètre par défaut:
si vous ne voulez pas de poignée devant le nœud, définissez-la tree.setRootVisible(false);.
2. Paramètres de l'icône du nœud
| méthode | La description |
|---|---|
| setLeafIcon (icône newIcon) | Définir l'icône du nœud feuille |
| setClosedIcon (icône newIcon) | Définir l'icône lorsque le nœud est à l'état réduit |
| setOpenIcon (icône newIcon) | Définir l'icône lorsque le nœud est à l'état développé |
3. Paramètre de ligne de connexion de nœud
Paramètre par défaut: à définir
si vous ne souhaitez pas avoir de ligne de connexion tree.putClientProperty("JTree.lineStyle", "None");.
Si défini sur tree.putClientProperty("JTree.lineStyle","Horizontal");. Il deviendra une ligne de colonne horizontale.
Cinq, maintenez le modèle d'arbre
Lorsque vous utilisez une arborescence, il est parfois nécessaire de fournir des fonctions de maintenance pour l'arborescence, telles que l'ajout, la suppression, la modification et la vérification des opérations. Ces opérations doivent être implémentées via la classe de modèle d'arbre DefaultTreeModel.
1. Ajout d'un nœud d'arbre
La méthode insertNodeInto () de la classe DefaultTreeModel peut ajouter un nouveau nœud au modèle d'arbre.
insertNodelnto(MutableTreeNode newChild, MutableTreeNode parent, int index);
newChild: l'objet de nœud nouvellement ajouté.
parent: objet du nœud parent où se trouve le nœud nouvellement ajouté.
index: la position d'index du nœud nouvellement ajouté.
2. Modifier le nœud de l'arborescence
La méthode nodeChangen () de la classe DefaultTreeModel est utilisée pour modifier le nœud.
nodeChanged(treeNode);
treeNode: l'objet de nœud modifié.
3. Supprimer le nœud
La méthode removeNodeFromParent () de la classe DefaultTreeModel est utilisée pour supprimer le nœud spécifié dans l'arborescence.
removeNodeFromParent(treeNode);
treeNode: L'objet noeud à supprimer.
Remarque: Le nœud racine de l'arborescence ne peut pas être supprimé. Si vous essayez de supprimer le nœud racine, une exception se produira.