java:jtable

1 de 4

http://www.magusoft.net/neotrials/pages/java/jtable.html

Table of Contents
Las tablas nos permiten tener tabulados de informacin que se vean organizados y que sean de utilidad para los
clientes. Las tablas son muy utilizadas en programas similares a excel, donde se deben tener rejillas de
informacin; o en programas de administracin donde pueden haber varios productos que tienen un conjunto
de caractersticas, o en programas de ventas, donde pueden haber varios vendedores con nmero de ventas y
con total vendido.

Creando un modelo esttico

Creando un modelo dinmico
Implementando el modelo dinmico
Usando el modelo
Guardar datos

Para agregar una tabla en NetBeans selecciona el icono de tabla de la paleta (que regularmente se encuentra a la derecha)
. Una vez que lo
hayas seleccionado agrgalo a la ventana principal. El JTable utiliza un DataModel para representar sus datos, de la misma manera que varios otros
componentes como JList.

Creando un modelo esttico

El modelo nos permite indicarle a la tabla qu informacin va a contener. Si slo queremos presentar informacin esttica (que nunca cambia) al cliente
entonces podemos usar un modelo esttico, para hacer esto vamos a hacer click en el atributo model que se encuentra en las propiedades.

Una vez que hicimos click aparecer una pantalla en la que podemos editar cmo queremos que se vea la tabla. En esta pantalla podemos seleccionar el
nemro de columnas, el nombre de las columnas e incluso podemos agregar algunos datos.

En la pantalla anterior podemos ver cmo manejar el nmero de columnas (con los botones de Insert, Delete o con los botones de +, -) y tambin
podemos ver una rejilla donde podemos poner el ttulo que aparece en la columna, el tipo de dato que va a guardar y si se puede editar o no.
Con esto podemos crear una tabla esttica que siempre va a iniciar con los mismos datos.

Creando un modelo dinmico

La mayora de las veces un usuario no va a querer una tabla esttica (en la que aunque pueda editar los valores no se muestren los valores que se haban
guardado previamente). Es por esto que es necesario crear un modelo dinmico. Para poder crear un modelo dinmico es necesario implementar la
interfaz TableModel que nos obliga a sobrecargar un gran nmero de mtodos:
getColumnClass(): Es un mtodo que

nos permite saber qu clase tiene guardada cada columna, esto es para que sean ms fciles de pintar para

java.
getColumnCount(): Es un mtodo que nos permite saber cuntas columnas tiene la tabla.
getColumnName(): Es un mtodo que nos permite saber el encabezado de la tabla para una cierta columna.
getRowCount(): Es un mtodo que nos permite saber cuntas filas tiene la tabla.
getValueAt(): Es un mtodo que nos devuelve el valor que se encuentra en la posicin pasada como parmetro.
isCellEditable(): Es un mtodo que nos devuelve verdadero si la celda puede ser modificada, o falso en caso contrario.
setValueAt(): Es un mtodo que nos permite cambiar el valor que se encuentra en la posicin pasada como parmetro mediante
usuario puede cambiar los datos dependiendo del mtodo isCellEditable()).

