précédent | suivant | table des matières

JTree

(Démonstration)

Le composant JTree permet de visualiser une structure d'arbre.

Généralités

Une instance de JTree ne contient pas de données, mais est simplement une vue de données contenues dans son modèle (architecture MVC).

Les données sont affichées ligne par ligne, chaque ligne contenant exactement une donnée qui est un Nœud

Un arbre a une racine

Les nœuds qui n’ont pas de fils sont des feuilles.

Une instance de JTree peut être créée par un constructeur par défaut, qui affiche l’image ci-contre, ou par un constructeur ayant en paramètre un TreeNode ou un TreeModel.

TreeModel est une interface, qui est implantée par exemple par DefaultTreeModel.

TreeNode est une interface, qui est dérivée en MutableTreeNode, qui est implantée par exemple par DefaultMutableTreeNode.

Exemples : 

DefaultMutableTreeNode racine1 =
       new DefaultMutableTreeNode("c’est la racine") ;
JTree monArbre1 = new JTree(racine1) ; 

DefaultMutableTreeNode racine2 =
       new DefaultMutableTreeNode("c’est la racine");
for( int i = 0; i < 3; ++i)
   racine2.add( new DefaultMutableTreeNode("fils N° "+ i));
JTree monArbre2 = new JTree(racine2) ;

racine3 = new DefaultMutableTreeNode("c’est la racine");
DefaultTreeModel arbreModele = new DefaultTreeModel(racine3);
monArbre3 = new JTree(arbreModele); 
   ...
for( int i = 0; i < 3; ++i){
    DefaultMutableTreeNode x = 
	  new DefaultMutableTreeNode("fils N° "+ i);
    for( int j = 0; j < 2*i; ++j)
    x.add( new DefaultMutableTreeNode("filsN° "+ i+"  "+j));
    racine3.add(x);
}

JTree

Constructeurs

JTree()

JTree(Hashtable<?,?> valeur) 

JTree(Object[] valeur)

JTree(TreeModel modele)

JTree(TreeNode racine)

JTree(TreeNode racine, boolean b)

JTree(Vector<?> valeur)

Quelque méthodes

Les branches de l'arbre peuvent être déployée ou refermées :

void collapseRow(TreePath chemin)

voidcollapseRow(int i)

void expandPath(TreePath chemin)

void expandRow(int i)

boolean isCollapsed(int i)

boolean isCollapsed(TreePath chemin)

boolean isExpanded(int i)

boolean isExpanded(TreePath chemin)

TreeModel getModel()

voidsetModel(TreeModel modele)

Affecter ou récupérer le modèle du JTree.

TreeModel getModel()

void setModel(TreeModel modele)

Visibilité de la racine, et de lignes.

void setRootVisible(boolean b)

boolean isRootVisible()

int getRowCount()

void setVisibleRowCount(int n)

DefaultTreeModel

La classe DefaultTreeModel définit un modèle de données pour la classe JTree. Les modifications dans le modèle sont répercutées dans le JTree.

Constructeurs

DefaultTreeModel(TreeNode racine) 

DefaultTreeModel(TreeNode racine, boolean b)

Quelques méthodes

void setRoot(TreeNode racine)

Object getRoot() 

void reload()

void insertNodeInto(MutableTreeNode fils,
   MutableTreeNode parent, int i)

void removeNodeFromParent(MutableTreeNode n)

Object getChild(Object parent, int index)

int getChildCount(Object parent)

int getIndexOfChild(Object parent, Object fils)

boolean isLeaf( Object n)

Exemple :

DefaultTreeModel dtm;
JTree jt;
TreePath tp;
dtm = new DefaultTreeModel(
      new DefaultMutableTreeNode("racine"));
jt = new JTree(dtm);

DefaultMutableTreeNode racine =
        (DefaultMutableTreeNode)dtm.getRoot();
racine.removeAllChildren();
dtm.reload();

