Java Swing (JTable詳解1)

好久沒有玩Swing了,算是練習英語,參考Sun公司官方給出的Java Tutorial的教程,來回顧一下JTable的用法,也希望大神來拍磚！

JTable顧名思義就是一個將數據以表格顯示的組件,但是需要特別注意的是:因為Java Swing采用了MVC的設計,所以JTable不是用來存放數據的,它只是用來作為視圖顯示,而真正用來存儲和維護數據的是TableModel這個接口的實現類。

 

 

 

從上面的圖我們可以看出幾個特點:

1.JTable的表頭其實也是一個單獨的組件,TableHeader

2.而每一列也可以被划分出來作為一個組件,TableColumn

3.JTable的數據選項不僅僅是可以顯示字符串,還可以顯示checkbox，img等等,其實只要你懂得如何去重寫它內部的方法,你想怎么顯示就怎么顯示.

好了,廢話不說了,來看

1.第一個例子(這個例子對官方的內容進行了少許變動,可以讓別人更加理解這個屬性的含義是什么)

package org.plx.jtable;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTable;

@SuppressWarnings("serial")
public class SimpleTableDemo extends JPanel {
    private boolean DEBUG = true;

    public SimpleTableDemo() {
        super(new BorderLayout());

        //創建表頭
        String[] columnNames = { "First Name", "Last Name", "Sport",
                "# of Years", "Vegetarian" };

        //創建顯示數據
        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) } };
        
        /*
         * JTable還提供了一個重載的構造方法,傳入兩個Vector
         * JTable(Vector rowData, Vector columnNames)
         * 
         */
        
        final JTable table = new JTable(data, columnNames);
    
        table.setBackground(Color.YELLOW);
        
        //table.setPreferredScrollableViewportSize(new Dimension(500, 0));
        
        if (DEBUG) {
            table.addMouseListener(new MouseAdapter() {
                public void mouseClicked(MouseEvent e) {
                    printDebugData(table);
                }
            });
        }

        // Create the scroll pane and add the table to it.
        //這也是官方建議使用的方式，否則表頭不會顯示，需要單獨獲取到TableHeader自己手動地添加顯示
        JScrollPane scrollPane = new JScrollPane(table);

        add(scrollPane);
            
        
        JPanel panel2 = new JPanel();
        this.add(panel2,BorderLayout.SOUTH);
        JButton btn1 = new JButton("表格填充整個視圖");
        JButton btn2 = new JButton("表格不添加整個視圖(默認不填充)");
        panel2.add(btn1);
        panel2.add(btn2);
        
        btn1.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                //設置表格填充整個視圖,在默認情況下,如果表格的大小小於視圖(窗體),你會發現下面的內容是其他顏色,可以將上面的yellow去掉做個比較
                table.setFillsViewportHeight(true);
            }
        });
        
        btn2.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                table.setFillsViewportHeight(false);
            }
        });
        
    }

    private void printDebugData(JTable table) {
        int numRows = table.getRowCount();
        int numCols = table.getColumnCount();
        javax.swing.table.TableModel model = table.getModel();

        System.out.println("Value of data: ");
        for (int i = 0; i < numRows; i++) {
            System.out.print("    row " + i + ":");
            for (int j = 0; j < numCols; j++) {
                System.out.print("  " + model.getValueAt(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("SimpleTableDemo");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        // Create and set up the content pane.
        SimpleTableDemo newContentPane = new SimpleTableDemo();
        newContentPane.setOpaque(true); // content panes must be opaque
        frame.setContentPane(newContentPane);

        // Display the window.
        //frame.pack();
        frame.setSize(800, 600);
        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();
            }
        });
    }
}

我在這里故意將表格的背景設置成YELLOW,可以讓大家更加看清JTable在默認的情況下當它自身顯示的大小小於容器時,它是不會去填充整個容器的,當設置setFillsViewportHeight為true的時候,表格就會填充整個容器。官方對於設置這個的作用是可以表格更加容易作為被拖拽的目標,但是我至今還沒試過往表格里托東西,事后准備試試。。。

在上面的代碼中還有一點需要注意的是:表格的顯示通常都會將其放置在JScrollpane,如果不放置,那么表格的表頭就無法顯示,而此時如果要顯示的話,那么就得將表頭(TableHeader,前面已經提到了)作為一個組件顯示，而JTable再作為一個組件顯示。

 

container.setLayout(new BorderLayout());

container.add(table.getTableHeader(),BorderLayout.PAGE_START);


container.add(table, BorderLayout.CENTER);

 

分析一下上面的表格存在的缺陷:

 (1).這個表格是可以被編輯的

 (2).我們發現,傳入的數據是Boolan類型，按照正常情況下,應該顯示成checkbox，但是這里卻是以字符串的形式顯示(比較第一個圖可以看到,它最后顯示的是一個checkbox,可以讓用戶查看更加的直觀,而第二種卻只能死板的顯示字符串)，而為什么會造成這樣的原因呢,后面我們分析完源碼就徹底明白了。

  (3).這里的創建需要我們自己先去創建數據或者Vector，但在很多情況下這種方式會對開發造成代碼的冗余。

 比如：我們從數據庫中查詢到一組對象,此時就需要將對象轉成數組或者集合
(當然,如果你用AOP來解決這類問題可能大材小用了)

 

2.修改單元格的寬度:

我們可以試着去觀察一下上面的表格,我們發現每列都是一樣的寬度,但是在實際的開發中可能會遇到對象的某些屬性是內容特別長的，但是某些屬性內容卻是特別端,因為可能會導致內容較長的列被遮擋,造成不好的用戶體驗.因此,設置表格列的寬度也是實際中必不可少的部分。OK,下面來完成一個對表格列寬度的設置。

 

package org.plx.jtable;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.table.TableColumn;

@SuppressWarnings("serial")
public class SetColumnSizeDemo extends JPanel {
    private boolean DEBUG = true;

