JTable con Base de Datos

JTABLE

Un JTable es un componente visual de Java que nos permite dibujar una tabla, de forma que en cada fila/columna de la tabla podamos poner el dato que queramos; un nombre, un apellido, una edad, un número, etc.

Definición Jtable

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.

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 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".

TABLE MODEL

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 tu 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 si mismo, es decir, puede tener la información de la tabla pero estos datos son los 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.

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 tu 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.

Y LA INFORMACIÓN, Y LAS COLUMNAS?.

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.

LLENAR UN JTABLE CON UNA BASE DE DATOS

Lo siguiente es un codigo en donde se llena un Jtable con Netbeans, pero haciéndolo mediante una base de datos... Solamente toca cambiar la conexion, el select y el nombre del Jtable

//Devuelve toda la tabla producto

public static DefaultListModel obtenerCodigos() {

DefaultListModel modelo = new DefaultListModel();

try {

DefaultListModel defaultListModel = new DefaultListModel();

int contador=1;

String codigo="";

ResultSet resultados = conexion.ejecutarConsulta("SELECT * FROM producto");

//Este while es quien llega la lista para luego utilizarla llenando el Jtable

while(resultados.next()){

codigo= resultados.getString(1);

defaultListModel.addElement(contador+". "+codigo);

contador++;

}

conexion.cerrarConsulta();

return defaultListModel;

} catch (SQLException ex) {

return modelo;

}

}

//aqui se llena el Jtable con lo que retorno lo anterior

this.listMarcadores.setModel(obtenerCodigos());

CAMPOS

 

Resumen de los Campos
Campo		Descripción
static int	AUTO_RESIZE_ALL_COLUMNS	Proporciona el Cambio de tamaño de Todas las columnas durante las operaciones de cambio de tamaño
static int	AUTO_RESIZE_LAST_COLUMN	Durante todas las operaciones de cambio de tamaño, aplica el ajuste únicamente a la última columna
static int	AUTO_RESIZE_NEXT_COLUMN	Cuando una columna se ajusta, este campo ajusta la siguiente, de forma opuesta
static int	AUTO_RESIZE_NEXT_OFF	Utiliza una barra de desplazamiento para ajustar el ancho de la columna
static int	AUTO_RESIZE_SUBSEQUENT_COLUMNS	Cambia las columnas siguientes para preservar el ancho total; este es el comportamiento por omisión
protected boolean	autoCreateColumnsFromModel	Si tiene el valor de true, la tabla consulta al TableModel para construir el conjunto de columnas
protected int	AutoResizeMode	Determina si la tabla cambia automáticamente el tamaño de la anchura de sus columnas para ocupar el ancho total de la tabla
protected TableCellEditor	cellEditor	Un objeto que sobrescribe la celda actual y permite al usuario cambiar sus contenidos
protected boolean	cellSelectionEnabled	Obsoleto desde la versión 1.3
protected TableColumnModel	columnModel	El TableColumnModel de la tabla
protected TableModel	dataModel	El TableModel de la table
protected Hashtable	defaultEditorsByColumnClass	Una tabla de objetos que muestra y edita el contenido de cada celda,indexado por clase como esta declarado en getColumnClass en la interface TableModel
protected Hashtable	defaultRenderersByColumnClass	Una tabla de objetos que muestra el contenido de cada celda,indexado por clase como esta declarado en getColumnClass en la interface TableModel
protected int	editingColumn	Identifica la columna de la celda que esta siendo editada
protected int	editingRow	Identifica la Fila de la celda que esta siendo editada
protected Component	editorComp	El componente que procesa la edición
protected Color	gridColor	El color de la rejilla(grid)
protected Dimension	preferredViewportSize	Utilizado por la interface Scrollable para determinar el area inicial visible
protected int	rowHeight	La altura -en pixeles- de las filas de la tabla
protected int	rowMargin	La altura -en pixeles- del margen entre las celdas en cada fila
protected boolean	rowSelectionAllowed	Devuelve true si se permite selección de fila en esta tabla
protected Color	selectionBackground	El color de fondo de las celdas seleccionadas
protected Color	selectionForeground	El color de primer plano de las celdas seleccionadas
protected ListSelectionModel	selectionModel	El ListSelectionModel de la tabla; se utiliza para controlar las filas seleccionadas
protected boolean	showHorizontalLines	Las líneas horizontales se dibujan entre las celdas cuando el campo esta en true
protected boolean	showVerticallLines	Las líneas verticales se dibujan entre las celdas cuando el campo esta en true
protected JTableHeader	tableHeader	El JTableHeader que funciona con la tabla

 

CONSTRUCTORES

 

 

Constructores
Constructor	Descripción
JTable()	Construye un JTable() predeterminado
JTable(int numRows, int numColumns)	Construye un JTable()con numRows y numColumns de celdas vacías, utilizando DefaultTableModel
JTable(Object[][] rowData, Object[] columnNames)	Construye un JTable() visualizando los valores de rowData en una matriz bidimencional, utilizando columnNames como nombres para las columnas
JTable(TableModel dm)	Construye un JTable() con dm como modelo de tabla, un modelo de columna predeterminado y un modelo de seleccion predeterminado
JTable(TableModel dm, TableColumnModel cm)	Construye un JTable() con dm como modelo de tabla, cm como modelo de columna y un modelo de seleccion predeterminado
JTable(TableModel dm, TableColumnModel cm, ListSelectionModel sm)	Construye un JTable() con dm como modelo de tabla, cm como modelo de columna y sm como modelo de selección
JTable(Vector rowData, Vector columnNames)	Construye un JTable() para visualizar los valores del Vector de Vectores, rowData, con nombres de columnas dados en columnNames

Básicamente crear la tabla, cargarle el modelo y agregar la data, esto se hace con la finalidad de editar el modelo que es más flexible para utilizar solo la tabla como una especie de panel el cual contendrá los datos, en realidad lo que editamos es el modelo, en otras palabras es como hacer galletas, el molde es nuestro modelo, la data es la masa y la galleta es la tabla.

Quedando claros en esto (pienso yo) vamos con algunos truquillos importantes e imprescindibles. Para crear el modelo y agregárselo a la tabla.

DefaultTableModel modelo = new DefaultTableModel();

JTable tabla = new JTable(modelo);

·         Agregar columnas

modelo.addColumn("columna");

·         Agregar datos.

Object [] filas = new Object[2];

filas[0] = "dato columna 1";

filas[1] = "dato columna 2";

modelo.addRow ( filas );

·         Borrar datos.

modelo.removeRow(FILA);

·         Modificar.

modelo.setValueAt ("nuevo dato", fila, columna);

·         Obtener el valor donde se hace click.

public void mouseClicked(MouseEvent e) {

int fila = tabla.rowAtPoint(evt.getPoint());

int columna = tabla.columnAtPoint(evt.getPoint());

if ((fila > -1) && (columna > -1))

System.out.println(modelo.getValueAt(fila,columna));

}

·         Hacer que la celda no se edite.

public boolean isCellEditable (int row, int column){

if (column == 3)

return true;

return false;

}

·         Deshabilitar el movimiento de columnas.

JTable tabla = new JTable();

tabla.getTableHeader().setReorderingAllowed(false);

·         Cambiar el tipo de dato.

public Class getColumnClass(int columna) {

if (columna == 0) return Boolean.class;

if (columna == 1) return Integer.class;

return Object.class;

}

·         Agregarle un Scroll.

JTable tabla = new JTable();

JScrollPane scroll = new JScrollPane(tabla);

JTable tabla = new JTable();

JScrollPane scroll = new JScrollPane();

scroll.setViewportView(tabla);

 

JTABLE Y DEFAULTTABLEMODEL

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);

Aunque en realidad esto no es estrictamente necesario, porque un JTable por defecto ya tiene dentro un DefaultTableModel, así que también sería válido esto otro

JTable tabla = new JTable();

DefaultTableModel modelo = (DefaultTableModel)tabla.getModel();

Una vez que tenemos el modelo, de una u otra forma, 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 JTableusando 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 JSCROOLPANE

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);

EJEMPLO DE TABLEMODEL EN JTABLE

Vamos a ver cómo utilizar un JTable de java. Pudes ver un applet de ejemplo y el código fuente.

Un JTable es un componente visual de java que nos permite dibujar una tabla, de forma que en cada fila/columna de la tabla podamos poner el dato que queramos; un nombre, un apellido, una edad, un número, etc, etc.

Como muchos componentes de java, se ha seguido una separación modelo-vista . La vista es el componente visual que vemos en pantalla, el modelo es una clase que contiene los datos que luego se verán en pantalla. El modelo de datos únicamente contiene los datos, nosabe nada de quién va a visulizar los datos ni como.

La forma más rápida y sencilla

Aparte de usar otros constructores que hay en JTable, una de lasformas más rápidas y sencillas de utilizar un JTable teniendo toda su funcionalidad, consiste en instanciar como modelo de datos un DefaultTableModel y luego un JTable , pasándole el modelo en el constructor. El código quedaría:

DefaultTableModel modelo = new DefaultTableModel();
JTable tabla = new JTable (modelo);

A partir de ahora todo se maneja con el modelo. En cuanto añadamos, borremos o cambiemos datos del modelo, el JTable se enterará y actualizará automáticamente. El DefaultTableModel tiene todos los métodos necesarios para modificar datos en su interior, añadir filas o columnas y darle a cada columna el nombre que queramos

Vamos a hacer nuestro propio modelo de datos

El DefaultTableModel es un modelo genérico y puede no ser suficiente (o al menos, incómodo de usar) para nuestros propósitos.

Es bastante habitual el querer manejar la tabla como si fuera una lista, de forma que cada filacorresponde a una clase de datos y las columnas son los atributos de esaclase. Por ejemplo, queremos una lista de Persona y cada persona tiene unnombre, un apellido y una edad. Queremos pintar este lista en una tabla,de forma que tiene tres columnas (nombre, apellido y edad) y tantas filascomo Personas haya en la lista. A mi me gustaría tener un modelo alque le diga

modelo.anhadePersona (persona);

 y no un

modelo.setValueAt (fila, columna, persona.nombre);
columna++;
modelo.setValueAt (fila, columna, persona.apellido);
columna++;
modelo.setValueAt (fila, columna, edad);

y algo parecido para obtener o borrar una persona dentro del modelo.

Por ello, a veces esmás cómodo implementar nuestros propios modelos de tabla. Lacosa es fácil, únicamente debemos implementar la interfaceTableModel y luego poner además todos losmétodos que queramos, como el anhadePersona() o el damePersona() mencionados antes.

Una clase que implemente un TableModel debe redefinir los siguientes métodos:

class MiModelo implements TableModel
{
    public void addTableModelListener (TableModelListener l) {...}
    public Class getColumnClass (int columIndex) {...}
    public int getColumnCount() {...}
    public String getColumnName (int columnIndex) {...}
    public int getRowCount() {...}
    public Object getValueAt (int rowIndex, int columnIndex) {...}
    public boolean isCellEditable (int rowIndex, int columnIndex) {...}
    public void removeTableModelListener (TableModelListener l) {...}
    public void setValueAt (Object aValue, int rowIndex, int columnIndex)
}

Hay básicamente tres tipos de métodos:

• Métodos para manejo de suscriptores al modelo. Un suscriptor es cualquier clase que quiera enterarse de cambios en los datos del modelo. El JTable es un ejemplo claro. El JTable se suscribe a cambios de datos en el modelo y de esta forma, en cuanto cambiemos datos en el modelo, el JTable se entera y se repinta automáticamente la pantalla. En este grupo están los métodos addTableModelListener() y removeTableModelListener()
• Métodos para menejo de datos. Permiten obtener y cambiar datos dentro de la tabla. Son los métodos getValueAt() y setValueAt().
• El resto son métodos para obtener información de la tabla en sí misma, como número de filas, número de columnas, si una fila-columna es o no editable, nombre de la columna, etc.

Métodos para los suscriptores

Para implementar los métodos de los suscriptores necesitamos que nuestro modelo tenga una lista de suscriptores y únicamente hay que añadir o borrar suscriptores de esa lista. El código puede ser tan simple como esto:

class MiModelo implements TableModel
{
    public void addTableModelListener (TableModelListenerl) {
        suscriptores.add (l);
    }

    public void removeTableModelListener (TableModelListener l) {
        suscriptores.remove(l);< BR >     }

    private LinkedList suscriptores = new LinkedList();
}

Si en vez de implementar TableModel, heredamos de AbstractTableModel , ya tenemos esto implementado, además de otra serie de métodos que nos serán útiles más adelante.

Metodos para manejo de los datos

Para el manejode datos, sólo tenemos dos métodos. El que pone un dato enuna fila,columna y el que lo obtiene. Si seguimos con la idea de hacer unalista de personas, el código puede quedar como esto:

class MiModelo implements TableModel
{
    public void setValueAt (Object dato, int fila, int columna) {
         // Obtenemos la persona de la fila indicada
        Persona aux = (Persona)datos.get (fila);   
        switch (columna) {
           // Nos pasan el nombre.
           case 0:                                                  
               aux.nombre = (String)dato;
               break;
           // Nos pasan el apellido.
           case 1:                                                   
               aux.apellido = (String)dato;
               break;
           // Nos pasan la edad.
           case 2:                                                   
               aux.edad = ((Integer)dato).intValue();
               break;
        }

        // Aquí hay que avisar a los sucriptores del cambio.
        // Ver unpoco más abajo cómo.
    }

    public Object getValueAt (int fila, int columna) {
        // Obtenemos la persona de la fila indicada
        Persona aux = (Persona)datos.get (fila);      
        switch (columna) {
            // Nos piden el nombre
            case 0:                                                    
                return aux.nombre;
                break;
            // Nos piden el apellido
            case 1:                                                     
                return aux.apellido;
                break;
            // Nos piden la edad.
            case 2:                                                    
                return new Integer (aux.edad);
                break;
         }
         return null;
    }

    private LinkedList datos = new LinkedList();
}

Simplemente hemos declarado una lista de personas como atributo privado de la clase y hecho los switch necesarios para poner u obtener el campo concreto de Persona para la columna indicada. El Object recibido y devuelto para cada compo puede ser lo que nosotros queramos,pero para una fila,columna dada, debe ser del mismo tipo en ambos métodos. Dicho de otra forma, si devolvemos un Integer,nos pasarán un Integer. Además, debeser un Object (una instancia de una clase), por eso tratamos la edad como Integer y no como int.

El método setValueAt() tiene una pequeña pega. Cualquier modificación que hagamos en los datos, debe ser notificada a los suscriptores. Debemos crear un TableModelEvent , rellenarlo con los datos adecuados y avisar a los suscriptores.

El TableModelEvent se puede rellenar con el constructor. Parael caso de setValueAt() debemos ponerdespués de cambiar el dato (del switch) algo como esto

TableModelEvent evento = new TableModelEvent (this, fila, fila, columna);

Se le pasan como parámetros:

• El modelo de datos que ha cambiado. En nuestro caso this.
• La fila inicial que ha cambiado.
• La fila final que ha cambiado, en nuestro caso la misma que la inicial, puesto que sólo ha cambiado una.
• La columna que ha cambiado.

Una vez creado el evento, hay que pasárselo a los suscriptores a través de su método tableChanged()

int i;

for (i=0; i<suscriptores.size(); i++)
    ((TableModelListener)suscriptores.get(i)).tableChanged(evento);

Debemos hacer esto en todos los métodos que hagamos que cambien el modelo de datos, bien sea modificando datos, borrando o añadiendo filas o columnas.

Los demás métodos

Los demás métodos son de información general para la tabla y no tienen demasiado truco.

• Devolver la clase de cada columna. Devolveremos String.class para el nombre y el apellido e Integer.class para la edad. Este método lo utiliza el JTable para saber cómo presentar o editar cada dato. Si el JTable no conoce la clase que le devolvemos (no es de las normales de java), lo más posible es que trate el dato como un Object yllame a su método toString() para pintarlo.
• Devolver el número de columnas. Para nuestro ejemplo de Persona, que tiene tres campos, devolveremos un 3.
• Devolver el nombre de las columnas. En nuestro ejemplo devolveremos "Nombre", "Apellido" y "Edad".
• Devolver cuántas filas hay (el número de elementos en nuestra lista de personas)
• Devolver si una celda en fila,columna es o no editable, es decir, si el usuario puede escribir en ella y modificar los datos del modelo. En nuestro ejemplo devolveremos true .

Otros métodos

Puesto que para eso hemos hecho este modelo, vamos a añadirle un par de métodos que nos son útiles para el ejemplo y nos facilitan el añadir y borrar personas:

public void anhadePersona (Persona nuevaPersona) {
    // Añade la persona al modelo
    datos.add (nuevaPersona);

    // Avisa a los suscriptores creando un TableModelEvent...
    TableModelEvent evento; evento = new TableModelEvent (
        this, this.getRowCount()-1, this.getRowCount()-1,
        TableModelEvent.ALL_COLUMNS, TableModelEvent.INSERT);

    // ... y avisando a los suscriptores
    int i;

    for (i=0; i<suscriptores.size(); i++)
        ((TableModelListener)suscriptores.get(i)).tableChanged(evento);
}

En este caso, en el evento, hemos puesto como fila la última, quees la recién añadida. Como columna hemos puesto  TableModelEvent.ALL_COLUMNS que indica que todas las columnas se han visto afectadas. Finalmente, hay un nuevo parámetro que indica que la fila indicada se ha insertado. Si no ponemos nada en este parámetro (como en el caso del setValueAt()), indica queesos datos ya existían antes y que se han modificado.

Y otro método para borrar una fila:

public void borraPersona (int fila) {
    // Se borra la fila datos.remove(fila);

    // Y se avisa a los suscriptores, creando un TableModelEvent...
    TableModelEvent evento = new TableModelEvent (this, fila, fila,
        TableModelEvent.ALL_COLUMNS, TableModelEvent.DELETE);

    // ... y pasándoselo a los suscriptores
    int i;

    for (i=0; i<suscriptores.size(); i++)
        ((TableModelListener)suscriptores.get(i)).tableChanged(evento);
}

Nada especial que comentar. Se borra la fila que se indica, se crea el evento de forma similar al anterior, pero cambiando el último parámetro y se avisa a los suscriptores.

RESUMEN

JTABLE

Definición 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 al usuario organización de información, oportunidades de editar y cambiar el tamaño de las columna entre otras.

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 .

Table Model es un programa que guarda los datos de la tabla para si mismo, es decir, puede tener la información de la tabla pero estos datos son los 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.

LLENAR UN JTABLE CON UNA BASE DE DATOS

Lo siguiente es un código en donde se llena un Jtable con Netbeans, pero haciéndolo mediante una base de datos... Solamente toca cambiar la conexión, el select y el nombre del Jtable

//Devuelve toda la tabla producto

public static DefaultListModel obtenerCodigos() {

DefaultListModel modelo = new DefaultListModel();

try {

DefaultListModel defaultListModel = new DefaultListModel();

int contador=1;

String codigo="";

ResultSet resultados = conexion.ejecutarConsulta("SELECT * FROM producto");

//Este while es quien llega la lista para luego utilizarla llenando el Jtable

while(resultados.next()){

codigo= resultados.getString(1);

defaultListModel.addElement(contador+". "+codigo);

contador++;

}

conexion.cerrarConsulta();

return defaultListModel;

} catch (SQLException ex) {

return modelo;

}

}

//aqui se llena el Jtable con lo que retorno lo anterior

this.listMarcadores.setModel(obtenerCodigos());

JTABLE Y DEFAULTTABLEMODEL

La forma más sencilla de usar un JTable y tener toda su funcionalidad es instanciar un Default Table Model y meterlo en el JTable, en el constructor Default Table Model modelo = new Default Table Model(); El método row At Point() 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 pixeles superior al que le corresponde según su número de filas.

Si usamos Default Table Model las celdas del JTable son editables por defecto.

La forma de decidir que celdas son o no editables es hacer nuestro propio modelo de datos, nuestro Table Model.

La forma sencilla de hacerlo es heredar de Default Table Model y redefinir el método es Cell Editable() para que sirva a nuestros propósitos 

SUMMARY

jtable

Definition It is a class that allows me to organize a certain information in the table, it differs from a database of normal use through Jetwing that can be visualized this table, giving to the users of the organization of the information, the opportunities of Edit and change the size of the Column among others.

Jetwear for many facilities, since it has several features that allow you to make from tables with complex information and very structured to tables with simple and basic information.

The model of the table is a program that saves the data of the table for itself, that is to say, it can have the information of the table but these data are the ones visualized by the computer, that is to say, to visualize a table the TABLEMODEL can have The information but without the Jtable can not be displayed to the user.

FILLING A JTABLE WITH A DATABASE

The only thing that is a code where a single is filled with Netbeans, but doing it through a database ... It only touches to change the connection, the select and the name of Jtable

// Returns the entire product table

Public static DefaultListModel getCodes () {

DefaultListModel template = new DefaultListModel ();

try {

DefaultListModel defaultListModel = new DefaultListModel ();

Int counter = 1;

String code = "";

ResultSet results = connection and execute Query ( "SELECT * FROM product");

// This while it is who reaches the list and then use it in the Jtable

While (results.next ()) {

Code = results.getString (1);

DefaultListModel.addElement (counter + "." + Code);

Counter ++;

}

Connection.Execute ();

Return defaultListModel;

} Catch (SQLException ex) {

Return model;

}

}

// here the Jtable is filled with what returns to the previous one

This.listMarcadores.setModel (getCodes ());

JTABLE AND DEFAULTTABLEMODEL

The simplest way to use a JTable and have all its functionality is to instantiate a Default Table Model and put it in the JTable, in the constructor Default Table Model Model = new Default Table Model (); The method row At point () it returns -1 if we click on the JTable, but outside any row.

It is the case that the JTable has a size in pixels superior to that corresponding to its number of rows.

If we use Default Table Model the JTable child cells are editable by default.

The way to decide that the child is not editable is to make our own data model, our model table.

The simple way to do is inherit from Default Table Model and redefine the method is Editable Mobile () to serve our purposes

RECOMENDACIONES

Querido lector Lo que acabas de leer es información sobre cómo se utiliza un jTable con base de datos pero previamente tu ya debiste haber importado la librería jdbc, y haber hecho tu conexión a la base de datos para poder mostrar la información que tienes en tu base de datos en un jtable de tu formulario. Y te recomendamos que utilices un jtable para mostrar tus datos porque tiene todas las características para poder visualizar los datos de tu base de datos.

CONCLUSIÓN

JTable es un componente visual de Java que nos permite dibujar una tabla, de forma que en cada fila/columna de la tabla podamos poner el dato que queramos; un nombre, un apellido, una edad, un número, etc.

 Además ,travez del un jtable nosotros podemos mostrar los contenidos de las tablas de nuestra base de datos.

También se a concluido que los objetos del tipo jtable contiene un método fundamental que es el DefaultTableModel mediante de este método podemos nosotros añadir nuevas filas extraer datos de las celdas como también añadir datos de la celda de la tabla.

APRECICION DEL EQUIPO

Muchas veces en el mundo de la programación no entendemos muchas cosas porque se usa esto o el otro bueno haciendo este trabajo hemos entendido el uso del jtable con base de datos y nos hemos dado cuenta por que se usan los métodos como el TableModel entre otros.

se ha visto también la importancia de esta herramienta para poder mostrar los datos de nuestra base de datos. El cual nos facilita mostrar estos datos debido a que un JTable es un componente visual de Java.

GLOSARIO DE TERMINOS

·         Un JTable es un componente visual de Java que nos permite dibujar una tabla, de forma que en cada fila/columna de la tabla podamos poner el dato que queramos; un nombre, un apellido, una edad, un número, etc

·         MouseListener

Es una interfaz y por eso se deben implementar todos los metodos abstractos

·         MouseAdapter

Implementan el correspondiente interface Listener redefiniendo todas las funciones declaradas en el interface sin que hagan nada en particular

·         getTableCellRendererComponent(). la implementación de este método debe configurar el componente con el fin de representar el pasado estado y luego devolver el componente.

·        JSCROLLPANE permite asociarle una pequeña vista o ventana deslizable o corrediza que permite solo que se vea una parte de dicho componente.

Un JSCROLLPANE, también puede asociarse a otros tipos de panels que contengan muchos componentes.

LINCOGRAFIA

http://www.elprogramador.com.mx/llenar-un-jtable-con-datos-de-una-base-de-datos-mysql/

https://programacionparajava.blogspot.pe/2014/09/agregar-eliminar-modificar-y-listar-en.html

http://www.programandoconcafe.com/2010/11/java-llenar-un-jtable-con-resultset.html

http://www.jc-mouse.net/java/jtable-editable-con-base-de-datos

http://www.javahispano.org/portada/2006/8/1/jtable-con-ejemplos-parte-1.html

http://yohanamoreno.blogspot.pe/2008/04/jtable.html


Aca los dejo el link de las Diapositivas de nuestro trabajo

http://www.slideshare.net/ErlinDarwinHerreraCieza/presentacin1-69646152

GRACIAS POR VISITAR NUESTRO BLOG.