TreePath tp = jt.getSelectionPath();
if(tp != null){
   DefaultMutableTreeNode parent = 
       (DefaultMutableTreeNode)
       tp.getLastPathComponent());
   DefaultMutableTreeNode nouveau = 
         new DefaultMutableTreeNode("nœud  "+(++in));
   dtm.insertNodeInto(nouveau, 
         parent, parent.getChildCount());
   jt.scrollPathToVisible(
      new TreePath(nouveau.getPath()));
}

TreePath tp = jt.getSelectionPath();
if(tp != null){
   DefaultMutableTreeNode noeud = 
      (DefaultMutableTreeNode)
	  (tp.getLastPathComponent());
   if(!noeud.isRoot())dtm.removeNodeFromParent(noeud);
}

DefaultMutableTreeNode

Un defaultMutableTreeNode est un nœud à tout faire. Un nœud a au plus un parent et 0 ou plus nœuds fils. Un defaultMutableTreeNode offre des méthodes permettant d’examiner, ou de modifier le parent ou les nœuds enfants. Un nœud sans parent est la racine. Un nœud sans enfant est une feuille. Un defaultMutableTreeNode a parmi ses attributs un attribut parent de type defaultMutableTreeNode, et un attribut childrensde type Vector.

Constructeurs :

DefaultMutableTreeNode()

DefaultMutableTreeNode(Object o)

DefaultMutableTreeNode(Objecto, boolean b)

Ajout ou retrait de nœuds :

void add(MutableTreeNode fils)

void insert(MutableTreeNode f, int i)

void remove(int i)

void removeFromParent()

void removeAllChildren()

void remove(MutableTreeNode f)

void setParent(MutableTreeNode n)

Informations sur le nœud :

boolean isRoot()

TreeNode getRoot()

boolean isLeaf()

int getDepth()

int getChildCount()

int getLeafCount()

nt getSiblingCount()

TreeNode getParent()

TreeNode[]getPath()

TreeNode getChildAfter(TreeNode fils)

TreeNode getChildAt(int i)

TreeNode getChildBefore(TreeNode fils)

TreeNode getFirstChild()

int getIndex(TreeNode fils)

TreeNode getLastChild()

DefaultMutableTreeNode getNextNode()

DefaultMutableTreeNode getPreviousNode()

Les ascendants, descendants et frères :

DefaultMutableTreeNode getNextSibling()

DefaultMutableTreeNode getPreviousSibling()

boolean isNodeSibling(TreeNode n)

TreeNode getChildAfter(TreeNode fils)

TreeNode getChildAt(int i)

TreeNode getChildBefore(TreeNode fils)

TreeNode getFirstChild()

int getIndex(TreeNode fils)

TreeNode getLastChild()

DefaultMutableTreeNode getNextNode()

DefaultMutableTreeNode getPreviousNode()

TreeNode getSharedAncestor(DefaultMutableTreeNode n)

boolean isNodeAncestor(TreeNode n)

boolean isNodeChild(TreeNode n)

boolean isNodeDescendant(DefaultMutableTreeNode n)

Les feuilles :

DefaultMutableTreeNode getFirstLeaf()

DefaultMutableTreeNode getLastLeaf()

DefaultMutableTreeNode getNextLeaf()

DefaultMutableTreeNode getPreviousLeaf()

Réponse à la sélection d'un nœud  dans un JTree

Pour exécuter une action lorsqu’un nœud est sélectionné :

• Créer une instance de la classe TreeSelectionListener en redéfinissant la méthode public void valueChanged(TreeSelectionEvent e).
• Ajouter cette instance dans la liste des TreeSelectionlistener du JTree.

monArbre.addTreeSelectionListener( new TreeSelectionListener(){
   public void valueChanged(TreeSelectionEvent e){
      DefaultMutableTreeNode lenoeud = 
	     (DefaultMutableTreeNode)monArbre.getLastSelectedPathComponent();
      // pour afficher le chemin de 
      // ce noeud vers la racine de l’arbre
      String s = lenoeud .toString();
      while(!lenoeud.isRoot()) {
          lenoeud = (DefaultMutableTreeNode)
          lenoeud.getParent();
          s = lenoeud .toString() + s;
      }
      statusBar.setText(s);
   }
});

Personnalisation des icônes

On peut modifier les différentes icônes de la façon suivante :

