Java Swing 8: El JTree

Volviendo de nuevo con un nuevo post sobre Swing, esta vez os dejo un componente un poco más complicado de entender, el JTree. Su uso con el Swing Designer es bien simple de ponerlo en un frame y dibujar su interfaz, pero cuando entremos en su estructura que tenemos para manejarlo necesitaremos tener conocimientos de lo que es un Tipo Abstracto de Datos (TAD para los amigos), y en concreto lo que es un árbol. Lo que se puede hacer y cómo se estructura internamente lo supongo por entendido. Si no es el caso mejor empezar por ver ésto, sino lo de a continuación puede convertirse en un jeroglífico.

http://es.wikipedia.org/wiki/Tipo_de_dato_abstracto
Búsqueda en Google sobre TADs árboles

Construyendo el escenario

Para éste tutorial he utilizado Eclipse Juno y la versión 7 update 9 del JDK. Lo primero es crear, dentro de Eclipse, en la ventana del explorador de proyectos, un nuevo proyecto de Java. Luego crear un nuevo JFrame con el asistente de Eclipse y ya tenemos el esqueleto del programa listo para empezar. Yendo al diseñador de formularios del Swing Designer le añades un Absolute layout al formulario para poder posicionar los componentes donde quieras del formulario, y entonces para éste ejemplo le he añadido dos botón y un componente JTree. El componente JTree está a su vez dentro de un JScrollPane para que se muestren las barras de scroll si el contenido es más grande que lo que se puede ver. 

Antes de continuar te debe de haber quedado una ventana parecida a la de la imagen de inicio.

En la versión que tengo, cuando añado el JTree al Frame, se crea con un contenido sobre colores, deportes y comida. Éstos datos están en la propiedad model. De igual manera que algunos otros componentes, tenemos un modelo de árbol para usar el JTree. Por ejemplo, cuando usamos las listas tenemos modelos de listas, pues ahora son modelos de árbol. Si no establecemos el modelo, por defecto se construye con los elementos dichos. Vamos ahora con el TreeModel.

Creando el árbol

Vamos a usar dos tipos de datos para crear la estructura y ponerla en el JTree: el DefaultTreeModel y el  DefaultMutableTreeNode.
El botón para cargar el árbol lo he puesto para leer el árbol de directorios de tu disco duro. El tipo de datos TreeModel es el objeto que tiene internamente el JTree para manejar su estructura en árbol, nosotros vamos a usar una clase derivada de ésta porque se trata de una interfaz que no podemos usar directamente. Entonces tenemos el DefaultTreeModel que va a ser el tipo que usaremos.
Por otro lado tenemos que en cada elemento de un DefaultTreeModel es un DefaultMutableTreeNode. De forma que cada nodo de éstos puede tener a su vez hijos, formando así un árbol según tenga hijos o no. Para entenderlo ésto he pensado usar el árbol de directorio que todos conocemos.
Antes de seguir, explicando las dos funciones del JTree, si queremos crear una estructura de tipo árbol como por ejemplo:

nodoroot
– nodo1 (indice 0)
— nodo1.1 (indice 0)
— nodo1.2 (indice 1)
– nodo2 (indice 1)
— nodo2.1 (indice 0)
—  nodo2.2 (indice 1)

…lo que tenemos que hacer es que cada nodo es un elemento de tipo DefaultMutableTreeNode, y cada elemento se puede hacer hijo de otro. Es decir, lo único que hay que decirle al programa es de cada nodo cuál es su padre con la función insertNodeInto(nodo, padre, índice). Por ejemplo para la estructura anterior programaríamos:

DefaultMutableTreeNode nodoroot, nodo1, nodo11, nodo12, nodo2, nodo21, nodo22;
nodoroot = new DefaultMutableTreeNode("Éste es el nodo principal.");
nodo1 = new DefaultMutableTreeNode("nodo1");
nodo11 = new DefaultMutableTreeNode("nodo11");
nodo12 = new DefaultMutableTreeNode("nodo12");
nodo2 = new DefaultMutableTreeNode("nodo2");
nodo21 = new DefaultMutableTreeNode("nodo21");
nodo22 = new DefaultMutableTreeNode("nodo22");
arbol.setRoot(nodoroot);
arbol.insertNodeInto(nodo1, nodoroot, 0);
arbol.insertNodeInto(nodo2, nodoroot, 1);
arbol.insertNodeInto(nodo11, nodo1, 0);
arbol.insertNodeInto(nodo12, nodo1, 1);
arbol.insertNodeInto(nodo21, nodo2, 0);
arbol.insertNodeInto(nodo22, nodo2, 1);

