Wie behalte ich das JTable-Zellenrendering nach einer Zellenbearbeitung bei?

Aufrechterhaltung der JTable-Zellenwiedergabe nach der Zellenbearbeitung

Problem

Nachdem eine JTable-Spalte als String eingerichtet und als Double sortiert wurde, wird die benutzerdefinierte Der Zellrenderer formatiert die Spalte zunächst als $###,##0.00 und stoppt das Rendern der Zellen, nachdem der Wert angegeben ist bearbeitet.

Lösung

Den Ereignisfluss verstehen

Wenn eine Zelle bearbeitet wird, treten die folgenden Ereignisse nacheinander auf:

1. Der Editor schließt ab .
2. Die Methode editStopped() in der Tabelle sammelt die neuen value.
3. setValueAt() im Modell wird mit dem neuen Wert aufgerufen.
4. Das Modell ruft fireTableCellUpdated() auf.

Implementierung der Lösung

Um das Zellenrendering nach der Bearbeitung beizubehalten, sind die folgenden Schritte erforderlich notwendig:

1. Standard-Renderer erweitern: Der Standard-Renderer sollte erweitert werden, um die Zahlenformatierung zu verarbeiten. Dadurch wird sichergestellt, dass der Renderer für die Anzeige der Werte verantwortlich ist.
2. Verwenden Sie den Renderer als Editor-Komponente: In manchen Fällen kann es praktisch sein, eine Instanz des Renderers als Editor zu verwenden Komponente. Dadurch kann die gleiche Formatierung sowohl auf die angezeigten als auch auf die bearbeiteten Werte angewendet werden.

Beispielimplementierung

Hier ist ein einfaches Beispiel mit den Standard-Editor- und Renderer-Implementierungen:

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

In diesem Beispiel erweitern die Klassen „CurrencyRenderer“ und „CurrencyEditor“ die standardmäßigen Renderer- bzw. Editor-Implementierungen, um die Zahlenformatierung zu verarbeiten. Beachten Sie, dass dieses Beispiel den Aufruf fireTableCellUpdated() nicht enthält, da er intern von der JTable verarbeitet wird.

Das obige ist der detaillierte Inhalt vonWie behalte ich das JTable-Zellenrendering nach einer Zellenbearbeitung bei?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!