JTree monArbre ...
DefaultTreeCellRenderer renderer = 
      new DefaultTreeCellRenderer();
renderer.setOpenIcon(icône pour un sous-arbre déployé);
renderer.setClosedIcon(cône pour un sous-arbre fermé);
renderer.setLeafIcon(icône de feuille);
monArbre.setCellRenderer(renderer);

Exemples

Visualiser la hiérarchie de fichiers

DefaultMutableTreeNode racine = 
         new DefaultMutableTreeNode("");DefaultTreeModel tm ;

JTree  monArbreF ;
// construction de la liste des lecteurs
File[] lecteurs = File.listRoots();
for (int i = 0; i < lecteurs.length; ++i){
   DefaultMutableTreeNode nouveau = 
       new DefaultMutableTreeNode(lecteurs[i].toString());
   racine.add(nouveau);
}
tm = new DefaultTreeModel(racine);
monArbreF = new JTree(tm);
// modification du rendu de l’arbre
DefaultTreeCellRenderer renderer = new DefaultTreeCellRenderer();
renderer.setOpenIcon(
      new ImageIcon(getClass().getResource("/jtree/ouvert.gif")));
renderer.setClosedIcon(
      new ImageIcon(getClass().getResource("/jtree/ferme.gif")));
renderer.setLeafIcon(null);
renderer.setBorderSelectionColor(Color.RED);
renderer.setBackgroundSelectionColor(Color.WHITE);
renderer.setTextSelectionColor(Color.RED);
renderer.setFont(new Font("Comic sans ms",Font.BOLD, 14));
renderer.setTextNonSelectionColor(Color.BLUE);
monArbreF.setCellRenderer(renderer);
// déploiement du sous arbre d’un nœud sélectionné
monArbreF.addTreeSelectionListener( new TreeSelectionListener(){
   public void valueChanged(TreeSelectionEvent e) {
      DefaultMutableTreeNode lenoeud = 
        (DefaultMutableTreeNode)monArbreF.getLastSelectedPathComponent();
      if (lenoeud  == null)   
      return;
      developper(lenoeud );
   }
});

void developper(DefaultMutableTreeNode n) {
// construction du chemin depuis la racine
TreeNode[] paths = n.getPath();
String path = "";
for (int i = 0; i < paths.length; ++i)<
   if (paths[i].toString() != null)
      path += "\\" + paths[i];
   File f = new File(path.substring(1));
   // si le nœud  est un repertoire
   // contenant au moins un fichier
   // créer la liste des fichiers du répertoire
   if (f.isDirectory() && n.getChildCount() == 0) {
      File tf[] = f.listFiles();
      for (int i = 0; i < tf.length; ++i) {
          tm.insertNodeInto(
             new DefaultMutableTreeNode(tf[i].getName()), n, i);
          monArbreF.expandPath(
             new TreePath(paths));
      }
   }
}

Visualiser des expressions arithmétiques

Pour obtenir l'arbre ci-contre, nous définissons les 3 classes suivantes :

abstract public class Noeud extends DefaultMutableTreeNode {
   boolean deploye = false;
   public Noeud() {
      children = new Vector();
   }
   public void setExpanded(boolean b) {
      deploye = b;
   }
}

public class NoeudOperateur extends Noeud {
   public static final String MULTIPLICATION = "*";
    public static final String DIVISION = "/";
   public static final String ADDITION = "+";
   public static final String SOUSTRACTION = "-";
   String operateur;
   public NoeudOperateur() {
      this(ADDITION);
   }
   public NoeudOperateur(String operateur) {
      this.operateur = operateur;
      deploye =       false;
   }

   public String getOperateur() {
      return operateur;
   }
   public void setOperateur(Object o) {
      if (o instanceof String ) 
         if(estOperateur((String)o))
            this.operateur = (String) o;
         else throw new IllegalArgumentException(
                  "l'opérateur doit +, -, / ou * : "+o);
      else throw new IllegalArgumentException(
                 "l'opérateur doit être une chaîne"+
                 " de caractères : " + o + "  ");
   }
   boolean estOperateur(String s){
      return s.equals(NoeudOperateur.ADDITION)||
                    s.equals(NoeudOperateur.MULTIPLICATION)||
                    s.equals(NoeudOperateur.DIVISION)||
                    s.equals(NoeudOperateur.SOUSTRACTION);
   }
   public String toString() {
      ...
   }
}

