Ejemplo JTree En Java

Otra semana de las largas y otra demora en publicar, sin embargo continúo con la secuencia de componentes Complejos Java Swing....

En esta ocasión vamos a trabajar con el JTree o también conocido como Arboles.... Realizaremos un ejemplo sencillo mostrando el procedimiento de creación y le daremos un uso simple sin mayores complicaciones.

Que es?

El Jtree es uno de los componentes complejos aveces mas dificiles de entender y por su  "grado de complejidad" muchas veces evitado por algunos....... representa un árbol jerárquico que podemos mostrar en nuestras aplicaciones, se compone de nodos a los que le podemos vincular eventos o acciones dependiendo de nuestras necesidades.

Para que sirve?

Un Jtree puede ser utilizado para muchas cosas, principalmente se utilizan para mostrar rutas de directorios, un ejemplo común lo vemos en nuestro computador (no importa cual sea el sistema operativo, desde que se pueda trabajar de forma gráfica), si ingresamos a un explorador de carpetas vemos el árbol de directorios que nos permite navegar mas facilmente.

Básicamente nos permiten representar estructuras de datos jerárquicas, cada elemento es un nodo al que le podemos definir su función y sus eventos independientes.

En Java podemos hacer casi cualquier cosa con este componente, sin embargo dependiendo de lo que necesitemos el grado de dificultad y los conocimientos en programación pueden variar.

El Ejemplo.

En esta ocasión y como es normal, vamos a hacer un ejemplo simple, no vamos a profundizar mucho en el componente, tan solo usaremos lo necesario para crear nuestro árbol y que se entienda su funcionamiento.

La aplicacion mostrará un árbol en el que evidenciaremos la estructura jerárquica con un directorio que representa la raíz, un directorio secundario que representa una rama y archivos independientes que representan las hojas.

Nuestra aplicación permitirá mostrar un JPanel diferente por cada archivo de nuestro árbol, esto nos será muy útil si queremos simular un explorador como el mostrado anteriormente, donde al seleccionar un directorio se muestra su contenido, adicionalmente veremos en un JTextArea la ruta de directorios recorrida......... Veamos

La Aplicación.

La Aplicación es muy simple, contaremos con una Clase Principal y una Clase Ventana, la primera clase sera desde donde realizamos el llamado a la ventana del sistema mostrada anteriormente...... veamos de forma rápida lo principal de nuestra clase....

Para crear el árbol además de utilizar obviamente la Clase JTree, también implementaremos la interface TreeSelectionListener, esta nos permitirá darle eventos a nuestros nodos (Mas adelante lo veremos).........

