Swing-JTable检测单元格数据变更前后值事件

绝地灬酷狼 2022-12-20 05:36 178阅读 0赞

参考：[https://www.cnblogs.com/pzy4447/p/5164775.html][https_www.cnblogs.com_pzy4447_p_5164775.html]

在JTable的初级教程中往往会提到，使用TableModel的 addTableModelListener方法可以监听单元格数据的变更，在其事件处理函，数tableChanged中，可以通过e.getColumn()，e.getFirstRow()，e.getLastRow()，e.getType()来获取变更发生的位置和变更的类型（插入、更新或删除）。然而该方法存在2个致命的问题：

1.双击单元格使其处于可编辑状态后，即使没有做出任何修改，当单元格失去焦点时，该事件将被激活。

2.通过该事件你可以获取单元格最新的数据，却无法获取原有数据。

经过一番搜索发现该文章已经解决了这个问题[Table Cell Listener][]，作者自己实现了一个单元格监听器TableCellListener，它订阅了指定table的addPropertyChangeListener，根据e.getPropertyName()来识别单元格编辑事件，根据table.isEditing()方法来判断单元格正在编辑还是编辑完毕。如果是正在编辑，则记录单元格位置和原因数据；如果已经编辑完毕，则记录新数据并与原有数据进行比对，如果不一致则说明单元格数据发生了变更，则激活指定响应函数。

测试用例如下：

TableDemo.java

/*
     * Copyright (c) 1995, 2008, Oracle and/or its affiliates. All rights reserved.
     *
     * Redistribution and use in source and binary forms, with or without
     * modification, are permitted provided that the following conditions
     * are met:
     *
     *   - Redistributions of source code must retain the above copyright
     *     notice, this list of conditions and the following disclaimer.
     *
     *   - Redistributions in binary form must reproduce the above copyright
     *     notice, this list of conditions and the following disclaimer in the
     *     documentation and/or other materials provided with the distribution.
     *
     *   - Neither the name of Oracle or the names of its
     *     contributors may be used to endorse or promote products derived
     *     from this software without specific prior written permission.
     *
     * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
     * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
     * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
     * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
     * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
     * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
     * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
     * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
     * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
     * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     */ 
    
    package TableCellListenerTest;
    
    /*
     * TableDemo.java requires no other files.
     */
    
    import javax.swing.AbstractAction;
    import javax.swing.Action;
    import javax.swing.JFrame;
    import javax.swing.JPanel;
    import javax.swing.JScrollPane;
    import javax.swing.JTable;
    import javax.swing.table.AbstractTableModel;
    
    import java.awt.Dimension;
    import java.awt.GridLayout;
    import java.awt.event.ActionEvent;
    
    /** 
     * TableDemo is just like SimpleTableDemo, except that it
     * uses a custom TableModel.
     */
    public class TableDemo extends JPanel {
        private boolean DEBUG = false;
    
        public TableDemo() {
            super(new GridLayout(1,0));
    
            JTable table = new JTable(new MyTableModel());
            table.setPreferredScrollableViewportSize(new Dimension(500, 70));
            table.setFillsViewportHeight(true);
    
            //Create the scroll pane and add the table to it.
            JScrollPane scrollPane = new JScrollPane(table);
    
            //Add the scroll pane to this panel.
            add(scrollPane);
            Action action = new AbstractAction()
            {
                public void actionPerformed(ActionEvent e)
                {
                    TableCellListener tcl = (TableCellListener)e.getSource();
                    System.out.printf("cell changed%n");
                    System.out.println("Row   : " + tcl.getRow());
                    System.out.println("Column: " + tcl.getColumn());
                    System.out.println("Old   : " + tcl.getOldValue());
                    System.out.println("New   : " + tcl.getNewValue());
                }
            };
            TableCellListener tcl = new TableCellListener(table, action);
        }
    
        class MyTableModel extends AbstractTableModel {
            private String[] columnNames = {"First Name",
                                            "Last Name",
                                            "Sport",
                                            "# of Years",
                                            "Vegetarian"};
            private Object[][] data = {
            {"Kathy", "Smith",
             "Snowboarding", new Integer(5), new Boolean(false)},
            {"John", "Doe",
             "Rowing", new Integer(3), new Boolean(true)},
            {"Sue", "Black",
             "Knitting", new Integer(2), new Boolean(false)},
            {"Jane", "White",
             "Speed reading", new Integer(20), new Boolean(true)},
            {"Joe", "Brown",
             "Pool", new Integer(10), new Boolean(false)}
            };
    
            public int getColumnCount() {
                return columnNames.length;
            }
    
            public int getRowCount() {
                return data.length;
            }
    
            public String getColumnName(int col) {
                return columnNames[col];
            }
    
            public Object getValueAt(int row, int col) {
                return data[row][col];
            }
    
            /*
             * JTable uses this method to determine the default renderer/
             * editor for each cell.  If we didn't implement this method,
             * then the last column would contain text ("true"/"false"),
             * rather than a check box.
             */
            public Class getColumnClass(int c) {
                return getValueAt(0, c).getClass();
            }
    
            /*
             * Don't need to implement this method unless your table's
             * editable.
             */
            public boolean isCellEditable(int row, int col) {
                //Note that the data/cell address is constant,
                //no matter where the cell appears onscreen.
                if (col < 2) {
                    return false;
                } else {
                    return true;
                }
            }
    
            /*
             * Don't need to implement this method unless your table's
             * data can change.
             */
            public void setValueAt(Object value, int row, int col) {
                if (DEBUG) {
                    System.out.println("Setting value at " + row + "," + col
                                       + " to " + value
                                       + " (an instance of "
                                       + value.getClass() + ")");
                }
    
                data[row][col] = value;
                fireTableCellUpdated(row, col);
    
                if (DEBUG) {
                    System.out.println("New value of data:");
                    printDebugData();
                }
            }
    
            private void printDebugData() {
                int numRows = getRowCount();
                int numCols = getColumnCount();
    
                for (int i=0; i < numRows; i++) {
                    System.out.print("    row " + i + ":");
                    for (int j=0; j < numCols; j++) {
                        System.out.print("  " + data[i][j]);
                    }
                    System.out.println();
                }
                System.out.println("--------------------------");
            }
        }
    
        /**
         * Create the GUI and show it.  For thread safety,
         * this method should be invoked from the
         * event-dispatching thread.
         */
        private static void createAndShowGUI() {
            //Create and set up the window.
            JFrame frame = new JFrame("TableDemo");
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    
            //Create and set up the content pane.
            TableDemo newContentPane = new TableDemo();
            newContentPane.setOpaque(true); //content panes must be opaque
            frame.setContentPane(newContentPane);
    
            //Display the window.
            frame.pack();
            frame.setVisible(true);
        }
    
        public static void main(String[] args) {
            //Schedule a job for the event-dispatching thread:
            //creating and showing this application's GUI.
            javax.swing.SwingUtilities.invokeLater(new Runnable() {
                public void run() {
                    createAndShowGUI();
                }
            });
        }
    }

TableCellListener.java

package DefaultTableModelDemo;
    import java.awt.event.*;
    import javax.swing.*;
    import java.beans.*;
    
    /*
     *  This class listens for changes made to the data in the table via the
     *  TableCellEditor. When editing is started, the value of the cell is saved
     *  When editing is stopped the new value is saved. When the oold and new
     *  values are different, then the provided Action is invoked.
     *
     *  The source of the Action is a TableCellListener instance.
     */
    public class TableCellListener implements PropertyChangeListener, Runnable
    {
        private JTable table;
        private Action action;
    
        private int row;
        private int column;
        private Object oldValue;
        private Object newValue;
    
        /**
         *  Create a TableCellListener.
         *
         *  @param table   the table to be monitored for data changes
         *  @param action  the Action to invoke when cell data is changed
         */
        
        public TableCellListener(JTable table, Action action)
        {
            this.table = table;
            this.action = action;
            this.table.addPropertyChangeListener( this );
        }
    
        /**
         *  Create a TableCellListener with a copy of all the data relevant to
         *  the change of data for a given cell.
         *
         *  @param row  the row of the changed cell
         *  @param column  the column of the changed cell
         *  @param oldValue  the old data of the changed cell
         *  @param newValue  the new data of the changed cell
         */
        private TableCellListener(JTable table, int row, int column, Object oldValue, Object newValue)
        {
            this.table = table;
            this.row = row;
            this.column = column;
            this.oldValue = oldValue;
            this.newValue = newValue;
        }
    
        /**
         *  Get the column that was last edited
         *
         *  @return the column that was edited
         */
        public int getColumn()
        {
            return column;
        }
    
        /**
         *  Get the new value in the cell
         *
         *  @return the new value in the cell
         */
        public Object getNewValue()
        {
            return newValue;
        }
    
        /**
         *  Get the old value of the cell
         *
         *  @return the old value of the cell
         */
        public Object getOldValue()
        {
            return oldValue;
        }
    
        /**
         *  Get the row that was last edited
         *
         *  @return the row that was edited
         */
        public int getRow()
        {
            return row;
        }
    
        /**
         *  Get the table of the cell that was changed
         *
         *  @return the table of the cell that was changed
         */
        public JTable getTable()
        {
            return table;
        }
    //
    //  Implement the PropertyChangeListener interface
    //
        @Override
        public void propertyChange(PropertyChangeEvent e)
        {
            //  A cell has started/stopped editing
    
            if ("tableCellEditor".equals(e.getPropertyName()))
            {
                if (table.isEditing()){
                    //System.out.printf("tableCellEditor is editing..%n");
                    processEditingStarted();
                }
                else{
                    //System.out.printf("tableCellEditor editing stopped..%n");
                    processEditingStopped();
                }
                    
            }
        }
    
        /*
         *  Save information of the cell about to be edited
         */
        private void processEditingStarted()
        {
            //  The invokeLater is necessary because the editing row and editing
            //  column of the table have not been set when the "tableCellEditor"
            //  PropertyChangeEvent is fired.
            //  This results in the "run" method being invoked
    
            SwingUtilities.invokeLater( this );
        }
        /*
         *  See above.
         */
        @Override
        public void run()
        {
            row = table.convertRowIndexToModel( table.getEditingRow() );
            column = table.convertColumnIndexToModel( table.getEditingColumn() );
            oldValue = table.getModel().getValueAt(row, column);
            //这里应对oldValue为null的情况做处理，否则将导致原值与新值均为空时仍被视为值改变
            if(oldValue == null)
                oldValue = "";
            newValue = null;
        }
    
        /*
         *    Update the Cell history when necessary
         */
        private void processEditingStopped()
        {
            newValue = table.getModel().getValueAt(row, column);
            //这里应对newValue为null的情况做处理，否则后面会抛出异常
            if(newValue == null)
                newValue = "";
            //  The data has changed, invoke the supplied Action
            if (! newValue.equals(oldValue))
            {
                //  Make a copy of the data in case another cell starts editing
                //  while processing this change
    
                
                TableCellListener tcl = new TableCellListener(
                    getTable(), getRow(), getColumn(), getOldValue(), getNewValue());
    
                ActionEvent event = new ActionEvent(
                    tcl,
                    ActionEvent.ACTION_PERFORMED,
                    "");        
                action.actionPerformed(event);
            }
        }
    }

[https_www.cnblogs.com_pzy4447_p_5164775.html]: https://www.cnblogs.com/pzy4447/p/5164775.html
[Table Cell Listener]: https://tips4java.wordpress.com/2009/06/07/table-cell-listener/