cdigo (el

25/06/2010 18:18

java:jtable

2 de 4

http://www.magusoft.net/neotrials/pages/java/jtable.html

getValueAt(): Es un mtodo que nos devuelve

indica getColumnClass() para esa columna.

el valor que est guardado en la celda pasada como parmetro, este valor va a ser de la clase que

Adems de todos los mtodos anteriores, la interfaz TableModel tiene un par de mtodos para manejar eventos (como por ejemplo, que el usuario haga
click, que edite una celda). Estos mtodos involucran agregar cdigo a nuestra clase que cuando modifique algn valor o que agregue nuevos datos tenga
que disparar eventos. Este cdigo, aunque no es muy complicado, no tendra ninguna utilidad (a menos que vayamos a escribir una manera de deshacer
acciones o algo similar), sin embargo como tenemos que implementar TableModel tendramos que implementarlos. Por suerte Java cuenta con un modelo
ya implementado (el que utilizan todas las tablas al ser creadas) que podemos utilizar para no implementar estos mtodos, entonces, en lugar de
implmentar la interfaz TableModel vamos a extender la clase DefaultTableModel que ya implementa la interfaz anterior.

Implementando el modelo dinmico

Normalmente las tablas slo crecen en una direccin (hacia abajo, aumentando el nmero de filas). Por ejemplo, en el reporte de empleados, es probable
que contratemos o despidamos empleados, por lo que vamos a tener que agregar ms filas, sin embargo sera raro que apareciera un nuevo atributo que
quisiramos manejar del empleado (y ms raro an que el cliente pudiera modificar el programa de tal manera que lo agregue). Entonces, como la
mayora de las tablas crecen en una sola dimensin(slo aumenta el nmero de filas) vamos a implementar un modelo en el que utilizando un ArrayList
que contiene arreglos vamos a manejar el crecimiento de la tabla (el ArrayList puede crecer, pero los arreglos no).
El ArrayList va a representar las filas de la tabla, y va a contener arreglos, que representan las columnas.

Primero veamos a crear una clase nueva, que extienda DefaultTableModel.

public class EditableTableModel
extends DefaultTableModel

Nuestro modelo debe tener alguna manera de almacenar los datos (ya vimos cmo vamos a resolver este problema) y adems debe contar con variables
de control que nos faciliten la tarea de saber cul es el nombre de las columnas, qu tipo de dato guarda cada columna (importante para poder guardar
nmeros o booleanos) y si la columna es editable (la mayora de las veces este parmetro va a ser verdadero, pero podran haber ocasiones en que
necesitramos que fuera falso).
private ArrayList<Object[]> data;
private
private
private
private

int numColumns;
String columnNames[];
Class classes[];
boolean editable[];

El constructor que recibe todos los parmetros debe de crear un tabla de datos en blanco y debe de leer los parmetros que manda el usuario. Como
vamos a tener varios constructores que reciban diferente nmero de parmetros debemos construir un mtodo que nos permita iniciar el objeto y llamarlo
desde todos los constructores, el mtodo sera algo similar a:
private void initComponents(String columnNames[], Class classes[], boolean editable[])
throws IllegalArgumentException {
if (columnNames.length != classes.length || classes.length != editable.length)
throw new IllegalArgumentException("The arrays passed as parameters must be of the same size");
data = new ArrayList<Object[]>();
this.numColumns = columnNames.length;
this.columnNames = columnNames;
this.classes = classes;
this.editable = editable;
}

La mayora de los mtodos son simples getters y setters (por ejemplo getRowCount() slo debe regresar el tamao de data con data.size(),
getValueAt() slo debe obtener el valor de la celda con data.get(row)[col]), por lo que estos mtodos no van a ser consultados con ms
detenimiento. Sin embargo, para permitir que la tabla pueda crecer debemos crear mtodos que nos permitan agregar o quitar filas. Estos mtodos deben
agregar o quitar arreglos de objetos de la lista de datos. Es decir:

25/06/2010 18:18

java:jtable

3 de 4

http://www.magusoft.net/neotrials/pages/java/jtable.html

public void addRow() {

int numRows = data.size();
Object[] row = new Object[numColumns];
data.add(row);
this.fireTableRowsInserted(numRows, numRows+1);
}

Y para remover va a ser muy similar:

@Override
public void removeRow(int row) {
data.remove(row);
this.fireTableRowsDeleted(row, row);
}

En los mtodos anteriores no est sucediendo mucho que no sepamos, excepto por los mtodos fireTableRowsInserted() y
fireTableRowsDeleted(). Estos dos mtodos le indican a la tabla (y la tabla se encarga de comunicarle a todos los componentes que dependan de ella)
que se agregaron o quitaron filas. Si no hiciramos esta llamada entonces no veramos los cambios hasta que modifiquemos los datos en la lista, que sera
cuando la tabla se dara cuenta de que el modelo cambi.
Otro mtodo que quizs sera importante implementar sera uno que nos permitiera agregar filas con datos, ya que muchas veces vamos a leer los datos
de un archivo y vamos a querer construir la tabla.
public void addRow(Object[] row) {
int numRows = data.size();
data.add(row);
this.fireTableRowsInserted(numRows, numRows+1);
}

Quizs tambin sera prudente crear un constructor que reciba una matriz de datos y de ah obtenga todos los datos para crear la tabla.

Usando el modelo
Construir el modelo es un proceso un poco abstracto y muchas veces no sabemos cmo estn sucediendo las cosas sino hasta que lo comenzamos a usar,
para poder usar nuestro modelo vamos a crear una clase de prueba que tenga una ventana con una tabla y dos botones de la siguiente manera:

Vamos a declarar el modelo en la parte de declaraciones globales, para que toda la interfaz grfica pueda acceder a ella (esto es conveniente porque as
los botones van a poder usarlo directamente, sin tener que sacarlo de la tabla pero podra considerarse una mala prctica de programacin).
private EditableTableModel model;

En el constructor de la ventana vamos a agregar el siguiente cdigo:

public EditableModelTest() {
initComponents();
String columnNames[] = { "Nombre",
"Edad",
"Telefono" };
Class classes[] =
{ String.class, Integer.class, String.class };
boolean editable[] =
{ true,
true,
true };
model = new EditableTableModel(columnNames, classes, editable);
tblEmployees.setModel(model);
}

Como podemos ver, el cdigo est creando tres arreglos, el primero tiene los nombres de las columnas (son tres columnas: nombre, edad y telfono), el
segundo arreglo es un arreglo de clases, que nos dice de qu tipo va a ser cada columna. Podemos utilizar cualquier clase de Java, pero regularmente
queremos utilizar String, Integer, Double, Float o Boolean, que son las clases para las que ya est creado un renderer y por lo tanto no tenemos que
preocuparnos por eso. Fjate que despus del nombre de la clase ponemos .class para que obtenga la clase. El ltimo arreglo es un arreglo de boolean y
nos dice si las columnas van a ser editables (en la mayora de los casos s).

25/06/2010 18:18

java:jtable

4 de 4

http://www.magusoft.net/neotrials/pages/java/jtable.html

Ahora vamos a implementar el botn para agregar filas:

private void btnAddRowActionPerformed(java.awt.event.ActionEvent evt) {
model.addRow();
}

Como nuestro modelo est bien implementado esto fue sencillsimo, ahora vamos a implementar el botn que borra las filas seleccionadas:
private void btnRemoveRowActionPerformed(java.awt.event.ActionEvent evt) {
int rows[] = tblEmployees.getSelectedRows();
model.removeRows(rows);
}

Igual de sencillo. Una vez que hayamos hecho todo esto nuestro programa debe permitir agregar y quitar filas y poner los datos que querramos adentro de
las filas.

Guardar datos
Una vez que los usuarios tengan la oportunidad de modificar la tabla van a agregar datos y van a querer guardar esos datos (imaginen que cada que abran
excel tienen que volver a poner todos los datos que haban puesto la vez anterior). Para guardar los datos vamos a crear un mtodo en el modelo que se
encargue de poner los datos en una matriz (para que sea ms fcil de manejar) y despus, utilizando este mtodo vamos a utilizar un par de ciclos para
guardar los datos en un archivo.
En el modelo vamos a agregar el siguiente mtodo:
public Object[][] getDataMatrix() {
int numRows = getRowCount();
int numCols = getColumnCount();
Object matrix[][] = new Object[numRows][numCols];
for (int rowIndex = 0; rowIndex < data.size(); rowIndex++) {
Object[] row = data.get(rowIndex);
for (int colIndex = 0; colIndex < row.length; colIndex++) {
Object object = row[colIndex];
matrix[rowIndex][colIndex] = object;
}
}
return matrix;
}

Y dentro de la interfaz grfica hay que crear un nuevo botn que sea el que guarda y debemos poner el siguiente cdigo:
private void btnSaveActionPerformed(java.awt.event.ActionEvent evt) {
try {
PrintWriter fileOut = new PrintWriter(new FileWriter("out.csv"));
Object[][] data = model.getDataMatrix();
for (int i = 0; i < data.length; i++) {
fileOut.print(data[i][0]);
for (int j = 1; j < data[i].length; j++) {
Object object = data[i][j];
if (object != null)
fileOut.print("," + object.toString());
else
fileOut.print(",");
}
fileOut.println();
}
fileOut.close();
JOptionPane.showMessageDialog(this, "Datos guardados");
} catch (IOException ex) {
JOptionPane.showMessageDialog(this, "Error al guardar!");
}
}

El mtodo anterior debera mostrar una ventana para seleccionar el archivo y debera de proporcionar informacin ms relevante en los errores, pero
para este ejemplo es suficiente para ver que los datos se guardan. Una vez que hagamos esto se va a crear un archivo llamado out.csv que puede ser
abierto por excel.

25/06/2010 18:18