Comment conserver le rendu des cellules JTable après une modification de cellule ?

Maintien du rendu des cellules JTable après la modification de la cellule

Problème

Après avoir configuré une colonne JTable en tant que chaîne et l'avoir triée en tant que double, la coutume le moteur de rendu de cellules formatant initialement la colonne comme $###,##0.00 arrête le rendu des cellules une fois que la valeur est édité.

Solution

Comprendre le flux d'événements

Lorsqu'une cellule est modifiée, les événements suivants se produisent dans l'ordre :

1. L'éditeur conclut .
2. La méthode EditingStopped() dans le tableau collecte les nouveaux value.
3. setValueAt() dans le modèle est appelé avec la nouvelle valeur.
4. Le modèle appelle fireTableCellUpdated().

Implémentation de la solution

Pour conserver le rendu des cellules après la modification, les étapes suivantes sont nécessaire :

1. Étendre le moteur de rendu par défaut : Le moteur de rendu par défaut doit être étendu pour gérer le formatage des nombres. Cela garantit que le moteur de rendu est responsable de l'affichage des valeurs.
2. Utilisez le moteur de rendu comme composant d'éditeur : Dans certains cas, il peut être pratique d'utiliser une instance du moteur de rendu comme éditeur composant. Cela permet d'appliquer le même formatage aux valeurs affichées et modifiées.

Exemple d'implémentation

Voici un exemple de base utilisant l'éditeur par défaut et les implémentations du moteur de rendu :

import javax.swing.DefaultCellEditor;
import javax.swing.DefaultTableCellRenderer;
import javax.swing.JTable;
import javax.swing.table.DefaultTableModel;
import java.text.NumberFormat;

public class RenderEditNumber {

    public static void main(String[] args) {
        NumberFormat nf = NumberFormat.getCurrencyInstance();
        DefaultTableModel model = new DefaultTableModel(
            new String[]{"Amount"}, 0) {

            @Override
            public Class<?> getColumnClass(int columnIndex) {
                return Double.class;
            }
        };
        for (int i = 0; i < 16; i++) {
            model.addRow(new Object[]{Double.valueOf(i)});
        }
        JTable table = new JTable(model);
        table.setPreferredScrollableViewportSize(new Dimension(123, 123));
        table.setDefaultRenderer(Double.class, new CurrencyRenderer(nf));
        table.setDefaultEditor(Double.class, new CurrencyEditor(nf));
    }

    private static class CurrencyRenderer extends DefaultTableCellRenderer {

        private NumberFormat formatter;

        public CurrencyRenderer(NumberFormat formatter) {
            this.formatter = formatter;
            this.setHorizontalAlignment(JLabel.RIGHT);
        }

        @Override
        public void setValue(Object value) {
            setText((value == null) ? "" : formatter.format(value));
        }
    }

    private static class CurrencyEditor extends DefaultCellEditor {

        private NumberFormat formatter;
        private JTextField textField;

        public CurrencyEditor(NumberFormat formatter) {
            super(new JTextField());
            this.formatter = formatter;
            this.textField = (JTextField) this.getComponent();
            textField.setHorizontalAlignment(JTextField.RIGHT);
            textField.setBorder(null);
        }

        @Override
        public Object getCellEditorValue() {
            try {
                return new Double(textField.getText());
            } catch (NumberFormatException e) {
                return Double.valueOf(0);
            }
        }

        @Override
        public Component getTableCellEditorComponent(JTable table,
            Object value, boolean isSelected, int row, int column) {
            textField.setText((value == null)
                ? "" : formatter.format((Double) value));
            return textField;
        }
    }
}

Dans cet exemple, les classes CurrencyRenderer et CurrencyEditor étendent respectivement les implémentations du moteur de rendu et de l'éditeur par défaut pour gérer le formatage des nombres. Notez que cet exemple n'inclut pas l'appel fireTableCellUpdated() car il est géré en interne par JTable.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!