Java Swing实现JTable检测单元格数据变更事件的方法示例

本文实例讲述了Java Swing实现JTable检测单元格数据变更事件的方法。分享给大家供大家参考，具体如下：

在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 awtDemo;
/*
* 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.
*/
@SuppressWarnings("serial")
public class TableDemo extends JPanel {
 private boolean DEBUG = false;
 @SuppressWarnings("unused")
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.
    */
   @SuppressWarnings({ "unchecked", "rawtypes" })
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 - www.jb51.net");
   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 awtDemo;
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);
   }
 }
}

运行效果：

由图可见，单元格数据修改后，控制台输出内容变更信息！

希望本文所述对大家java程序设计有所帮助。

来源：http://www.cnblogs.com/pzy4447/p/5164775.html