    public SetColumnSizeDemo() {
        super(new BorderLayout());

        //創建表頭
        String[] columnNames = { "First Name", "Last Name", "Sport",
                "# of Years", "Vegetarian" };

        //創建顯示數據
        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) } };
        
        /*
         * JTable還提供了一個重載的構造方法,傳入兩個Vector
         * JTable(Vector rowData, Vector columnNames)
         * 
         */
        
        final JTable table = new JTable(data, columnNames);
    
        table.setBackground(Color.YELLOW);
        
        table.setPreferredScrollableViewportSize(new Dimension(800, 100));
        
        if (DEBUG) {
            table.addMouseListener(new MouseAdapter() {
                public void mouseClicked(MouseEvent e) {
                    printDebugData(table);
                }
            });
        }

        // Create the scroll pane and add the table to it.
        //這也是官方建議使用的方式，否則表頭不會顯示，需要單獨獲取到TableHeader自己手動地添加顯示
        JScrollPane scrollPane = new JScrollPane(table);

        add(scrollPane);
            
        
        JPanel panel2 = new JPanel();
        this.add(panel2,BorderLayout.SOUTH);
        JButton btn1 = new JButton("表格填充整個視圖");
        JButton btn2 = new JButton("表格不添加整個視圖(默認不填充)");
        panel2.add(btn1);
        panel2.add(btn2);
        
        btn1.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                //設置表格填充整個視圖,在默認情況下,如果表格的大小小於視圖(窗體),你會發現下面的內容是其他顏色,可以將上面的yellow去掉做個比較
                table.setFillsViewportHeight(true);
            }
        });
        
        btn2.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                table.setFillsViewportHeight(false);
            }
        });
        initColumnSize(table);
    }

    private void printDebugData(JTable table) {
        int numRows = table.getRowCount();
        int numCols = table.getColumnCount();
        javax.swing.table.TableModel model = table.getModel();

        System.out.println("Value of data: ");
        for (int i = 0; i < numRows; i++) {
            System.out.print("    row " + i + ":");
            for (int j = 0; j < numCols; j++) {
                System.out.print("  " + model.getValueAt(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("SimpleTableDemo");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        // Create and set up the content pane.
        SetColumnSizeDemo newContentPane = new SetColumnSizeDemo();
        newContentPane.setOpaque(true); // content panes must be opaque
        frame.setContentPane(newContentPane);

        // 這里直接使用pack來顯示
        frame.pack();
        frame.setVisible(true);
    }
    
    /**
     * 設置Column的寬度
     */
    private void initColumnSize(JTable table){
        //表格的每一列也是一個組件
        TableColumn tc = null;
        
        for(int i = 0 ;i < table.getColumnCount();i++){
            //注意:這里需要使用TableColumnModel來獲取
            //如果直接使用table.getColumn(identifier)會報錯,
            tc = table.getColumnModel().getColumn(i);
            tc.setPreferredWidth(50 * (i+1));
        }
    }

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

可以顯示一下效果,這邊圖片上傳一直失敗。還有一點要注意的是：表格的列默認情況下是可以拖動的,那么我們可以設置

tc.setMaxWidth(maxWidth);和 tc.setMinWidth(minWidth);來確定它拖動到最大和最小的寬度。最后補充一點:JTable可以設置setAutoResizeMode，可以傳入一下的五個值: 

AUTO_RESIZE_OFF,

AUTO_RESIZE_NEXT_COLUMN,

AUTO_RESIZE_SUBSEQUENT_COLUMNS,

AUTO_RESIZE_LAST_COLUMN,

AUTO_RESIZE_ALL_COLUMNS

    /**
     * @see #getUIClassID
     * @see #readObject
     */
    private static final String uiClassID = "TableUI";

    /** Do not adjust column widths automatically; use a horizontal scrollbar instead. */
    public static final int     AUTO_RESIZE_OFF = 0;

    /** When a column is adjusted in the UI, adjust the next column the opposite way. */
    public static final int     AUTO_RESIZE_NEXT_COLUMN = 1;

    /** During UI adjustment, change subsequent columns to preserve the total width;
      * this is the default behavior. */
    public static final int     AUTO_RESIZE_SUBSEQUENT_COLUMNS = 2;

    /** During all resize operations, apply adjustments to the last column only. */
    public static final int     AUTO_RESIZE_LAST_COLUMN = 3;

    /** During all resize operations, proportionately resize all columns. */
    public static final int     AUTO_RESIZE_ALL_COLUMNS = 4;

默認情況下的值是2。上面代碼中的注釋已經說得很清楚了。

現在回到前面第一個案例中遺留下來的問題就是為什么有些單元格可以顯示checkbox，有些只能顯示字符串呢?

我們來看下面的這個例子:

package org.plx.jtable;

import java.awt.Dimension;
import java.awt.GridLayout;

import javax.swing.DefaultCellEditor;
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.table.AbstractTableModel;
import javax.swing.table.DefaultTableCellRenderer;
import javax.swing.table.TableColumn;

@SuppressWarnings("serial")
public class TableRenderDemo extends JPanel {

    private boolean DEBUG = false;

    public TableRenderDemo() {
        super(new GridLayout(1, 0));

        JTable table = new JTable(new MyTableModel());
        table.setPreferredScrollableViewportSize(new Dimension(500, 400));
        table.setFillsViewportHeight(true);

        // Create the scroll pane and add the table to it.
        JScrollPane scrollPane = new JScrollPane(table);

        // Fiddle with the Sport column's cell editors/renderers.
        setUpSportColumn(table, table.getColumnModel().getColumn(2));

        // Add the scroll pane to this panel.
        add(scrollPane);
    }

    @SuppressWarnings({ "rawtypes", "unchecked" })
    public void setUpSportColumn(JTable table, TableColumn sportColumn) {
        // Set up the editor for the sport cells.
        JComboBox comboBox = new JComboBox();
        comboBox.addItem("Snowboarding");
        comboBox.addItem("Rowing");
        comboBox.addItem("Knitting");
        comboBox.addItem("Speed reading");
        comboBox.addItem("Pool");
        comboBox.addItem("None of the above");
        sportColumn.setCellEditor(new DefaultCellEditor(comboBox));

        // Set up tool tips for the sport cells.
        DefaultTableCellRenderer renderer = new DefaultTableCellRenderer();
        renderer.setToolTipText("Click for combo box");
        sportColumn.setCellRenderer(renderer);
    }

    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 final Object[] longValues = { "Jane", "Kathy",
                "None of the above", new Integer(20), Boolean.TRUE };

        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({ "rawtypes", "unchecked" })
        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("TableRenderDemo");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        // Create and set up the content pane.
        TableRenderDemo newContentPane = new TableRenderDemo();
        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();
            }
        });
    }
}

此時再次運行上面的程序就可以顯示checkbox。首先我們這里自己去創建了一個TableModel的實現類

public interface TableModel
{
    /**
     * Returns the number of rows in the model. A
     * <code>JTable</code> uses this method to determine how many rows it
     * should display.  This method should be quick, as it
     * is called frequently during rendering.
     *
     * @return the number of rows in the model
     * @see #getColumnCount
     */
    public int getRowCount();

TableModel是一個接口,而我們自己所編寫的TableModel是繼承了AbstractTableModel，該類是一個抽象類,實現了一部分的方法。但是最最核心和還是

 

