Este documento describe el uso de JTable para visualizar datos de una base de datos. JTable permite organizar información en una tabla que puede editarse y modificarse. Se crea un TableModel que controla los datos y luego un JTable vinculado al TableModel para mostrar la información de forma visual. El documento también explica cómo hacer celdas editables o no y obtener datos seleccionados de la tabla.

1. ESCUELA PROFESIONAL DE
INGENIERÍA DE SISTEMAS Y TELEMÁTICA
CONTROL JTABLE CON BASE DE DATOS
ÁREA : Desarrollo de Software I.
DOCENTE : Ing. Marco Aurelio Porro Chulli.
ESTUDIANTES :
•Ocaña Bueno Lisbeth.
•Herrera Silva Carlos Jhónatan.
CICLO : V
GRUPO : “A”
Bagua Grande, Noviembre del 2016

2. JTable es una clase que me permite organizar una determinada
información en tabla, ésta difiere de una base de datos normal
porque al utilizar JTable podemos visualizar esta tabla, brindándole
al usuario organización de información, oportunidades de editar y
cambiar el tamaño de las columnas entre otras.
Un JTable representa una tabla de datos con sus respectivas Filas y
Columnas, la información que se muestra en ella puede ser
ingresada tanto por nosotros como obtenida de una base de datos.
Definición:
CONTROL JTABLE CON BASE DE DATOS:

3. INICIOS DE JTABLE:
En principio se creó la clase JTable para constituir un interfaz
ligado a bases de datos a través de "Java Database Connectivity"
(JDBC), y así evita la complejidad que existía para el manejo de
datos, dando así al programador mucha más facilidad a la hora de
trabajar con este tipo de información.
JTable le da al programador muchas facilidades, pues este posee
varias características que permiten hacer desde tablas con
información compleja y muy estructurada hasta tablas con
información sencilla y "básica".

4. La clase JTable controla como se presentan los datos, siendo el TableModel quien controla los datos
sí mismos. Para crear una JTable habrá pues que crear un TableModel antes, normalmente.
TableModel lo que hace es predeterminar ciertas características para el JTable es decir, que tú
puedes poner ciertos parámetros dentro de un TableModel y así no tener que determinarlos siempre.
TableModel es un programa que guarda los datos de la tabla para sí mismo, es decir, puede tener la
información de la tabla, pero estos datos son visualizados por el computador, es decir, para
visualizar una tabla el TABLEMODEL puede tener la información, pero sin el JTable no se puede
visualizar para el usuario.
TABLE MODEL:

5. ¿ES EDITABLE O NO?:
JTable tiene una característica muy
llamativa, este permite que el
programador pueda decidir que se
edita y que no, sin embargo, si el
programador dentro de su
programa o de su TABLEMODEL
no tiene determinado este aspecto,
JTable automáticamente hace
editable las celdas dentro de la
tabla.
Existen varias maneras de hacer
editable o no las celdas dentro de
la tabla, para ver estos comandos
tú te puedes dirigir a Dentro de las
celdas encontradas en una tabla
se puede permitir al usuario editar
o no editar según lo desee el
programador, esta propiedad se
puede arreglar desde el table
model o directamente y/o desde el
programa. JTable tiene la
propiedad de dejar editable las
celdas si no encuentra nada que
hable de esto.

6. JTable te brinda muchas facilidades para poder crear una table, y así mismo de llenarla con la
información que desees ( números, letras etc...) por lo que sencillamente dentro de una tabla está
automáticamente a través de la información debidamente separada - por ""(comillas) o por , (coma) -
es capaz de contabilizarlas y al mismo tiempo llenarla con la información que se le dio; es decir el
programador solo se debe encargar de poner los títulos de las tablas y así mismo de escribir la
información en el mismo orden en que desee que salga de acuerdo con los títulos y JTable se
encargara automáticamente de colocar la información donde se le indico.
¿Y LA INFORMACIÓN, Y LAS COLUMNAS?:

7. PROPIEDADES:
La forma más sencilla de usar un JTable y tener toda su funcionalidad es instanciar un DefaultTableModel y meterlo en el JTable, en el
constructor
DefaultTableModel modelo = new DefaultTableModel();
JTable tabla = new JTable(modelo);
Podemos añadir columnas directamente en el modelo
modelo.addColumn("etiqueta columna 1");
modelo.addColumn("etiqueta columna 2");
Podemos añadir datos directamente en el modelo, así como borrarlos o modificarlos.
Object [] fila = new Object[2];
fila[0] = "dato columna 1";
fila[1] = "dato columna 3";

8. modelo.addRow ( fila ); // Añade una fila al final
modelo.setValueAt ("nuevo valor", 0, 1); // Cambia el valor de la fila 1, columna 2.
modelo.removeRow (0); // Borra la primera fila
Todo lo que hagamos se reflejará de inmediato en el JTable.
Obtener fila y columna del JTable en la que se hace click
A veces nos interesa seleccionar una fila del JTable para hacer algo con ella (sacar un menú, recoger datos para mostrarlos en otro
sitio, etc).
Una forma de hacerlo es añadiendo un MouseListener al JTable, de esta manera
tabla.addMouseListener(new MouseAdapter()
{
public void mouseClicked(MouseEvent e)
{
int fila = tabla.rowAtPoint(e.getPoint());
int columna = tabla.columnAtPoint(e.getPoint());
if ((fila > -1) && (columna > -1))
System.out.println(modelo.getValueAt(fila,columna));
}
});

9. Hemos añadido un MouseAdapter para no tener que implementar todos los métodos del MouseListener.
Con el método tabla.rowAtPoint() es posible enterarnos en qué fila de del JTable ha ocurrido el evento del ratón (el click en
este caso). Para ello basta llamar a este método pasándole las coordenadas x,y del evento de ratón, que se obtienen con
el método e.getPoint().
Una vez que sabemos la fila, debemos comprobar si es mayor que -1. El método rowAtPoint() nos devuelve -1 si
pinchamos en el JTable, pero fuera de cualquier fila. Es el caso de que el JTable tenga un tamaño en pixels superior al que
le corresponde según su número de filas.
Lo mismo vale para columnAtPoint().
Una vez que tenemos la fila y sabemos que no es -1, es fácil a través del modelo obtener los datos correspondientes. En
este caso se escribe por pantalla con un System.out.prinln() el valor de la fila y columna que se ha seleccionado.
Hacer que una celda del JTable no sea editable.
Si usamos DefaultTableModel las celdas del JTable son editables por defecto. A veces esto no nos interesa y JTable no
tiene métodos para impedirlo. La forma de decidir qué celdas son o no editables es hacer nuestro propio modelo de datos,
nuestro TableModel. La forma sencilla de hacerlo es heredar de DefaultTableModel y redefinir el método isCellEditable()
para que sirva a nuestros propósitos.

10. public class MiModelo extends DefaultTableModel
{
public boolean isCellEditable (int row, int column)
{
// Aquí devolvemos true o false según queramos que una celda
// identificada por fila,columna (row,column), sea o no editable
if (column == 3)
return true;
return false;
}
}
En este ejemplo, hemos creado nuestro propio modelo de datos que hace que la columna 4 (los índices empiezan en cero) de la
tabla sea editable y el resto no. Ahora simplemente instanciamos el JTable usando este modelo y rellenamos los datos igual que
antes.
MiModelo modelo = new MiModelo();
JTable tabla = new JTable(modelo);
Cambiar el tipo de dato con DefaultTableModel
DefaultTableModel por defecto le dice al JTable que todos los datos que tiene son Object. A veces, porque queramos cambiar el
TableCellRenderer o cualquier otro motivo, nos interesa que determinadas columnas se consideren como Boolean, como Integer o
cualquier otro tipo de dato.
Para modificar esto, tenemos que crearnos nuestro propio modelo de Datos. La forma más sencilla es heredar de DefaultTableModel
y redefinir el método getColumnClass().

11. public class MiModelo extends DefaultTableModel
{
/** Primera columna Boolean, segunda Integer y el resto Object */
public Class getColumnClass(int columna)
{
if (columna == 0) return Boolean.class;
if (columna == 1) return Integer.class;
return Object.class;
}
}
En el ejemplo se ha hecho que la primera columna sea de Boolean, la segunda de Integer y el resto de Object.
Una cosa curiosa de los Boolean, es que el JTable al pintarlos los pone como JCheckBox.
Hacer visible una fila concreta del JTable dentro de un JScrollPane
Para que un JTable tenga barras de scroll y tenga una "cabecera" con las etiquetas de las columnas, es necesario meterla en un
JScrollPane. Esto se puede hacer de dos formas.
JTable tabla = new JTable();
JScrollPane scroll = new JScrollPane(tabla);
o bien
JTable tabla = new JTable();