public class NoeudEntier extends Noeud{
    Integer entier;
    public NoeudEntier(int i) {
       entier = new Integer(i);
    }
    public NoeudEntier(Integer i) {
       entier =i;
    }
    public String toString(){
       return entier.toString();
    }
    public void setVal(int v){
       entier = new Integer(v);
    }
 }

On peut alors construire un arbre :

DefaultMutableTreeNode rac = new DefaultMutableTreeNode();
NoeudOperateur racine = new NoeudOperateur(NoeudOperateur.ADDITION);
NoeudOperateur ng1 = new NoeudOperateur(NoeudOperateur.MULTIPLICATION);
NoeudOperateur ng2 = new NoeudOperateur(NoeudOperateur.SOUSTRACTION);
NoeudOperateur ng3 = new NoeudOperateur(NoeudOperateur.SOUSTRACTION);

ExpressionTreeModel leModele = new ExpressionTreeModel(rac);
leModele.insertNodeInto(new NoeudEntier(1), ng1, 0);
leModele.insertNodeInto(new NoeudEntier(2), ng1, 1);
leModele.insertNodeInto( ng3, ng2, 0);
leModele.insertNodeInto( new NoeudEntier(4), ng2, 1);
leModele.insertNodeInto( new NoeudEntier(3), ng3, 0);
leModele.insertNodeInto( new NoeudEntier(5), ng3, 1);
leModele.insertNodeInto( ng1, racine, 0);
leModele.insertNodeInto( ng2, racine, 1);
leModele.insertNodeInto( ng3, ng2, 1);
leModele.insertNodeInto( racine, rac, 0);
JTree monArbre = new JTree(leModele);
monArbre.addTreeExpansionListener(new javax.swing.event.TreeExpansionListener(){
   public void treeExpanded(javax.swing.event.TreeExpansionEvent e){
      NoeudOperateur no = (NoeudOperateur);e.getPath().getLastPathComponent();
      no.setExpanded(true);
   }
   public void treeCollapsed(javax.swing.event.TreeExpansionEvent e) {
      NoeudOperateur no = (NoeudOperateur )e.getPath().getLastPathComponent();
      no.setExpanded(false);
   }
});

public class ExpressionTreeModel extends DefaultTreeModel {
   public ExpressionTreeModel(DefaultMutableTreeNode racine) {
      super(racine);
   }
   public void valueForPathChanged(TreePath chemin, Object nVal){
      Object[] p = chemin.getPath();
      Object n = p[p.length-1];
      if(p.length==1){// édition de la racine
          ((NoeudOperateur)n).setOperateur(nVal);
      }else{
         NoeudOperateur parent = (NoeudOperateur)p[p.length-2];
         if(n instanceof NoeudOperateur)// c'est un opérateur
           ((NoeudOperateur) n).setOperateur(nVal);
         else//c'est un entier
           ((NoeudEntier)n).setVal(Integer.parseInt((String)nVal));
      }
      this.nodeChanged((Noeud)n);
   }
}

Visualiser des arbres n-aires

Nous voulons faire une représentation d’un arbre nommé lArbre constitué de Nœuds dans un JTree dont le modèle s’appelle leModele. Un Nœud à trois attributs Info, filsAine et frere.

private void enArbre( DefaultMutableTreeNode parent, Noeud r) { 
   if (r != null) {
      DefaultMutableTreeNode fils = new DefaultMutableTreeNode(r.getInfo());
      parent.add(fils);
      enArbre(fils, r.getFilsAine());
      enArbre( parent, r.getFrere());
   }
}

Avec un appel initial :

enArbre(leModele.getRoot(), lArbre.getRacine());

Pour initialiser le modèle du JTree, il suffit d'enlever tous les fils de la racine :

((DefaultMutableTreeNode)leModele.getRoot()).removeAllChildren();

haut de la page