public class Ventana extends JFrame implements TreeSelectionListener {

Adicionalmente vamos a utilizar un JScrollPane donde almacenaremos nuestro árbol, esto es importante ya que si nuestro árbol es muy grande necesitamos un contenedor que permita su uso facilmente.

scrollPaneArbol = new JScrollPane();
scrollPaneArbol.setBounds(10, 80, 150, 130);
scrollPaneArbol.setViewportView(arbol);

Definimos un método crearArbol() el cual sera el encargado de contener todo lo necesario para la creación del árbol, la creación y vinculación de los nodos con los que vamos a trabajar.

private void crearArbol() {
/**Construimos los nodos del arbol que seran ramas u hojas*/
/**Definimos cual será el directorio principal o la raiz de nuestro arbol*/
  DefaultMutableTreeNode carpetaRaiz = new DefaultMutableTreeNode("Carpeta");
 /**Definimos el modelo donde se agregaran los nodos*/
  DefaultTreeModel modelo = new DefaultTreeModel(carpetaRaiz);
 /**agregamos el modelo al arbol, donde previamente establecimos la raiz*/
 arbol = new JTree(modelo);
 /**definimos los eventos*/
 arbol.getSelectionModel().addTreeSelectionListener(this);
        
 /**Definimos mas nodos del arbol y se lo agregamos al modelo*/
 DefaultMutableTreeNode carpeta2 = new DefaultMutableTreeNode("SubCarpeta");
 DefaultMutableTreeNode archivo1 = new DefaultMutableTreeNode("Archivo1");
 DefaultMutableTreeNode archivo2 = new DefaultMutableTreeNode("Archivo2");
 DefaultMutableTreeNode archivo3 = new DefaultMutableTreeNode("Archivo3");
 /**Definimos donde se agrega el nodo, dentro de que rama y que posicion*/
 modelo.insertNodeInto(carpeta2, carpetaRaiz, 0);
 modelo.insertNodeInto(archivo1, carpetaRaiz, 1);
 modelo.insertNodeInto(archivo2, carpetaRaiz, 2);

 /**Creamos las hojas del arbol*/
 DefaultMutableTreeNode archivo4 = new DefaultMutableTreeNode("Archivo4");
 DefaultMutableTreeNode archivo5 = new DefaultMutableTreeNode("Archivo5");
 DefaultMutableTreeNode archivo6 = new DefaultMutableTreeNode("Archivo6");
        
 modelo.insertNodeInto(archivo3, carpeta2, 0);
 modelo.insertNodeInto(archivo4, carpeta2, 1);
 modelo.insertNodeInto(archivo5, carpeta2, 2);
 modelo.insertNodeInto(archivo6, carpeta2, 3);
}

Como vemos para la creación de los nodos utilizamos la clase DefaultMutableTreeNode asi como una clase DefaultTreeModel el cual sera el modelo donde agregaremos cada uno de estos, definiendo allí la estructura de directorios y archivos con los que vamos a trabajar..... Vemos también la linea

arbol.getSelectionModel().addTreeSelectionListener(this);

donde vinculamos los eventos a nuestro árbol, esto gracias a que implementamos la interfaz TreeSelectionListener mencionada anteriormente.

Por ultimo utilizamos el método valueChanged() definido por la interfaz anterior, para implementar los eventos que necesitemos....

public void valueChanged(TreeSelectionEvent e) {

DefaultMutableTreeNode nodoSeleccionado;
nodoSeleccionad=(DefaultMutableTreeNode)arbol.getLastSelectedPathComponent();
eventosNodoSeleccionado(nodoSeleccionado);
 
 s+="Ruta: ";
 areaDeTexto.setText("\n");
 areaDeTexto.setText("hola");
 /**Obtenemos la ruta seleccionada*/
 TreePath rutaSeleccionada = e.getPath();
 Object [] nodos = rutaSeleccionada.getPath();
 for (int i = 0; i < nodos.length ; i++){
 Object nodo=nodos[i];
 s+=nodo.toString() + " / ";
 }
 s+="\n";
 areaDeTexto.setText(s);
}

En el método anterior usamos 2 maneras de capturar los eventos, la primera

usando el método getLastSelectedPathComponent() el cual nos permite obtener el nodo seleccionado, este se lo enviamos al método eventosNodoSeleccionado() que nos permitirá definir el panel asociado a nuestra selección.

La otra manera es mediante un objeto de tipo TreePath, este lo obtenemos usando el evento definido al momento de seleccionar un nodo, usando e.getpath() obtenemos la ruta completa de nuestra selección, esta ruta esta compuesta de los nodos de nuestro árbol, los cuales se almacenan en un arreglo de objetos que podemos recorrer y mostrarlos en el área de texto de nuestra aplicación.

Y una vez mas llegamos a un rápido final con un ejemplo simple que puede ser de mucha ayuda...........como se mencionó esta es una forma rápida y fácil de trabajar con nodos, espero mas adelante poder produndizar en este componente...... y espero que les pueda servir ;)

Descarga!!!

Les dejo el enlace de descarga por si lo quieren revisar ;).....está en Eclipse pero si usas NetBeans te interesará esta entrada con un vídeo paso a paso de como abrirlo en el... recuerden que es gratis, y nada cuesta opinar, compartir o agradecer :)

También te podría Interesar.

• Ejemplo JColorChooser
• Ejemplo Jtable
• Contenedores Java Swing.
• ¿Eclipse Vs Netbeans?
• Componentes de Texto Java Swing
• Configuración Ambiente de Desarrollo... Descarga de Eclipse 
• Instalando el Plugin JBoss Tools En Eclipse
• Menús Con Java Swing. 
• Clases en Java 
• Clases Abstractas

¿Hay algo que quieras anexar o comentar sobre esta entrada?  no dudes en hacerlo.....y si te gustó...... te invito a compartir y Suscribirte ingresando al botón "Participar en este sitio" para darte cuenta de mas entradas como esta ;)