En el ejemplo os he dejado algo más complicado, con una función recursiva que carga toda la estructura de directorios desde el directorio raiz “/”. Es decir, cuando le damos al botón tenemos el código siguiente:

btnCargarrbolDe.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {

DefaultTreeModel arbol = (DefaultTreeModel) tree.getModel();
DefaultMutableTreeNode nroot = new DefaultMutableTreeNode("Árbol de directorios");

arbol.setRoot(nroot);

CargaEstructuraDirectorios(arbol, nroot, "/");
}
});

… una vez dicho cual es el nodo principal (nroot), la función CargaEstructuraDirectorios lo hace todo. Puede tardar bastante, depende lo que tengas en tu ordenador o lo rápido que sea, déjalo ejecutarse hasta el final si lo quieres ver el resultado.
No voy a entrar en detalle sobre funciones recursivas o lectura de directorios. Lo que hay que saber es que lista un directorio, añadiendo todo lo que encuentra al árbol en su lugar adecuado, de maner que si encuentra un directorio lo añade también. Y acto seguido entra al directorio y lo lista, de manera que si algo de dentro también es un directorio vuelve a hacer lo mismo, es decir, vuelve a entrar en éste segundo directorio y lo lista también añadiendo de nuevo los elementos en el lugar adecuado. Así sucesivamente hasta listar todos los directorios y subdirectorios.
Todo ésto queda simple con una función recursiva que os dejo aquí:

private void CargaEstructuraDirectorios(DefaultTreeModel arbol, DefaultMutableTreeNode padre, String ruta) {
DefaultMutableTreeNode aux = null;

File archivo = new File(ruta);
File[] archivos = archivo.listFiles();

if (archivos != null) {
for (int i = 0; i < archivos.length; i++) {

aux = new DefaultMutableTreeNode(archivos[i].getName());
arbol.insertNodeInto(aux, padre, i);

if (archivos[i].isDirectory()) {
try {
CargaEstructuraDirectorios(arbol, aux, archivos[i].getAbsolutePath() + "/");
} catch (Exception e) {
System.out.println(e.getMessage());
}
}

}

}
}

Borrar un nodo

Igual que se añaden nodos, también se pueden borrar. Usando la función removeNodeFromParent que se usa en el ejemplo. Con un botón simple. No sólo podemos borrar un nodo, también podemos borrarlo de un sitio y ponerlo en otro, reordenando nuestro árbol, modificándolo, o lo que necesitemos. Pero con añadir o borrar tenemos lo básico para empezar…

Click, empieza el juego

Ahora se complica, pero empieza el juego xD ¿cómo hacer algo cuando hacemos click en un elemento del árbol? Haciendo click derecho con el ratón en el JTree añadimos el capturador de eventos que vamos a usar para hacer álgo cuando el usuario hace click en el JTree:

Eclipse, de nuevo nos genera el código esqueleto siguiente:

final JTree tree = new JTree();
tree.addTreeSelectionListener(new TreeSelectionListener() {
public void valueChanged(TreeSelectionEvent e) {
DefaultMutableTreeNode nseleccionado = (DefaultMutableTreeNode) tree.getLastSelectedPathComponent();
JOptionPane.showMessageDialog(frame, nseleccionado.getPath());
}
});

Se pueden capturar otros eventos. Y bueno, ya la imaginación o lo que necesitemos entra en juego para desarrollar lo que necesitemos. Con las funciones principales que nos proporcina el DefaultMutableTreeNode pordemos hacer lo que queramos. Podemos tener varios árboles y ponerlos en el JTree cuando queramos uno u otro, podemos recorrer los nodos por los índices, podemos saber cuál es el nodo principal con la función .getRoot, saber cuántos hijos tiene un nodo con .getChildCount, etcétera…
No hay más que curiosear para qué sirven las funciones proporcionadas, como podemos ver en la imagen siguiente del Eclipse:

Hay que saber que cuando hacemos cambios en la estructura de árbol, éstos automáticamente se visualizan en el JTree, con lo que sólo tenemos que centrarnos en el árbol.
Para más información me remito de nuevo a la documentación oficial:

Códigos del ejemplo

En el ejemplo he comentado algunas cosas más. Aquí están en descarga directa los códigos fuentes. Hay un .jar, para ejecutarlo necesitas el JRE instalado, si quieres modificarlo, sólo necesitas un editor de texto ya que sólo hay un fichero .java y recompilarlo.
Todo el código comentado es el siguiente para el que no quiera descargarlo:

import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.EventQueue;