        /*
         * 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({ "rawtypes", "unchecked" })
        public Class getColumnClass(int c) {
            return getValueAt(0, c).getClass();
        }

從以上的注釋我們可以知道:JTable是使用這個方法來決定對於每個單元格是如何渲染的，如果我們不實現這個方法,那么默認返回的值就是true或者false,而不是一個checkbox。

其本質的原因在於如果當返回的是一個Object.class，那么JTable在渲染的時候就是使用字符串去顯示，如果你返回的是Boolean.class，那么就是以checkbox來渲染,而如果是Image.class，那么就可以以圖片的顯示來顯示。我們的第一個例子中,直接使用數組的方式來構建JTable，它的低層是通過自身的一個TableModel來維護,這個類是一個匿名內部類,

 public JTable(final Object[][] rowData, final Object[] columnNames) {
        this(new AbstractTableModel() {
            public String getColumnName(int column) { return columnNames[column].toString(); }
            public int getRowCount() { return rowData.length; }
            public int getColumnCount() { return columnNames.length; }
            public Object getValueAt(int row, int col) { return rowData[row][col]; }
            public boolean isCellEditable(int row, int column) { return true; }
            public void setValueAt(Object value, int row, int col) {
                rowData[row][col] = value;
                fireTableCellUpdated(row, col);
            }
        });
    }

通過以上的源碼我們可以看到,它是繼承了AbstractTableModel，而AbstractTableModel中的getColumnClass方法返回的就是一個Object.class，所以無論傳入什么內容，JTable在顯示的時候都是通過字符串去顯示。

AbstractTableModel的getColumnClass方法:

package org.plx.jtable;

import java.awt.Dimension;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.BoxLayout;
import javax.swing.ButtonGroup;
import javax.swing.JCheckBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.JTextArea;
import javax.swing.ListSelectionModel;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
import javax.swing.plaf.metal.MetalLookAndFeel;
import javax.swing.table.AbstractTableModel;

@SuppressWarnings("serial")
public class TableSelectionDemo extends JPanel implements ActionListener {
    private JTable table;
    private JCheckBox rowCheck;
    private JCheckBox columnCheck;
    private JCheckBox cellCheck;
    private ButtonGroup buttonGroup;
    private JTextArea output;

    public TableSelectionDemo() {
        setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
        table = new JTable(new MyTableModel());
        table.setPreferredScrollableViewportSize(new Dimension(500, 70));
        table.setFillsViewportHeight(true);
        table.getSelectionModel().addListSelectionListener(new RowListener());
        table.getColumnModel().getSelectionModel()
                .addListSelectionListener(new ColumnListener());
        add(new JScrollPane(table));
        

        add(new JLabel("Selection Mode"));
        buttonGroup = new ButtonGroup();
        //可以選中多行，使用ctrl或者shift都可以進行選擇，默認情況下就是可以選擇多行
        addRadio("Multiple Interval Selection").setSelected(true);
        //只能選中單行
        addRadio("Single Selection");
        //只能選中連續的多行
        addRadio("Single Interval Selection");
        
        
        add(new JLabel("Selection Options"));
        
        
        //默認情況下就是以行為單位進行選擇
        rowCheck = addCheckBox("Row Selection");
        rowCheck.setSelected(true);
        
        columnCheck = addCheckBox("Column Selection");
        
        
        cellCheck = addCheckBox("Cell Selection");
        cellCheck.setEnabled(false);


        
        output = new JTextArea(5, 40);
        output.setEditable(false);
        add(new JScrollPane(output));
    }

    private JCheckBox addCheckBox(String text) {
        JCheckBox checkBox = new JCheckBox(text);
        checkBox.addActionListener(this);
        add(checkBox);
        return checkBox;
    }

    private JRadioButton addRadio(String text) {
        JRadioButton b = new JRadioButton(text);
        b.addActionListener(this);
        buttonGroup.add(b);
        add(b);
        return b;
    }

    public void actionPerformed(ActionEvent event) {
        String command = event.getActionCommand();
        // Cell selection is disabled in Multiple Interval Selection
        // mode. The enabled state of cellCheck is a convenient flag
        // for this status.
        if ("Row Selection" == command) {
            table.setRowSelectionAllowed(rowCheck.isSelected());
            // In MIS mode, column selection allowed must be the
            // opposite of row selection allowed.
            if (!cellCheck.isEnabled()) {
                table.setColumnSelectionAllowed(!rowCheck.isSelected());
            }
        } else if ("Column Selection" == command) {
            table.setColumnSelectionAllowed(columnCheck.isSelected());
            // In MIS mode, row selection allowed must be the
            // opposite of column selection allowed.
            if (!cellCheck.isEnabled()) {
                table.setRowSelectionAllowed(!columnCheck.isSelected());
            }
        } else if ("Cell Selection" == command) {
            table.setCellSelectionEnabled(cellCheck.isSelected());
        } else if ("Multiple Interval Selection" == command) {
            table.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
            // If cell selection is on, turn it off.
            if (cellCheck.isSelected()) {
                cellCheck.setSelected(false);
                table.setCellSelectionEnabled(false);
            }
            // And don't let it be turned back on.
            cellCheck.setEnabled(false);
        } else if ("Single Interval Selection" == command) {
            table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
            // Cell selection is ok in this mode.
            cellCheck.setEnabled(true);
        } else if ("Single Selection" == command) {
            table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
            // Cell selection is ok in this mode.
            cellCheck.setEnabled(true);
        }

        // Update checkboxes to reflect selection mode side effects.
        rowCheck.setSelected(table.getRowSelectionAllowed());
        columnCheck.setSelected(table.getColumnSelectionAllowed());
        if (cellCheck.isEnabled()) {
            cellCheck.setSelected(table.getCellSelectionEnabled());
        }
    }

    private void outputSelection() {
        output.append(String.format("Lead: %d, %d. ", table.getSelectionModel()
                .getLeadSelectionIndex(), table.getColumnModel()
                .getSelectionModel().getLeadSelectionIndex()));
        output.append("Rows:");
        for (int c : table.getSelectedRows()) {
            output.append(String.format(" %d", c));
        }
        output.append(". Columns:");
        for (int c : table.getSelectedColumns()) {
            output.append(String.format(" %d", c));
        }
        output.append(".\n");
    }

    private class RowListener implements ListSelectionListener {
        public void valueChanged(ListSelectionEvent event) {
            if (event.getValueIsAdjusting()) {
                return;
            }
            output.append("ROW SELECTION EVENT. ");
            outputSelection();
        }
    }

    private class ColumnListener implements ListSelectionListener {
        public void valueChanged(ListSelectionEvent event) {
            if (event.getValueIsAdjusting()) {
                return;
            }
            output.append("COLUMN SELECTION EVENT. ");
            outputSelection();
        }
    }

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

        @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) {
            data[row][col] = value;
            fireTableCellUpdated(row, col);
        }

    }

    /**
     * Create the GUI and show it. For thread safety, this method should be
     * invoked from the event-dispatching thread.
     */
    private static void createAndShowGUI() {
        try {
            UIManager.setLookAndFeel(new MetalLookAndFeel());
            JFrame frame = new JFrame("TableSelectionDemo");
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            TableSelectionDemo newContentPane = new TableSelectionDemo();
            newContentPane.setOpaque(true); // content panes must be opaque
            frame.setContentPane(newContentPane);

            // Display the window.
            frame.pack();
            frame.setVisible(true);
        } catch (UnsupportedLookAndFeelException e) {
            throw new RuntimeException(e);
        }

    }

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

以上代碼的核心是理解API中的幾個方法:

selectRowAllowed是否允許選中行,selectColumnAllowed是否選中列，當設置兩個方法都為true的時候,那么此時就是設置你選中的是單元格.如果兩個都設置false，那么就表示什么都無法選中。最后，如果你只能選中一個單元格,還需要設置selectListModel為singleSelection，對於singleSelection方法中的參數是通過獲取到ListSelectionModel中的常量來完成設置。

package javax.swing;

import javax.swing.event.*;

/**
 * This interface represents the current state of the
 * selection for any of the components that display a
 * list of values with stable indices.  The selection is
 * modeled as a set of intervals, each interval represents
 * a contiguous range of selected list elements.
 * The methods for modifying the set of selected intervals
 * all take a pair of indices, index0 and index1, that represent
 * a closed interval, i.e. the interval includes both index0 and
 * index1.
 *
 * @author Hans Muller
 * @author Philip Milne
 * @see DefaultListSelectionModel
 */

public interface ListSelectionModel
{
    /**
     * A value for the selectionMode property: select one list index
     * at a time.
     *
     * @see #setSelectionMode
     */
    int SINGLE_SELECTION = 0;

    /**
     * A value for the selectionMode property: select one contiguous
     * range of indices at a time.
     *
     * @see #setSelectionMode
     */
    int SINGLE_INTERVAL_SELECTION = 1;

    /**
     * A value for the selectionMode property: select one or more
     * contiguous ranges of indices at a time.
     *
     * @see #setSelectionMode
     */
    int MULTIPLE_INTERVAL_SELECTION = 2;


    /**
     * Changes the selection to be between {@code index0} and {@code index1}
     * inclusive. {@code index0} doesn't have to be less than or equal to
     * {@code index1}.
     * <p>
     * In {@code SINGLE_SELECTION} selection mode, only the second index
     * is used.
     * <p>
     * If this represents a change to the current selection, then each
     * {@code ListSelectionListener} is notified of the change.
     *
     * @param index0 one end of the interval.
     * @param index1 other end of the interval
     * @see #addListSelectionListener
     */
    void setSelectionInterval(int index0, int index1);


    /**
     * Changes the selection to be the set union of the current selection
     * and the indices between {@code index0} and {@code index1} inclusive.
     * {@code index0} doesn't have to be less than or equal to {@code index1}.
     * <p>
     * In {@code SINGLE_SELECTION} selection mode, this is equivalent
     * to calling {@code setSelectionInterval}, and only the second index
     * is used. In {@code SINGLE_INTERVAL_SELECTION} selection mode, this
     * method behaves like {@code setSelectionInterval}, unless the given
     * interval is immediately adjacent to or overlaps the existing selection,
     * and can therefore be used to grow the selection.
     * <p>
     * If this represents a change to the current selection, then each
     * {@code ListSelectionListener} is notified of the change.
     *
     * @param index0 one end of the interval.
     * @param index1 other end of the interval
     * @see #addListSelectionListener
     * @see #setSelectionInterval
     */
    void addSelectionInterval(int index0, int index1);


