Ejemplo JTree En Java

Otra semana de las largas y otra demora en

publicar, sin embargo contino con la secuencia de componentes
Complejos Java Swing....

En esta ocasin vamos a trabajar con el JTree o tambin conocido

como Arboles.... Realizaremos un ejemplo sencillo mostrando el
procedimiento de creacin 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 jerrquico 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 comn lo vemos en nuestro computador (no importa cual
sea el sistema operativo, desde que se pueda trabajar de forma
grfica), si ingresamos a un explorador de carpetas vemos el rbol de
directorios que nos permite navegar mas facilmente.

Bsicamente nos permiten representar estructuras de datos

jerrquicas, cada elemento es un nodo al que le podemos definir su
funcin 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 programacin pueden variar.

El Ejemplo.
En esta ocasin 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 jerrquica con un directorio que representa la raz, un
directorio secundario que representa una rama y archivos
independientes que representan las hojas.

Nuestra aplicacin 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 Aplicacin.
La Aplicacin 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 rpida lo principal de nuestra clase....

Para crear el rbol adems de utilizar obviamente la Clase JTree,

tambin implementaremos la interface TreeSelectionListener, esta
nos permitir darle eventos a nuestros nodos (Mas adelante lo
veremos).........
1 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.
1 scrollPaneArbol = new JScrollPane();
2 scrollPaneArbol.setBounds(10, 80, 150, 130);
3 scrollPaneArbol.setViewportView(arbol);

Definimos un mtodo crearArbol() el cual sera el encargado de

contener todo lo necesario para la creacin del rbol, la creacin y
vinculacin de los nodos con los que vamos a trabajar.
1 private void crearArbol() {
/**Construimos los nodos del arbol que seran ramas u hojas*/
2
/**Definimos cual ser el directorio principal o la raiz de nuestro arbol*/
3 DefaultMutableTreeNode carpetaRaiz = new DefaultMutableTreeNode("Carpeta");
4 /**Definimos el modelo donde se agregaran los nodos*/
5 DefaultTreeModel modelo = new DefaultTreeModel(carpetaRaiz);
6 /**agregamos el modelo al arbol, donde previamente establecimos la raiz*/
arbol = new JTree(modelo);
7 /**definimos los eventos*/
8 arbol.getSelectionModel().addTreeSelectionListener(this);
9
10 /**Definimos mas nodos del arbol y se lo agregamos al modelo*/
11 DefaultMutableTreeNode carpeta2 = new DefaultMutableTreeNode("SubCarpeta");
12 DefaultMutableTreeNode archivo1 = new DefaultMutableTreeNode("Archivo1");
DefaultMutableTreeNode archivo2 = new DefaultMutableTreeNode("Archivo2");
13 DefaultMutableTreeNode archivo3 = new DefaultMutableTreeNode("Archivo3");
14 /**Definimos donde se agrega el nodo, dentro de que rama y que posicion*/
15 modelo.insertNodeInto(carpeta2, carpetaRaiz, 0);
16 modelo.insertNodeInto(archivo1, carpetaRaiz, 1);
modelo.insertNodeInto(archivo2, carpetaRaiz, 2);
17
18
19
20
21 /**Creamos las hojas del arbol*/
22 DefaultMutableTreeNode archivo4 = new DefaultMutableTreeNode("Archivo4");
23 DefaultMutableTreeNode archivo5 = new DefaultMutableTreeNode("Archivo5");
DefaultMutableTreeNode archivo6 = new DefaultMutableTreeNode("Archivo6");
24
25 modelo.insertNodeInto(archivo3, carpeta2, 0);
26 modelo.insertNodeInto(archivo4, carpeta2, 1);
27 modelo.insertNodeInto(archivo5, carpeta2, 2);
28 modelo.insertNodeInto(archivo6, carpeta2, 3);
29 }
30
31
Como vemos para la creacin de los nodos utilizamos la
claseDefaultMutableTreeNode 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 tambin la linea
1 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 mtodo valueChanged() definido por la

interfaz anterior, para implementar los eventos que necesitemos....
1 public void valueChanged(TreeSelectionEvent e) {
2
DefaultMutableTreeNode nodoSeleccionado;
3
nodoSeleccionad=(DefaultMutableTreeNode)arbol.getLastSelectedPathComponent();
4 eventosNodoSeleccionado(nodoSeleccionado);
5
6 s+="Ruta: ";
7 areaDeTexto.setText("\n");
8 areaDeTexto.setText("hola");
/**Obtenemos la ruta seleccionada*/
9 TreePath rutaSeleccionada = e.getPath();
10 Object [] nodos = rutaSeleccionada.getPath();
11 for (int i = 0; i < nodos.length ; i++){
12 Object nodo=nodos[i];
13 s+=nodo.toString() + " / ";
}
14 s+="\n";
15 areaDeTexto.setText(s);
16 }
17
18
19

En el mtodo anterior usamos 2 maneras de capturar los eventos, la

primera
usando el mtodo getLastSelectedPathComponent() el cual nos
permite obtener el nodo seleccionado, este se lo enviamos al
mtodoeventosNodoSeleccionado() que nos permitir definir el
panel asociado a nuestra seleccin.

La otra manera es mediante un objeto de tipo TreePath, este lo

obtenemos usando el evento definido al momento de seleccionar un
nodo, usandoe.getpath() obtenemos la ruta completa de nuestra
seleccin, 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 aplicacin.
Ejemplo JTable

Despus del break anterior sobre Eclipse y Netbeans, continuamos

con la secuencia de entradas sobre Java Swing, esta vez es el turno
de los componentes complejos, sin embargo cambiar la metodologa
de las entradas anteriores pues el tema lo amerita....

Se crear una entrada por cada componente complejo, con el fin de

exponer rapidamente y mediante ejemplos su
funcionamiento.....iniciamos con JTable....

Que es?
Un Jtable representa una tabla de datos con sus respectivas Filas y
Columnas, la informacin que se muestra en ella puede ser ingresada
tanto por nosotros como obtenida de una base de datos...

El Ejemplo.
Para el ejemplo presentaremos una ventana de registro de usuarios
donde a medida que se diligencia el formulario, se almacenan los
datos en la BD, desde all se obtendr la informacin y se mostrarn
los datos en 2 JTable.........
los JTable son aparentemente iguales, sin embargo la diferencia esta
en la forma como los llenamos...........el primero lo llenaremos
usando lgica de programacin, el segundo lo llenaremos con un
componenteDefaultTableModel.........

Este ejemplo es basado en la aplicacin realizada sobre el

Patrn Modelo Vista Controlador (El Script de la BD lo encuentran en
esa entrada), por lo tanto usaremos parte de la lgica
desarrollada.......para esta solo dejaremos la vista de registro,
agregandole los JTable con las que vamos a trabajar....

La Aplicacin.
 Como se mencion el ejemplo es simple,
tenemos una seccin de registro y una seccin donde mostramos
losJTable.
Por cuestiones de simplicidad no aplicaremos el MVC de lleno, sin
embargo seguimos usando los patrones DAO y VO para el manejo de
la informacin, el primero para comunicarnos con la BD y el segundo
para transportar nuestros datos.

En la clase Conexion tenemos los parmetros requeridos para

conectarnos a nuestra BD MySql, por ultimo usamos la clase Principal
para llamar a la VentanaRegistro donde presentamos la GUI y
llenamos las tablas que muestran la informacin.

Tabla Usuario Matriz de Datos.

Este JTable lo llenamos aplicando un poquito de lgica de
programacin, uno de los constructores de la clase JTable recibe 2
argumentos, el primero es la matriz con los datos a mostrar, el
segundo es un arreglo con los nombres de las columnas, por esa
razn lo que hacemos es obtener los datos de la BD, almacenarlos en
una lista y posteriormente pasarlos a la matriz, as como inicializar un
arreglo con los encabezados para finalmente mandrselos al
contructor.....
1 public void mostrarDatosUsandoLogica() {
String titulos[] = { "Codigo", "Nombre", "Edad", "Profesin","Telefono" };
2 String informacin[][] = obtieneMariz();// obtenemos la informacion de la BD
3
4 mitabla1 = new JTable(informacin, titulos);
5 mitabla1.setEnabled(false);
6 mitabla1.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
7 mibarra1.setViewportView(mitabla1);
}
8
9 private String[][] obtieneMariz() {
10 PersonaDao miPersonaDao = new PersonaDao();
11 /**
12
13
14 * llamamos al metodo que retorna la info de la BD y la almacena en la
15 * lista
16 */
17 ArrayList< PersonaVo > miLista = miPersonaDao.buscarUsuariosConMatriz();
18 /**
* como sabemos que son 5 campos, definimos ese valor por defecto para
19 * las columnas las filas dependen de los registros retornados
20 */
21 String informacion[][] = new String[miLista.size()][5];
22
23 for (int x = 0; x < informacion.length; x++) {
informacion[x][0] = miLista.get(x).getIdPersona() + "";
24 informacion[x][1] = miLista.get(x).getNombrePersona() + "";
25 informacion[x][2] = miLista.get(x).getProfesionPersona() + "";
26 informacion[x][3] = miLista.get(x).getEdadPersona() + "";
27 informacion[x][4] = miLista.get(x).getTelefonoPersona() + "";
28 }
return informacion;
29 }
30
31
32

Tabla Usando Table Model

Este JTable a nivel visual es igual que el anterior, sin embargo la
diferencia radica en la forma de obtener los datos, aqui usamos un
constructor sin argumentos y un objeto de
tipo DefaultTableModel el cual nos permite definir la forma como
llenamos la tabla, tanto en el caso de los encabezados como en la
informacin....... de esta manera el llenado de los datos se realiza
directamente por medio del objeto model que se envia como
parametro al metodo que consulta la BD....
1 private void mostrarDatosConTableModel() {
DefaultTableModel model;
2
model = new DefaultTableModel();// definimos el objeto tableModel
3 miTabla2 = new JTable();// creamos la instancia de la tabla
4 miTabla2.setModel(model);
5 model.addColumn("N Documento");
6 model.addColumn("Nombre");
model.addColumn("Edad");
7 model.addColumn("Profesin");
8 model.addColumn("Telefono");
9
10 miTabla2.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
11 miTabla2.getTableHeader().setReorderingAllowed(false);
12
13 PersonaDao miPersonaDao2 = new PersonaDao();
/**
14
15
16 * enviamos el objeto TableModel, como mandamos el objeto podemos
17 * manipularlo desde el metodo
*/
18 miPersonaDao2.buscarUsuariosConTableModel(model);
19 miBarra2.setViewportView(miTabla2);
20 }
21
22

Con esta tabla vemos que podemos utilizar otros elementos

compatibles con el componente JTable que nos pueden ahorrar
muchas lineas de cdigo, en este caso comparandolo con el anterior
nos ahorra un mtodo con un proceso de mas para obtener el mismo
resultado.....