http://www.abcdatos.com/tutoriales/tutorial/z3128.html
Jtable es una clase que me permite organizar una determinada información en tabla, esta difiere de una base de datos normal porque al utilizar Jtable tu puedes visualizar esta tabla, brindándole a el usuario organización de información, oportunidades de editar y cambiar el tamaño de las columna entre otras.
En principio se creo 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 par el manejo de datos, dando así al programador mucha mas 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".
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 esta 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.
Para un CellRendered con un TableModel sencillo, tal vez identificar clases pueda ser algo mas complejo que no pueda hacer, pero para uno un poco mas avanzado, esto seria muy fácil, y para esto cito el caso de un CHECK BOX(casilal de verificación) el cual es un componente grafico generado por Jtable después de que identifica una información tipo boolean, dándole así la apariencia de un cuadro rellenable, un check box no es mas que eso, una opción - que puede ser editable o no - que simplemente se chulea para indicar un si o un no ( si esta chuleado significa verdadero, sino lo esta indica falso), la cual el usuario solo puede colocar mediante un TableModel que sepa identificar clases.
UN LIST BOX?
En algunas oportunidades, para cierto tipo de información que deseamos que el usuario complete, necesitamos darle a el usuario, cierto tipo de opciones cosa que a través de un List Box tu puedes ofrecer al usuario el tipo de respuestas que tu desees que el selecciones, este tipo de organización de información ya no es tan sencillo como declarar una información tipo boolean, toca crear la lista.
http://www.gfc.edu.co/estudiantes/anuario/2002/sistemas/alejandra/Jtable.junk/c2.html
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";
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));
}
});
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 propositos
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().
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();
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 rectangulo sea visible
scrollPane.getViewport().scrollRectToVisible (r);
http://www.chuidiang.com/chuwiki/index.php?title=JTable#JTable
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. El ejemplo java1416.java muestra esta circunstancia.
import java.awt.*;
import java.awt.event.*;
import com.sun.java.swing.*;
import com.sun.java.swing.table.*;
import com.sun.java.swing.event.*;
// El Modelo de la Tabla es el que controla todos los
// datos que se colocan en ella
class ModeloDatos extends AbstractTableModel {
Object datos[][] = {
{"uno","dos","tres","cuatro"},
{"cinco","seis","siete","ocho"},
{"nueve","diez","once","doce"},
};
// Esta clase imprime los datos en la consola cada vez
// que se produce un cambio en cualquiera de las
// casillas de la tabla
class TablaListener implements TableModelListener {
public void tableChanged( TableModelEvent evt ) {
for( int i=0; i < j="0;" tabla =" new" panel =" new" frame =" new">
Una vez que se tiene un TableModel, ya sólo resta colocarlo en el constructor de JTable. Todos los detalles de presentación, edición y actualización están ocultos al programador. En este ejemplo, se coloca la JTable en un JScrollPane, por lo que es necesario un método especial en JTable.
Las tablas pueden soportar un comportamiento más complejo. En el ejemplo java1417.java, se utiliza un método para cargar un array de ocho columnas por un ciento de filas y, posteriormente, la tabla es configurada para que muestre solamente las líneas verticales y permita la selección simultánea de la fila y columna en que se encuentre la celda marcada.
import java.awt.*;
import java.awt.event.*;
import java.util.*;
import com.sun.java.swing.*;
import com.sun.java.swing.table.*;
class java1417 extends JPanel {
private JTable tabla;
private JScrollPane panelScroll;
private String titColumna[];
private String datoColumna[][];
public java1417() {
setLayout( new BorderLayout() );
// Creamos las columnas y las cargamos con los datos que van a
// aparecer en la pantalla
CreaColumnas();
CargaDatos();
// Creamos una instancia del componente Swing
tabla = new JTable( datoColumna,titColumna );
// Aquí se configuran algunos de los parámetros que permite
// variar la JTable
tabla.setShowHorizontalLines( false );
tabla.setRowSelectionAllowed( true );
tabla.setColumnSelectionAllowed( true );
// Cambiamos el color de la zona seleccionada (rojo/blanco)
tabla.setSelectionForeground( Color.white );
tabla.setSelectionBackground( Color.red );
// Incorporamos la tabla a un panel que incorpora ya una barra
// de desplazamiento, para que la visibilidad de la tabla sea
// automática
panelScroll = new JScrollPane( tabla );
add( panelScroll, BorderLayout.CENTER );
}
// Creamos las etiquetas que sirven de título a cada una de
// las columnas de la tabla
public void CreaColumnas() {
titColumna = new String[8];
for( int i=0; i < datocolumna =" new" iy="0;" ix="0;" ventana =" new">
Aunque el ejemplo contiene un array relativamente grande de datos, la clase JTable no manipula demasiado bien grandes cantidades de información, resultando un rendimiento bastante pobre cuando se sobrepasan los 2000 elementos. http://www.itapizaco.edu.mx/paginas/JavaTut/froufe/parte14/cap14-13.html
No hay comentarios:
Publicar un comentario