12. JScrollPane scroll = new JScrollPane();
scroll.setViewportView(tabla);
es bastante habitual al principio equivocarse y usar el método add(), que NO funcionará correctamente
JTable tabla = new JTable();
JScrollPane scroll = new JScrollPane();
// Esto NO funciona.
scroll.add(tabla);
Cuando
tenemos un JTable metido dentro de un JScrollPane, a veces queremos que las barras de scroll se desplacen para que una
determinada celda sea visible.
No conozco una forma inmediata de hacerlo, pero una posible solución es esta.
// Nos devuelve la posición en pixels de una celda en fila,columna
Rectangle r = tabla.getCellRect( fila, columna, true);
// Mueve el scroll para que el rectángulo sea visible
scrollPane.getViewport().scrollRectToVisible (r);
La JTable controla cómo se presentan los datos, siendo el TableModel quien controla los datos en sí mismos. Para crear una JTable
habrá pues que crear un TableModel antes, normalmente. Se puede implementar, para ello, el interfaz TableModel, pero es mucho
más simple heredar de la clase ayuda AbstractTableModel.

13. EJEMPLO:
public class Ejm1_LlenarJTableDesdeDataBase extends JFrame{
DefaultTableModel dtmEjemplo;
JTable tblEjemplo;
JScrollPane scpEjemplo;
public Ejm1_LlenarJTableDesdeDataBase()
{
tblEjemplo = new JTable();
scpEjemplo= new JScrollPane();
//Llenamos el modelo
dtmEjemplo = new DefaultTableModel(null,getColumnas());
setFilas();
tblEjemplo.setModel(dtmEjemplo);
scpEjemplo.add(tblEjemplo);
this.add(scpEjemplo);
this.setSize(500, 200);
scpEjemplo.setViewportView(tblEjemplo);
setDefaultCloseOperation(javax.swing.WindowConstants.DISPOSE_ON_CLOSE);
}
//Encabezados de la tabla
private String[] getColumnas()
{

14. String columna[]=new String[]{"Columna1","Columna2","Columna3"};
return columna;
}
private void setFilas()
{
//Conectar a PostgreSQL
Ejm1_ConectarPostgreSQL cnndb = new Ejm11_ConectarPostgreSQL();
CachedRowSet crs = cnndb.Function("SELECT deptno, dname, loc FROM dept");
Object datos[]=new Object[3];
//Numero de columnas de la tabla
try {
while (crs.next()) {
for (int i = 0; i < 3; i++) {
datos[i] = crs.getObject(i + 1);
}
dtmEjemplo.addRow(datos);
}
crs.close();
} catch (Exception e)
}
}
public static void main(String args[]) {
Ejm1_LlenarJTableDesdeDataBase obj1 = new
Ejm1_LlenarJTableDesdeDataBase();
obj1.setVisible(true);
}
}

15. CONCLUCIÓN:
Existe una clase llamada JTable que permite crear objetos con forma de tabla.
Estos objetos son ideales para mostrar el contenido de las tablas de una base de datos,
aunque pueden ser usados de forma independiente también para mostrar cualquier tipo de
datos.
Los objetos del tipo JTable contienen un modelo de datos de tipo DefaultTableModel.
Cada vez que se quiera trabajar con una tabla será necesario construir su modelo y
asignárselo a la tabla.
Cada vez que se quiera modificar de alguna forma los datos de una tabla, será necesario
acceder a su modelo y trabajar con él.
A través del modelo de una tabla podemos añadir nuevas filas a la tabla, eliminar filas,
extraer datos de las celdas de la tabla o añadir datos a las celdas de la tabla.
La creación de tablas se convierte en una tarea sencilla cuando comenzamos a conocer las
clases auxiliares que la acompañan para mejorar su rendimiento y eficiencia; la finalidad de
este trabajo de investigación es precisamente empezar a familiarizarse con estas clases.