Tutoriales
Enlaces
Licencia
Esta obra está bajo una licencia de Creative Commons.
Para reconocer la autoría debes poner el enlace https://old.chuidiang.org
En este tutorial vamos a ver un ejemplo sencillo de cómo usar el JTree en java.
El JTree es el componente java visual (como los botoncitos, listas, menús, etc) que nos permite visualizar un árbol. En él podemos ver el típico árbol de datos en el que podemos abrir cada uno de los nodos para ver qué tiene dentro, cerrarlos, etc. Similar al árbol de directorios que nos muestran algunas aplicaciones para elegir un fichero.
Aunque el JTree es muy configurable, en este tutorial sólo veremos como usarlo de una forma sencilla, usando las clases por defecto que java nos ofrece para ello.
Como en casi todos los componentes visuales de java, hay dos clases importantes implicadas.
Por un lado tenemos "la vista", que es la clase java que se ve. Esta clase es el JTree y es lo que se ve en la pantalla, en nuestra ventana.
Por otro lado tenemos el "modelo de datos". Esta clase de java puede ser cualquier clase que implemente la interface TreeModel, pero java nos ofrece ya implementada la clase DefaultTreeModel. Esta clase es la que contiene los datos que queremos visualizar en "la vista". Contiene los datos que visualizaremos en el JTree.
¿Qué datos admite el DefaultTreeModel?. Puesto que vamos a hacer un árbol, admite datos que se puedan asociar entre sí como padres e hijos. No valen datos cualesquiera. Esos datos deben implementar la interface TreeNode. Cualquier clase que implemente esta interface, tendrá métodos para interrogarle sobre quién es su padre, si tiene hijos, etc. Estos métodos será los que acabe usando JTree para saber qué debe pintar, quién es hijo de quién y quién es padre de quién.
Existe otro tipo de dato también importante, el MutableTreeNode. Este es igual que el anterior, pero además tiene métodos para modificar las asociaciones entre padres e hijos. Permite añadir nuevos hiijos a los padres, cambiar el padre de los hijos y cualquier otro tipo de indecencia que se nos ocurra. Si nuestro árbol va a cambiar sobre la marcha, nos interesa usar datos (nodos) que implementen esta interface.
Java nuevamente nos ofrece una clase que ya implementa MutableTreeNode y por tanto tiene todos los métodos necesarios para saber quién es hijo de quién y los métodos necesarios para cambiar estas asociaciones. Esta clase es DefaultMutableTreeNode. Tiene además un método intereseante, que es setUserObject(). Este método nos permite guardar dentro la información que queramos. Esta información será nuestro dato real, lo que realmente nos interesa. DefaultMutableTreeNode únicamente nos ahorrará escribir el código necesario para mantener asociaciones entre padres e hijos, además de hacer de almacén de nuestro dato.
Vamos a ir haciendo código para ver cómo usar todas estas clases. Trataremos de construir y construiremos el árbol del dibujo
Primero instanciamos nuestro modelo de datos, el DefaultTreeModel y la parte visual, el JTree. Metemos el primero dentro del segundo.
La clase DefaultTreeModel necesita en su constructor el nodo raíz del árbol, es decir, el dato que hace de padre de todos los demás, el de más alto nivel. Por ello, debemos instanciar este primer dato para poder construir el DefaultTreeModel.
Ese primer dato será un DefaultMutableTreeNode. A este DefaultMutableTreeNode podemos pasarle el dato que queramos bien a través del método que comentamos setUserObject(), bien a través del constructor. Nuestro dato será un simple String que diga "abuelo" y lo meteremos en el constructor.
El código quedaría así
DefaultMutableTreeNode abuelo = new DefaultMutableTreeNode("abuelo");
modelo = new DefaultTreeModel(abuelo);
JTree tree = new JTree(modelo);
En el árbol se mostrará el resultado de llamar a toString() de nuestro "user object". Como en nuestro caso es un simple String "abuelo", el método toString() de String devuelve "abuelo" y eso es lo que se verá como raíz del árbol.
Ahora sólo nos queda ir añadiendo el resto de los datos del árbol. Lo único que tenemos que hacer es ir creando los nodos, como DefaultMutableTreeNode. A cada uno de ellos meterle el dato que queramos, bien en el constructor, bien con el método setUserObject(). En nuestro caso usaremos un simple String con el texto que queremos que se muestre. Finalmente, hay que ir asociando estos datos.
El abuelo ya lo tenemos creado, así que el código de creación de los demás nodos puede ser este
DefaultMutableTreeNode padre = new DefaultMutableTreeNode("padre");
DefaultMutableTreeNode tio = new DefaultMutableTreeNode("tio");
DefaultMutableTreeNode hijo=new DefaultMutableTreeNode("hijo");
DefaultMutableTreeNode hija=new DefaultMutableTreeNode("hija");
Para asociar estos datos tenemos dos opciones.
La diferencia de hacerlo de una manera u otra es que JTree se entera automáticamente de cambios de DefaultTreeModel y los refleja automáticamente en pantalla, pero no se entera de los cambios en los DefaultMutableTreeNode y por tanto no los refresca en pantalla.
Si queremos refresco inmediato, debemos usar métodos de DefaultTreeModel. Si queremos hacer varios cambios sin ver como se van haciendo en pantalla, podemos usar los métodos de DefaultMutableTreeNode, pero debemos tener en cuenta que al final hay que provocar desde código el refresco del JTree, bien con un repaint(), bien con uno de los métodos fire...() de DefaultTreeModel.
Puesto que estamos haciendo un ejemplo simple y es más simple, usaremos el método insertNodeInto() para hacer la asociación. Este método lleva tres parámetros:
El código para estas asociaciones es sencillo:
modelo.insertNodeInto(padre,abuelo,0);
modelo.insertNodeInto(tio, abuelo, 1);
modelo.insertNodeInto(hijo, padre, 0);
modelo.insertNodeInto(hija, padre, 1);
Ya está. Esto construye el árbol de la figura inicial. En PruebaJTree.java puedes ver el ejemplo completo.
El siguiente paso es cambiar esos iconos tan feos que salen en el árbol por otros más horribles, pero que al menos sean de nuestra propia cosecha.