    /**
     * Changes the selection to be the set difference of the current selection
     * and the indices between {@code index0} and {@code index1} inclusive.
     * {@code index0} doesn't have to be less than or equal to {@code index1}.
     * <p>
     * In {@code SINGLE_INTERVAL_SELECTION} selection mode, if the removal
     * would produce two disjoint selections, the removal is extended through
     * the greater end of the selection. For example, if the selection is
     * {@code 0-10} and you supply indices {@code 5,6} (in any order) the
     * resulting selection is {@code 0-4}.
     * <p>
     * If this represents a change to the current selection, then each
     * {@code ListSelectionListener} is notified of the change.
     *
     * @param index0 one end of the interval.
     * @param index1 other end of the interval
     * @see #addListSelectionListener
     */
    void removeSelectionInterval(int index0, int index1);


    /**
     * Returns the first selected index or -1 if the selection is empty.
     */
    int getMinSelectionIndex();


    /**
     * Returns the last selected index or -1 if the selection is empty.
     */
    int getMaxSelectionIndex();


    /**
     * Returns true if the specified index is selected.
     */
    boolean isSelectedIndex(int index);


    /**
     * Return the first index argument from the most recent call to
     * setSelectionInterval(), addSelectionInterval() or removeSelectionInterval().
     * The most recent index0 is considered the "anchor" and the most recent
     * index1 is considered the "lead".  Some interfaces display these
     * indices specially, e.g. Windows95 displays the lead index with a
     * dotted yellow outline.
     *
     * @see #getLeadSelectionIndex
     * @see #setSelectionInterval
     * @see #addSelectionInterval
     */
    int getAnchorSelectionIndex();


    /**
     * Set the anchor selection index.
     *
     * @see #getAnchorSelectionIndex
     */
    void setAnchorSelectionIndex(int index);


    /**
     * Return the second index argument from the most recent call to
     * setSelectionInterval(), addSelectionInterval() or removeSelectionInterval().
     *
     * @see #getAnchorSelectionIndex
     * @see #setSelectionInterval
     * @see #addSelectionInterval
     */
    int getLeadSelectionIndex();

    /**
     * Set the lead selection index.
     *
     * @see #getLeadSelectionIndex
     */
    void setLeadSelectionIndex(int index);

    /**
     * Change the selection to the empty set.  If this represents
     * a change to the current selection then notify each ListSelectionListener.
     *
     * @see #addListSelectionListener
     */
    void clearSelection();

    /**
     * Returns true if no indices are selected.
     */
    boolean isSelectionEmpty();

    /**
     * Insert length indices beginning before/after index.  This is typically
     * called to sync the selection model with a corresponding change
     * in the data model.
     */
    void insertIndexInterval(int index, int length, boolean before);

    /**
     * Remove the indices in the interval index0,index1 (inclusive) from
     * the selection model.  This is typically called to sync the selection
     * model width a corresponding change in the data model.
     */
    void removeIndexInterval(int index0, int index1);

    /**
     * Sets the {@code valueIsAdjusting} property, which indicates whether
     * or not upcoming selection changes should be considered part of a single
     * change. The value of this property is used to initialize the
     * {@code valueIsAdjusting} property of the {@code ListSelectionEvent}s that
     * are generated.
     * <p>
     * For example, if the selection is being updated in response to a user
     * drag, this property can be set to {@code true} when the drag is initiated
     * and set to {@code false} when the drag is finished. During the drag,
     * listeners receive events with a {@code valueIsAdjusting} property
     * set to {@code true}. At the end of the drag, when the change is
     * finalized, listeners receive an event with the value set to {@code false}.
     * Listeners can use this pattern if they wish to update only when a change
     * has been finalized.
     * <p>
     * Setting this property to {@code true} begins a series of changes that
     * is to be considered part of a single change. When the property is changed
     * back to {@code false}, an event is sent out characterizing the entire
     * selection change (if there was one), with the event's
     * {@code valueIsAdjusting} property set to {@code false}.
     *
     * @param valueIsAdjusting the new value of the property
     * @see #getValueIsAdjusting
     * @see javax.swing.event.ListSelectionEvent#getValueIsAdjusting
     */
    void setValueIsAdjusting(boolean valueIsAdjusting);

    /**
     * Returns {@code true} if the selection is undergoing a series of changes.
     *
     * @return true if the selection is undergoing a series of changes
     * @see #setValueIsAdjusting
     */
    boolean getValueIsAdjusting();

    /**
     * Sets the selection mode. The following list describes the accepted
     * selection modes:
     * <ul>
     * <li>{@code ListSelectionModel.SINGLE_SELECTION} -
     *   Only one list index can be selected at a time. In this mode,
     *   {@code setSelectionInterval} and {@code addSelectionInterval} are
     *   equivalent, both replacing the current selection with the index
     *   represented by the second argument (the "lead").
     * <li>{@code ListSelectionModel.SINGLE_INTERVAL_SELECTION} -
     *   Only one contiguous interval can be selected at a time.
     *   In this mode, {@code addSelectionInterval} behaves like
     *   {@code setSelectionInterval} (replacing the current selection),
     *   unless the given interval is immediately adjacent to or overlaps
     *   the existing selection, and can therefore be used to grow it.
     * <li>{@code ListSelectionModel.MULTIPLE_INTERVAL_SELECTION} -
     *   In this mode, there's no restriction on what can be selected.
     * </ul>
     *
     * @see #getSelectionMode
     * @throws IllegalArgumentException if the selection mode isn't
     *         one of those allowed
     */
    void setSelectionMode(int selectionMode);

    /**
     * Returns the current selection mode.
     *
     * @return the current selection mode
     * @see #setSelectionMode
     */
    int getSelectionMode();

    /**
     * Add a listener to the list that's notified each time a change
     * to the selection occurs.
     *
     * @param x the ListSelectionListener
     * @see #removeListSelectionListener
     * @see #setSelectionInterval
     * @see #addSelectionInterval
     * @see #removeSelectionInterval
     * @see #clearSelection
     * @see #insertIndexInterval
     * @see #removeIndexInterval
     */
    void addListSelectionListener(ListSelectionListener x);

    /**
     * Remove a listener from the list that's notified each time a
     * change to the selection occurs.
     *
     * @param x the ListSelectionListener
     * @see #addListSelectionListener
     */
    void removeListSelectionListener(ListSelectionListener x);
}

 

TableModel：

在前面我們已經提到過TableModel是用來管理真實的數據.我們在實際的開發中通常會使用DefaultTableModel。在創建JTable的時候,如果你傳入的是一個Object[]，那么底層維護的TableModel是一個AbstractModel的匿名內部類，這才前面已經提到，但是如果你傳入的是Vector，那么底層維護的是DefaultTableModel.

底層源碼:

  public JTable(Vector rowData, Vector columnNames) {
        this(new DefaultTableModel(rowData, columnNames));
    }

但是我們最希望的是直接丟一個對象就去，然后顯示。下面我們就自己編寫一個TableModel來完成一下的操作(當然，如果你想要你的程序更加的靈活，那么在TableModel中使用反射和內省機制吧)。對於自己實現TableModel，我們通常會去繼承AbstractTableModel.

下面我們自己編寫一個基於面向對象的TableModel，然后你再拿和傳統的方式去比較，讓你馬上感覺從Jdbc上升到Hibernate的級別。當然，要編寫一個通用的組件可能還需要測試，這里我這是提供一種思路來給大家參考而已。

package org.plx.jtable;

import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;

public class User implements PropertyChangeListener{
    
    
    @BeanColumn(name = "用戶編號", index = 0)
    private Integer id;
    
    
    @BeanColumn(name = "用戶姓名", index = 1)
    private String username;
    