import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;
import javax.swing.event.TreeModelListener;
import javax.swing.JButton;
import javax.swing.JTree;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.MutableTreeNode;
import javax.swing.tree.TreeModel;
import javax.swing.tree.TreePath;

import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.io.File;
import javax.swing.JScrollPane;
import javax.swing.event.TreeSelectionListener;
import javax.swing.event.TreeSelectionEvent;

// La clase principal
public class Principal extends JFrame {

// el panel contenedor
private JPanel contentPane;
// el JFrame
static Principal frame;

/**
* esta es la función que primero se ejecuta creando el JFRame y visualizándolo
*/
public static void main(String[] args) {
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
frame = new Principal();
frame.setVisible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
});
}

/**
* la creación del JFrame principal donde está programado todo lo de éste ejemplo
*/
public Principal() {
// título de ventana
setTitle("Java Swing 8 El JTree by Jnj");
// operación al cerra el JFrame
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
// dimensiones y posición en el escritorio
setBounds(100, 100, 450, 306);
// se crea el panel
contentPane = new JPanel();
// los bordes
contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
// se establece
setContentPane(contentPane);
contentPane.setLayout(null);

// se pone el botón en la ventana
JButton btnCargarrbolDe = new JButton(
"Cargar u00E1rbol de directorios");
btnCargarrbolDe.setBounds(10, 11, 200, 23);
contentPane.add(btnCargarrbolDe);

// las barras de escroll para el JTree
JScrollPane scrollPane = new JScrollPane();
scrollPane.setBounds(10, 45, 414, 206);
contentPane.add(scrollPane);

// el JTree
final JTree tree = new JTree();
// que captura el evento click
tree.addTreeSelectionListener(new TreeSelectionListener() {
public void valueChanged(TreeSelectionEvent e) {
// se obtiene el nodo seleccionado
DefaultMutableTreeNode nseleccionado = (DefaultMutableTreeNode) tree.getLastSelectedPathComponent();
// visualiza el path del nodo
JOptionPane.showMessageDialog(frame, nseleccionado.getPath());
}
});
// se pone el árbol en el panel de las barras de scroll
scrollPane.setViewportView(tree);

// aquí el botón que borra el último elemento de los primeros hijos
// es decir, desde el nodo root, borra sólo el último hijo
JButton btnBorrarltimoNodo = new JButton("Borrar u00FAltimo nodo");
btnBorrarltimoNodo.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {

DefaultTreeModel arbol = (DefaultTreeModel) tree.getModel();
DefaultMutableTreeNode padre = (DefaultMutableTreeNode) arbol.getRoot();
int numeroDeHijos = arbol.getChildCount(padre);

// borra el último hijo del padre
arbol.removeNodeFromParent((MutableTreeNode) arbol.getChild(
padre, numeroDeHijos - 1));
}
});
btnBorrarltimoNodo.setBounds(220, 11, 204, 23);
contentPane.add(btnBorrarltimoNodo);

// evento click del botón de carga del árbol
// simplemente añade el nodo root y llama a la función de carga
// para añadir todos los nodos hijos al nodo root
btnCargarrbolDe.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent arg0) {

DefaultTreeModel arbol = (DefaultTreeModel) tree.getModel();
DefaultMutableTreeNode nroot = new DefaultMutableTreeNode(
"Árbol de directorios");

arbol.setRoot(nroot);

CargaEstructuraDirectorios(arbol, nroot, "/");

}
});


}

// función recursiva que lista todos los directorios y subdirectorios
// a partir de una ruta, añadiéndolos a la estructura en árbol
private void CargaEstructuraDirectorios(DefaultTreeModel arbol,
DefaultMutableTreeNode padre, String ruta) {
DefaultMutableTreeNode aux = null;

File archivo = new File(ruta); // puntero al directorio de la ruta
File[] archivos = archivo.listFiles(); // lista todos los archivos de la ruta

// recorre lo que hay en la ruta
if (archivos != null) {
for (int i = 0; i < archivos.length; i++) {

// creando un nodo con cada cosa del directorio
aux = new DefaultMutableTreeNode(archivos[i].getName());
// inserta el nodo hijo
arbol.insertNodeInto(aux, padre, i);

// si encontramos un directorio volvemos a hacer lo mismo con sus hijos
if (archivos[i].isDirectory()) {
try {

// llamando recursivamente de nuevo a ésta misma función
CargaEstructuraDirectorios(arbol, aux,
archivos[i].getAbsolutePath() + "/");

} catch (Exception e) {
System.out.println(e.getMessage()); // por si acaso le he puesto un try xD
}
}

}

}
}

// termina la creación del frame
}

// fin de la clase

Un saludo.

Compartir..

Dejar un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *