java - how - jtable editing row

Tutorial editable de JTable

Question

¿Hay algún buen libro o sitio web que vaya a crear una JTable ? Quiero hacer una columna editable. Me gustaría poner realmente un componente JCheckBox heredado (que hemos creado aquí) en una de las columnas de la tabla en lugar de simplemente poner la tabla JCheckBox en función de que es un campo boolean editable.

Tengo el libro JFC Swing Tutorial Second Edition , pero me gustaría saber si hay otros ejemplos que pueda ver y aprender a manejar mejor las tablas. El libro parece tomar el "rastro" de Java en línea y ponerlo en el libro.

Sin embargo, estoy volviendo a leer las cosas, solo curiosidad por si alguien ha encontrado algo que podría ayudarme más.

Answer 1

Este tutorial del lobby java es fácil de seguir. El rastro en línea de Swing para JTable al que hace referencia indica que se ha actualizado. ¿Analizó todo el asunto para una mejor información posible (no siempre es mejor)?

Answer 2

La clase que desea ampliar para crear su propio comportamiento es DefaultTableModel. Eso te permitirá definir tu propio comportamiento. Un buen tutorial se puede encontrar en el sitio del sol .

Answer 3

Algunas clases útiles son:

Package javax.swing.table :

TableModel - Interfaz para un tablemodel AbstractTableModel - Clase agradable para extender para crear su propia tabla con estructuras de datos personalizadas DefaultTableModel - Modelo de tabla predeterminado que puede tratar con arrays[] y Vectors

Para deshabilitar la edición en cualquier celda, debe anular el isCellEditable(int row, int col)

Answer 4

Si está tratando de usar una JTable simple con 1 columna editable y conoce la ubicación de la columna, siempre puede usar el modelo de tabla predeterminado y sobrecargar la llamada isCellEditable .

algo como esto :

myTable.setModel(new DefaultTableModel(){
@Override
public boolean isCellEditable(int row, int column) {
    if (column == x) {
        return true;
    } else
        return false;
}
});

Y para la casilla de verificación crear una clase de renderizador

MyCheckBoxRenderer extends JCheckBox implements TableCellRenderer

Answer 5

en su Modelo de tabla, debe anular las funciones "isCellEditable" y "setValueAt", como a continuación.
La columna 4 es la columna para las celdas editables.
Luego, cuando haces doble clic en la celda y escribes algo,
Se llamará a setValueAt () y se guardará el valor en el DO de tableModel, campo col4.

public ArrayList<XXXDO> tbmData = new ArrayList<XXXDO>(); //arraylist for data in table

@Override
public boolean isCellEditable(int row, int col) {
    if (col == 4) {
        return true;
    } else {
        return false;
    }
}

@Override
public void setValueAt(Object value, int row, int col) {
    if ((row >= 0) && (row < this.tbmData.size()) && (col >= 0) && (col < this.colNm.length)) {
        if (col == 4) {
            tbmData.get(row).col4= (String) value;
        }
        fireTableCellUpdated(row, col);
    } else {
    }
}

Answer 6

Para que una columna sea editable, debe anular el método isCellEditable en TableModel . Crear un TableModel es bastante fácil si hereda AbstractTableModel y lo recomendaría para todas las JTable s, excepto para las más simples.

Sin embargo, adaptar TableModel es solo una parte de lo que debe hacer. Para obtener realmente un componente personalizado en JTable , debe establecer un procesador de celdas personalizado. Para usar un componente personalizado interactivo, debe establecer un editor de celda personalizado. En algunos casos, es suficiente usar versiones ligeramente modificadas de las clases predeterminadas para esto.

Editores

Si ya tiene un componente personalizado, puede hacerlo fácilmente mediante delegación: cree una nueva clase que implemente TableCellEditor y devuelva una nueva instancia del componente en el método getCellEditorComponent . Los parámetros de este método incluyen el valor actual, así como las coordenadas de la celda, un enlace a la tabla y, si se selecciona o no la celda.

El TableCellEditor también tiene un método que se llama cuando el usuario confirma un cambio en el contenido de la celda (donde puede validar la entrada del usuario y ajustar el modelo) o cancela una edición. Asegúrese de llamar al método stopEditing() en su editor si alguna vez aborta programáticamente la edición, de lo contrario, el componente del editor permanecerá en la pantalla; esta vez me tomó aproximadamente 2 horas para depurar.

Tenga en cuenta que dentro de una JTable editores y solo editores reciben eventos! Mostrar un botón se puede hacer usando un renderizador. Pero para obtener un botón de funcionamiento, debe implementar un editor con los EventListeners correctos registrados. El registro de un oyente en un procesador no hace nada.

Renderers

Implementar un renderizador no es estrictamente necesario para lo que describes en tu pregunta, pero por lo general terminas haciéndolo de todos modos, aunque solo sea por modificaciones menores. Los renderizadores, a diferencia de los editores, son críticos para la velocidad. ¡El getTableCellRendererComponent de un renderizador se llama una vez para cada celda de la tabla! El componente devuelto por un renderizador solo se usa para pintar la celda, no para la interacción, y así se puede "reutilizar" para la siguiente celda. En otras palabras, debes ajustar el componente (por ejemplo, usando setText(...) o setFont(...) si es un TextComponent ) en el renderizador, no debes instanciar uno nuevo: esa es una manera fácil de paralizar el desempeño.

Advertencias

Tenga en cuenta que para que los renderizadores y editores funcionen, debe indicarle a JTable cuándo utilizar un determinado procesador / editor. Básicamente hay dos formas de hacer esto. Puede establecer el renderizador / editor de celda predeterminado para un cierto tipo usando los métodos JTable respectivos. Para que esto funcione, su TableModel necesita devolver exactamente este tipo en el getColumnClass(...) . El modelo de tabla predeterminado no hará esto por usted, siempre devuelve Object.class . Estoy seguro de que ha dejado perplejas a mucha gente.

La otra forma de configurar el editor / procesador es estableciéndolo explícitamente en la columna, es decir, obteniendo la TableColumn mediante el getTableColumn(...) de JTable . Esto es mucho más elaborado, sin embargo, también es la única manera de tener dos renderizadores / editores diferentes para una sola clase. Por ejemplo, su modelo puede tener dos columnas de clase String que se representan de maneras completamente diferentes, tal vez una vez usando JLabel/DefaultRenderer y la otra usando un JButton para acceder a un editor más elaborado.

JTable con sus visualizadores y editores personalizados es extremadamente versátil, pero también es mucho para asimilar, y hay muchas cosas que hacer mal. ¡Buena suerte!

Cómo usar Tablas en The Swing Tutorial es una lectura obligatoria para cualquiera que personalice JTables. En particular, lea y vuelva a leer Concepts: Editors and Renderers porque normalmente demora un tiempo en "hacer clic". Los ejemplos en renderizadores y editores personalizados también son muy útiles.