    @BeanColumn(name = "用戶密碼", index = 2)
    private String password;
    
    
    @BeanColumn(name = "用戶年齡", index = 3)
    private int age;

    //這里如果取名字為is開頭，在introspector中可能會存在BUG
    @BeanColumn(name = "婚否", index = 4)
    private Boolean marry;
    
    
    public User() {}
    

    public User(Integer id, String username, String password, int age,
            Boolean marry) {
        this.id = id;
        this.username = username;
        this.password = password;
        this.age = age;
        this.marry = marry;
    }



    public Boolean getMarry() {
        return marry;
    }

    public void setMarry(Boolean marry) {
        this.marry = marry;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public void propertyChange(PropertyChangeEvent evt) {
        
    }


    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((id == null) ? 0 : id.hashCode());
        return result;
    }


    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        User other = (User) obj;
        if (id == null) {
            if (other.id != null)
                return false;
        } else if (!id.equals(other.id))
            return false;
        return true;
    }
    
    

}

在這里，我自己定義了一個Annotation,用來定義這個屬性在JTable中對應的表頭名字。

 

package org.plx.jtable;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface BeanColumn {

    String name();//在JTable中的表頭名字
    int index();//在表頭的索引
}

好了，下面我們來測試一下寫的程序。

package org.plx.jtable;

import java.awt.BorderLayout;
import java.awt.FlowLayout;
import java.awt.Panel;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;

import javax.swing.AbstractButton;
import javax.swing.ButtonGroup;
import javax.swing.JButton;
import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JRadioButton;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.JTextField;
import javax.swing.table.AbstractTableModel;
import javax.swing.table.TableModel;

/**
 * 基於對象格式的TableModel
 * 
 * @author Administrator
 * 
 */
public class TableModelDemo {

    public static void main(String[] args) {

        final int WIDTH = 700;
        final int HEIGHT = 500;
        final int USER_SIZE = 10;

        final JFrame frame = new JFrame();
        frame.setTitle("基於面向對象的TableModel測試");
        frame.setSize(WIDTH, HEIGHT);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        final JTable table = new JTable();
        table.setFillsViewportHeight(true);
        table.setRowHeight(30);
        List<User> users = new ArrayList<User>();
        for (int i = 0; i < USER_SIZE; i++) {
            User u = new User();
            u.setId(i);
            u.setUsername("username" + i);
            u.setPassword("123");
            u.setAge(i + 20);
            u.setMarry(i % 2 == 0);
            users.add(u);
        }

        final TableModel tableModel = new MyTableModel<User>(users);
        table.setModel(tableModel);

        frame.add(new JScrollPane(table));

        Panel panel = new Panel();

        JButton addBtn = new JButton("添加用戶");
        JButton deleteBtn = new JButton("刪除用戶（按照行來刪除）");
        JButton deleteBtn2 = new JButton("刪除用戶（按照對象來刪除）");
        JButton updateBtn = new JButton("更新用戶");

        panel.add(addBtn);
        panel.add(deleteBtn);
        panel.add(deleteBtn2);
        panel.add(updateBtn);

        addBtn.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                JDialog dialog = new JDialog(frame, true);
                dialog.setSize(300, 300);

                JLabel idLab = new JLabel("用戶編號:");
                final JTextField idTextField = new JTextField(25);

                JLabel nameLab = new JLabel("用戶姓名");
                final JTextField nameTextField = new JTextField(25);

                JLabel passwordLab = new JLabel("用戶密碼:");
                final JTextField passwordTextField = new JTextField(25);

                JLabel ageLab = new JLabel("用戶年齡:");
                final JTextField ageTextField = new JTextField(25);

                final JRadioButton marry = new JRadioButton();
                marry.setText("已婚");
                marry.setSelected(true);

                final JRadioButton noMarry = new JRadioButton();
                noMarry.setText("未婚");

                final ButtonGroup group = new ButtonGroup();
                group.add(marry);
                group.add(noMarry);

                JButton button = new JButton("確認添加");

                button.addActionListener(new ActionListener() {
                    @SuppressWarnings({ "unchecked", "rawtypes" })
                    @Override
                    public void actionPerformed(ActionEvent e) {
                        Integer id = Integer.parseInt(idTextField.getText());
                        String username = nameTextField.getText();
                        String password = passwordTextField.getText();
                        int age = Integer.parseInt(ageTextField.getText());
                        boolean marry = false;
                        Enumeration<AbstractButton> en = group.getElements();
                        for (; en.hasMoreElements();) {
                            AbstractButton ab = en.nextElement();
                            if (ab.isSelected()) {
                                marry = ab.getText().equals("已婚") ? true
                                        : false;
                                break;
                            }
                        }
                        User user = new User(id, username, password, age, marry);
                        ((MyTableModel) tableModel).addRow(user);
                    }
                });

                dialog.setLayout(new FlowLayout());
                dialog.add(idLab);
                dialog.add(idTextField);
                dialog.add(nameLab);
                dialog.add(nameTextField);
                dialog.add(passwordLab);
                dialog.add(passwordTextField);
                dialog.add(ageLab);
                dialog.add(ageTextField);
                dialog.add(marry);
                dialog.add(noMarry);

                dialog.add(button);

                dialog.setVisible(true);
            }
        });
        
        deleteBtn.addActionListener(new ActionListener() {
            @SuppressWarnings("rawtypes")
            @Override
            public void actionPerformed(ActionEvent e) {
                int rowIndex = table.getSelectedRow();
                ((MyTableModel)table.getModel()).deleteRow(rowIndex);
            }
        });
        
        
        deleteBtn2.addActionListener(new ActionListener() {
            @SuppressWarnings({ "rawtypes", "unchecked" })
            @Override
            public void actionPerformed(ActionEvent e) {
                int rowIndex = table.getSelectedRow();
                
                MyTableModel tableModel = ((MyTableModel)table.getModel());
                Integer id = (Integer) tableModel.getValueAt(rowIndex, 0);
                User u = new User();
                u.setId(id);
                tableModel.deleteRow(u);
            }
        });
        
        updateBtn.addActionListener(new ActionListener() {
            
            @Override
            public void actionPerformed(ActionEvent e) {
                final int rowIndex = table.getSelectedRow();
                
                @SuppressWarnings("rawtypes")
                final MyTableModel tableModel = ((MyTableModel)table.getModel());
                /*
                 //傳統的方式是需要通過
                    for(int i = 0;i < tableModel.getColumnCount();i++){
                        tableModel.getValueAt(rowIndex, i);
                    }
                */
                //現在我們采用基於OO的獲取
                User user = (User) tableModel.getObjbyRowIndex(rowIndex);
                
                JDialog dialog = new JDialog(frame, true);
                dialog.setSize(300, 300);

                JLabel idLab = new JLabel("用戶編號:");
                final JTextField idTextField = new JTextField(String.valueOf(user.getId()),25);
                

                JLabel nameLab = new JLabel("用戶姓名");
                final JTextField nameTextField = new JTextField(user.getUsername(),25);

                JLabel passwordLab = new JLabel("用戶密碼:");
                final JTextField passwordTextField = new JTextField(user.getPassword(),25);

                JLabel ageLab = new JLabel("用戶年齡:");
                final JTextField ageTextField = new JTextField(String.valueOf(user.getAge()),25);

                final JRadioButton marry = new JRadioButton();
                marry.setText("已婚");

                final JRadioButton noMarry = new JRadioButton();
                noMarry.setText("未婚");
                
                if(user.getMarry()){
                    marry.setSelected(true);
                }
                else{
                    noMarry.setSelected(true);
                }

                final ButtonGroup group = new ButtonGroup();
                group.add(marry);
                group.add(noMarry);

                JButton button = new JButton("確認更新");

                button.addActionListener(new ActionListener() {
                    @SuppressWarnings({ "unchecked"})
                    @Override
                    public void actionPerformed(ActionEvent e) {
                        Integer id = Integer.parseInt(idTextField.getText());
                        String username = nameTextField.getText();
                        String password = passwordTextField.getText();
                        int age = Integer.parseInt(ageTextField.getText());
                        boolean marry = false;
                        Enumeration<AbstractButton> en = group.getElements();
                        for (; en.hasMoreElements();) {
                            AbstractButton ab = en.nextElement();
                            if (ab.isSelected()) {
                                marry = ab.getText().equals("已婚") ? true
                                        : false;
                                break;
                            }
                        }
                        User user = new User(id, username, password, age, marry);
                        tableModel.update(rowIndex, user);
                    }
                });

                dialog.setLayout(new FlowLayout());
                dialog.add(idLab);
                dialog.add(idTextField);
                dialog.add(nameLab);
                dialog.add(nameTextField);
                dialog.add(passwordLab);
                dialog.add(passwordTextField);
                dialog.add(ageLab);
                dialog.add(ageTextField);
                dialog.add(marry);
                dialog.add(noMarry);

                dialog.add(button);

                dialog.setVisible(true);
            }
        });

        frame.add(panel, BorderLayout.SOUTH);

        frame.setVisible(true);
    }

}

/**
 * 請將你傳入的對象以JavaBean的形式創建
 * 
 * 自己定義的TableModel，可以直接放入對象
 * 
 * @author Administrator
 * 
 * @param <T>
 */
@SuppressWarnings("serial")
class MyTableModel<T> extends AbstractTableModel {
    private List<T> objs;
    private BeanInfo beanInfo;
    private Map<Integer, String> columnInfo = null;
    private Map<Integer, Integer> propertyInfo = null;
    private PropertyDescriptor[] pd = null;
    private int columnCount;
    @SuppressWarnings("unused")
    private Class<T> clazz;

    public MyTableModel() {
        try {
            columnInfo = new TreeMap<Integer, String>();
            propertyInfo = new HashMap<Integer, Integer>();
            Field[] fields = getClz().getDeclaredFields();
            beanInfo = Introspector.getBeanInfo(getClz());
            pd = beanInfo.getPropertyDescriptors();
            for (Field f : fields) {
                if (f.isAnnotationPresent(BeanColumn.class)) {
                    // 這里沒有直接寫成columnCOunt = fileds.length是因為可能某些字段不用來顯示
                    columnCount++;
                    // 獲取到Annotation
                    BeanColumn bc = f.getAnnotation(BeanColumn.class);
                    // 獲取到該屬性對應的列名稱
                    String columnName = bc.name();
                    // 獲取該名稱在Table中的索引值
                    int index = bc.index();
                    // 通過TreeMap將列名稱以及它的索引存儲起來,用來顯示表頭信息
                    columnInfo.put(index, columnName);
                    /*
                     * 判斷該屬性在beanInfo中的索引
                     * 最后顯示是通過columnIndex--PropertyDescriptor數組中的索引，
                     * 然后獲取到PropertyDescriptor來獲取到具體的數據
                     */
                    for (int i = 0; i < pd.length; i++) {
                        String fieldName = null;
                        if (f.getName().startsWith("is")) {
                            fieldName = f
                                    .getName()
                                    .substring(
                                            f.getName().indexOf("is")
                                                    + "is".length())
                                    .toLowerCase();
                        } else {
                            fieldName = f.getName();
                        }
                        if (fieldName.equals(pd[i].getName())) {
                            propertyInfo.put(index, i);
                        }
                    }
                }
            }
        } catch (IntrospectionException e) {
            e.printStackTrace();
        }
    }

    public MyTableModel(List<T> list) {
        this();
        this.objs = list;
    }

    
    /**
     * 獲取到泛型中的Class對象
     * 這里還未解決，暫時先寫死
     * @return
     */
    @SuppressWarnings("unchecked")
    private Class<T> getClz() {
        return (Class<T>) User.class;
    }

    /**
     * 返回對象集合
     * 
     * @return
     */
    public List<T> getObjs() {
        return objs;
    }

    /**
     * 設置對象集合
     * 
     * @param objs
     */
    public void setObjs(List<T> objs) {
        this.objs = objs;
    }

    /**
     * 獲取總的行數
     */
    @Override
    public int getRowCount() {
        if (objs != null) {
            return objs.size();
        } else {
            return 0;
        }
    }

    /**
     * 獲取總的列數
     */
    @Override
    public int getColumnCount() {
        return columnCount;
    }

    /**
     * 返回單元格的數據做顯示
     */
    @Override
    public Object getValueAt(int rowIndex, int columnIndex) {
        try {
            if (objs != null) {
                // 獲取到行數據
                T t = objs.get(rowIndex);
                Integer propertyIndex = propertyInfo.get(columnIndex);
                return pd[propertyIndex].getReadMethod().invoke(t,
                        new Object[] {});
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 返回類的名稱
     */
    @Override
    public String getColumnName(int column) {
        return columnInfo.get(column);
    }

    /**
     * 返回TableCellRender渲染的類型
     */
    @Override
    public Class<?> getColumnClass(int columnIndex) {
        if (pd != null) {
            return pd[propertyInfo.get(columnIndex)].getPropertyType();
        }
        return Object.class;
    }

    /**
     * DefaultTableModel底層也是這樣去完成的
     */
    @Override
    public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
        try {
            T t = objs.get(rowIndex);
            int propIndex = propertyInfo.get(columnIndex);
            pd[propIndex].getWriteMethod().invoke(t, new Object[] { aValue });
            // 當數據更新完成之后完成更新視圖層
            fireTableCellUpdated(rowIndex, columnIndex);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 設置是否可以編輯
     */
    @Override
    public boolean isCellEditable(int rowIndex, int columnIndex) {
        return true;
    }

    public void addRow(T t) {
        if (t == null) {
            throw new RuntimeException("添加失敗");
        }
        objs.add(t);
        fireTableRowsInserted(getRowCount() - 1, getRowCount() - 1);
    }

    /**
     * 提供重載方法，讓用戶去調用
     * 
     * @param data
     */
    public void addRow(List<Object> data) {

    }

    public void addRow(Object[] data) {

    }
    
    /**
     * 根據對象來刪除
     * 此時需要重寫對象的equals和hashCode方法,因為底層ArrayLiST判斷對象是否
     * 相等是通過equals方法來進行比較
     * @param t
     */
    public void deleteRow(T t){
        this.objs.remove(t);
        fireTableRowsDeleted(this.getColumnCount(),this.getColumnCount());
    }
    
    /**
     * 根據行來刪除
     * @param rowIndex
     */
    public void deleteRow(int rowIndex){
        this.objs.remove(rowIndex);
        fireTableRowsDeleted(this.getColumnCount(),this.getColumnCount());
    }

    public T getObjbyRowIndex(int rowIndex){
        return objs.get(rowIndex);
    }
    
    /**
     * 更新行數據
     * @param rowIndex
     * @param t
     */
    public void update(int rowIndex,T t){
        this.objs.set(rowIndex, t);
        fireTableRowsUpdated(this.getColumnCount() - 1, this.getRowCount() - 1);
    }
    
}

 如果我們自己編寫TableModel的時候，在更新數據之后還得調用方法讓去通知視圖層去重新顯示，我們在繼承了AbstractTableModel之后就使用了以下的方法。

 

Method	Change
fireTableCellUpdated	Update of specified cell.
fireTableRowsUpdated	Update of specified rows
fireTableDataChanged	Update of entire table (data only).
fireTableRowsInserted	New rows inserted.
fireTableRowsDeleted	Existing rows Deleted
fireTableStructureChanged	Invalidate entire table, both data and structure.

 下面介紹兩個概念：一個叫渲染，一個叫編輯。

我們先介紹渲染:我們需要知道的是其實每一個單元格都是繪制出來的，而每一個單元格其實也是一個組件(Component)。Swing為了性能的原因，對於每一列使用一種單元格渲染器來渲染所有的單元格。這是我們要介紹的重點。

JTable默認的渲染器是DefaultTableCellRenderer，通過查看源碼我們會發現原來這是一個JLabel啊！

/**
 * @(#)DefaultTableCellRenderer.java    1.48 08/09/18
 *
 * Copyright 2006 Sun Microsystems, Inc. All rights reserved.
 * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */

package javax.swing.table;

import javax.swing.*;
import javax.swing.table.TableCellRenderer;
import javax.swing.border.*;

import java.awt.Component;
import java.awt.Color;
import java.awt.Rectangle;

import java.io.Serializable;
import sun.swing.DefaultLookup;


/***
 * The standard class for rendering (displaying) individual cells
 * in a <code>JTable</code>.
 * <p>
 *
 * <strong><a name="override">Implementation Note:</a></strong>
 * This class inherits from <code>JLabel</code>, a standard component class. 
 * However <code>JTable</code> employs a unique mechanism for rendering
 * its cells and therefore requires some slightly modified behavior
 * from its cell renderer.  
 * The table class defines a single cell renderer and uses it as a 
 * as a rubber-stamp for rendering all cells in the table; 
 * it renders the first cell,
 * changes the contents of that cell renderer, 
 * shifts the origin to the new location, re-draws it, and so on.
 * The standard <code>JLabel</code> component was not
 * designed to be used this way and we want to avoid 
 * triggering a <code>revalidate</code> each time the
 * cell is drawn. This would greatly decrease performance because the
 * <code>revalidate</code> message would be
 * passed up the hierarchy of the container to determine whether any other
 * components would be affected.  
 * As the renderer is only parented for the lifetime of a painting operation
 * we similarly want to avoid the overhead associated with walking the
 * hierarchy for painting operations.
 * So this class
 * overrides the <code>validate</code>, <code>invalidate</code>,
 * <code>revalidate</code>, <code>repaint</code>, and
 * <code>firePropertyChange</code> methods to be 
 * no-ops and override the <code>isOpaque</code> method solely to improve
 * performance.  If you write your own renderer,
 * please keep this performance consideration in mind.
 * <p>
 *
 * <strong>Warning:</strong>
 * Serialized objects of this class will not be compatible with
 * future Swing releases. The current serialization support is
 * appropriate for short term storage or RMI between applications running
 * the same version of Swing.  As of 1.4, support for long term storage
 * of all JavaBeans<sup><font size="-2">TM</font></sup>
 * has been added to the <code>java.beans</code> package.
 * Please see {@link java.beans.XMLEncoder}.
 *
 * @version 1.48 09/18/08
 * @author Philip Milne 
 * @see JTable
 */
public class DefaultTableCellRenderer extends JLabel
    implements TableCellRenderer, Serializable
{

   /***
    * An empty <code>Border</code>. This field might not be used. To change the
    * <code>Border</code> used by this renderer override the 
    * <code>getTableCellRendererComponent</code> method and set the border
    * of the returned component directly.
    */
    private static final Border SAFE_NO_FOCUS_BORDER = new EmptyBorder(1, 1, 1, 1);
    private static final Border DEFAULT_NO_FOCUS_BORDER = new EmptyBorder(1, 1, 1, 1);
    protected static Border noFocusBorder = DEFAULT_NO_FOCUS_BORDER;

    // We need a place to store the color the JLabel should be returned 
    // to after its foreground and background colors have been set 
    // to the selection background color. 
    // These ivars will be made protected when their names are finalized. 
    private Color unselectedForeground; 
    private Color unselectedBackground; 

    /***
     * Creates a default table cell renderer.
     */
    public DefaultTableCellRenderer() {
    super();
    setOpaque(true);
        setBorder(getNoFocusBorder());
        setName("Table.cellRenderer");
    }

    private Border getNoFocusBorder() {
        Border border = DefaultLookup.getBorder(this, ui, "Table.cellNoFocusBorder");
        if (System.getSecurityManager() != null) {
            if (border != null) return border;
            return SAFE_NO_FOCUS_BORDER;
        } else if (border != null) {
            if (noFocusBorder == null || noFocusBorder == DEFAULT_NO_FOCUS_BORDER) {
                return border;
            }
        }
        return noFocusBorder;
    }

    /***
     * Overrides <code>JComponent.setForeground</code> to assign
     * the unselected-foreground color to the specified color.
     * 
     * @param c set the foreground color to this value
     */
    public void setForeground(Color c) {
        super.setForeground(c); 
        unselectedForeground = c; 
    }
    
    /***
     * Overrides <code>JComponent.setBackground</code> to assign
     * the unselected-background color to the specified color.
     *
     * @param c set the background color to this value
     */
    public void setBackground(Color c) {
        super.setBackground(c); 
        unselectedBackground = c; 
    }

    /***
     * Notification from the <code>UIManager</code> that the look and feel
     * [L&F] has changed.
     * Replaces the current UI object with the latest version from the 
     * <code>UIManager</code>.
     *
     * @see JComponent#updateUI
     */
    public void updateUI() {
        super.updateUI(); 
    setForeground(null);
    setBackground(null);
    }
    
    // implements javax.swing.table.TableCellRenderer
    /***
     *
     * Returns the default table cell renderer.
     * <p>
     * During a printing operation, this method will be called with
     * <code>isSelected</code> and <code>hasFocus</code> values of
     * <code>false</code> to prevent selection and focus from appearing
     * in the printed output. To do other customization based on whether
     * or not the table is being printed, check the return value from
     * {@link javax.swing.JComponent#isPaintingForPrint()}.
     *
     * @param table  the <code>JTable</code>
     * @param value  the value to assign to the cell at
     *            <code>[row, column]</code>
     * @param isSelected true if cell is selected
     * @param hasFocus true if cell has focus
     * @param row  the row of the cell to render
     * @param column the column of the cell to render
     * @return the default table cell renderer
     * @see javax.swing.JComponent#isPaintingForPrint()
     */
    public Component getTableCellRendererComponent(JTable table, Object value,
                          boolean isSelected, boolean hasFocus, int row, int column) {

        Color fg = null;
        Color bg = null;

        JTable.DropLocation dropLocation = table.getDropLocation();
        if (dropLocation != null
                && !dropLocation.isInsertRow()
                && !dropLocation.isInsertColumn()
                && dropLocation.getRow() == row
                && dropLocation.getColumn() == column) {

            fg = DefaultLookup.getColor(this, ui, "Table.dropCellForeground");
            bg = DefaultLookup.getColor(this, ui, "Table.dropCellBackground");

            isSelected = true;
        }

        if (isSelected) {
            super.setForeground(fg == null ? table.getSelectionForeground()
                                           : fg);
            super.setBackground(bg == null ? table.getSelectionBackground()
                                           : bg);
    } else {
            Color background = unselectedBackground != null
                                    ? unselectedBackground
                                    : table.getBackground();
            if (background == null || background instanceof javax.swing.plaf.UIResource) {
                Color alternateColor = DefaultLookup.getColor(this, ui, "Table.alternateRowColor");
                if (alternateColor != null && row % 2 == 0)
                    background = alternateColor;
            }
            super.setForeground(unselectedForeground != null
                                    ? unselectedForeground
                                    : table.getForeground());
            super.setBackground(background);
    }

    setFont(table.getFont());

    if (hasFocus) {
            Border border = null;
            if (isSelected) {
                border = DefaultLookup.getBorder(this, ui, "Table.focusSelectedCellHighlightBorder");
            }
            if (border == null) {
                border = DefaultLookup.getBorder(this, ui, "Table.focusCellHighlightBorder");
            }
            setBorder(border);

        if (!isSelected && table.isCellEditable(row, column)) {
                Color col;
                col = DefaultLookup.getColor(this, ui, "Table.focusCellForeground");
                if (col != null) {
                    super.setForeground(col);
                }
                col = DefaultLookup.getColor(this, ui, "Table.focusCellBackground");
                if (col != null) {
                    super.setBackground(col);
                }
        }
    } else {
            setBorder(getNoFocusBorder());
    }

        setValue(value); 

    return this;
    }
    
    /**
     * The following methods are overridden as a performance measure to 
     * to prune code-paths are often called in the case of renders
     * but which we know are unnecessary.  Great care should be taken
     * when writing your own renderer to weigh the benefits and 
     * drawbacks of overriding methods like these.
     */

    /***
     * Overridden for performance reasons.
     * See the <a href="#override">Implementation Note</a> 
     * for more information.
     */
    public boolean isOpaque() { 
    Color back = getBackground();
    Component p = getParent(); 
    if (p != null) { 
        p = p.getParent(); 
    }
        
    // p should now be the JTable. 
    boolean colorMatch = (back != null) && (p != null) && 
        back.equals(p.getBackground()) && 
            p.isOpaque();
    return !colorMatch && super.isOpaque(); 
    }

    /***
     * Overridden for performance reasons.
     * See the <a href="#override">Implementation Note</a> 
     * for more information.
     *
     * @since 1.5
     */
    public void invalidate() {}

    /***
     * Overridden for performance reasons.
     * See the <a href="#override">Implementation Note</a> 
     * for more information.
     */
    public void validate() {}

    /***
     * Overridden for performance reasons.
     * See the <a href="#override">Implementation Note</a> 
     * for more information.
     */
    public void revalidate() {}

    /***
     * Overridden for performance reasons.
     * See the <a href="#override">Implementation Note</a> 
     * for more information.
     */
    public void repaint(long tm, int x, int y, int width, int height) {}

    /***
     * Overridden for performance reasons.
     * See the <a href="#override">Implementation Note</a> 
     * for more information.
     */
    public void repaint(Rectangle r) { }

    /***
     * Overridden for performance reasons.
     * See the <a href="#override">Implementation Note</a> 
     * for more information.
     *
     * @since 1.5
     */
    public void repaint() {
    }

    /***
     * Overridden for performance reasons.
     * See the <a href="#override">Implementation Note</a> 
     * for more information.
     */
    protected void firePropertyChange(String propertyName, Object oldValue, Object newValue) {    
    // Strings get interned...
    if (propertyName=="text"
                || propertyName == "labelFor"
                || propertyName == "displayedMnemonic"
                || ((propertyName == "font" || propertyName == "foreground")
                    && oldValue != newValue
                    && getClientProperty(javax.swing.plaf.basic.BasicHTML.propertyKey) != null)) {

            super.firePropertyChange(propertyName, oldValue, newValue);
        }
    }

    /***
     * Overridden for performance reasons.
     * See the <a href="#override">Implementation Note</a> 
     * for more information.
     */
    public void firePropertyChange(String propertyName, boolean oldValue, boolean newValue) { }


    /***
     * Sets the <code>String</code> object for the cell being rendered to
     * <code>value</code>.
     * 
     * @param value  the string value for this cell; if value is
     *        <code>null</code> it sets the text value to an empty string
     * @see JLabel#setText
     * 
     */
    protected void setValue(Object value) {
    setText((value == null) ? "" : value.toString());
    }
    

    /***
     * A subclass of <code>DefaultTableCellRenderer</code> that
     * implements <code>UIResource</code>.
     * <code>DefaultTableCellRenderer</code> doesn't implement
     * <code>UIResource</code>
     * directly so that applications can safely override the
     * <code>cellRenderer</code> property with
     * <code>DefaultTableCellRenderer</code> subclasses.
     * <p>
     * <strong>Warning:</strong>
     * Serialized objects of this class will not be compatible with
     * future Swing releases. The current serialization support is
     * appropriate for short term storage or RMI between applications running
     * the same version of Swing.  As of 1.4, support for long term storage
     * of all JavaBeans<sup><font size="-2">TM</font></sup>
     * has been added to the <code>java.beans</code> package.
     * Please see {@link java.beans.XMLEncoder}.
     */
    public static class UIResource extends DefaultTableCellRenderer 
        implements javax.swing.plaf.UIResource
    {
    }

}

在JTable中有這樣一段代碼:

/**
     * Creates default cell renderers for objects, numbers, doubles, dates,
     * booleans, and icons.
     * @see javax.swing.table.DefaultTableCellRenderer
     *
     */
    protected void createDefaultRenderers() {
        defaultRenderersByColumnClass = new UIDefaults(8, 0.75f);

        // Objects
        setLazyRenderer(Object.class, "javax.swing.table.DefaultTableCellRenderer$UIResource");

        // Numbers
        setLazyRenderer(Number.class, "javax.swing.JTable$NumberRenderer");

        // Doubles and Floats
        setLazyRenderer(Float.class, "javax.swing.JTable$DoubleRenderer");
        setLazyRenderer(Double.class, "javax.swing.JTable$DoubleRenderer");

        // Dates
        setLazyRenderer(Date.class, "javax.swing.JTable$DateRenderer");

        // Icons and ImageIcons
        setLazyRenderer(Icon.class, "javax.swing.JTable$IconRenderer");
        setLazyRenderer(ImageIcon.class, "javax.swing.JTable$IconRenderer");

        // Booleans
        setLazyRenderer(Boolean.class, "javax.swing.JTable$BooleanRenderer");
    }

JTableton在HashTable中存放Class對象作為KEY,渲染器的全稱作為Value,當調用TableModel中的getColumnClass的時候,然后就會去判斷到底對於這列的數據使用什么渲染方式，其實TableColumn也可以是設置CellRender。我們就來看看javax.swing.JTable$BooleanRender是怎么實現的。

static class BooleanRenderer extends JCheckBox implements TableCellRenderer, UIResource
    {
        private static final Border noFocusBorder = new EmptyBorder(1, 1, 1, 1);

        public BooleanRenderer() {
            super();
            setHorizontalAlignment(JLabel.CENTER);
            setBorderPainted(true);
        }

        public Component getTableCellRendererComponent(JTable table, Object value,
                                                       boolean isSelected, boolean hasFocus, int row, int column) {
            if (isSelected) {
                setForeground(table.getSelectionForeground());
                super.setBackground(table.getSelectionBackground());
            }
            else {
                setForeground(table.getForeground());
                setBackground(table.getBackground());
            }
            setSelected((value != null && ((Boolean)value).booleanValue()));

            if (hasFocus) {
                setBorder(UIManager.getBorder("Table.focusCellHighlightBorder"));
            } else {
                setBorder(noFocusBorder);
            }

            return this;
        }
    }

正所謂源碼面前，了無秘密。現在應該知道是怎么回事了吧。這里需要注意的是，我們返回的Class類型是包裝類，而不是原生數據類型。

好了,下面我們自己編寫兩個渲染器給大家瞧瞧。

        table.setDefaultRenderer(Object.class,
                new DefaultTableCellHeaderRenderer() {
                    @Override
                    public Component getTableCellRendererComponent(
                            JTable arg0, Object arg1, boolean arg2,
                            boolean arg3, int row, int arg5) {
                         super.getTableCellRendererComponent(
                                arg0, arg1, arg2, arg3, row, arg5);
                         if(row % 2 == 0){
                                this.setBackground(Color.BLUE);
                            }
                         return this;
                    }

                });

我們將TabeModel中的代碼所謂做修改

    /**
     * 返回TableCellRender渲染的類型
     */
    @Override
    public Class<?> getColumnClass(int columnIndex) {
//        if (pd != null) {
//            return pd[propertyInfo.get(columnIndex)].getPropertyType();
//        }
        return Object.class;
    }

怎么樣，SO Easy吧！

如果我們自己想要編寫特定的渲染器，我們可以實現TableCellRender接口來完成。這部分內容將在下篇中介紹、、、、、、、、