程序博客网 > linux中文版系统下载

Tables（二）

来源：互联网 发布：linux中文版系统下载 编辑：程序博客网 时间：2024/05/21 17:41

18.3 TableMode接口

现在我们已经了解了JTable组件的基础，现在我们可以了解其内部是如何管理数据元素的了。他是借助于实现了TableModel接口的类来完成的。

TableModel接口定义了JTable查询列头与表格单元值，并且当表格可编辑时修改单元值所需要的框架。其定义如下：

[java] view plaincopyprint?
  1. public interface TableModel {  
  2.   // Listeners   
  3.   public void addTableModelListener(TableModelListener l);  
  4.   public void removeTableModelListener(TableModelListener l);  
  5.   // Properties   
  6.   public int getColumnCount();  
  7.   public int getRowCount();  
  8.   // Other methods   
  9.   public Class getColumnClass(int columnIndex);  
  10.   public String getColumnName(int columnIndex);  
  11.   public Object getValueAt(int rowIndex, int columnIndex);  
  12.   public boolean isCellEditable(int rowIndex, int columnIndex);  
  13.   public void setValueAt(Object vValue, int rowIndex, int columnIndex);  
  14. }  

18.3.1 AbstractTableModel类
AbstractTableModel类提供了TableModel接口的基本实现。他管理TableModelListener列表以及一些TableModel方法的默认实现。当我们派生这个类时，我们所需要提供的就是实际列与行的计数以及表格模型中的特定值（getValueAt()）。列名默认为为如A，B，C，...，Z，AA，BB之类的标签，并且数据模型是只读的，除非isCellEditable()被重写。
如果我们派生AbstractTableModel并且使得数据模型是可编辑的，那么我们就要负责调用AbstractTableModel中的fireXXX()方法来保证当数据模型发生变化时TableModelListener对象都会得到通知：
[java] view plaincopyprint?
  1. public void fireTableCellUpdated(int row, int column);  
  2. public void fireTableChanged(TableModelEvent e);  
  3. public void fireTableDataChanged();  
  4. public void fireTableRowsDeleted(int firstRow, int lastRow);  
  5. public void fireTableRowsInserted(int firstRow, int lastRow);  
  6. public void fireTableRowsUpdated(int firstRow, int lastRow);  
  7. public void fireTableStructureChanged();  

当我们需要创建一个JTable时，为了重用已有的数据结构而派生AbstractTableModel并不常见。这个数据结构通常是来自JDBC查询的结果，但是并没有限制必须是这种情况。为了进行演示，下面的匿名类定义显示了我们如何将一个数据看作一个AbstractTableModel：
[java] view plaincopyprint?
  1. TableModel model = new AbstractTableModel() {  
  2.   Object rowData[][] = {  
  3.     {"one",   "ichi"},  
  4.     {"two",   "ni"},  
  5.     {"three", "san"},  
  6.     {"four",  "shi"},  
  7.     {"five",  "go"},  
  8.     {"six",   "roku"},  
  9.     {"seven", "shichi"},  
  10.     {"eight", "hachi"},  
  11.     {"nine",  "kyu"},  
  12.     {"ten",   "ju"}  
  13.   };  
  14.   Object columnNames[] = {"English", "Japanese"};  
  15.   public String getColumnName(int column) {  
  16.     return columnNames[column].toString();  
  17.   }  
  18.   public int getRowCount() {  
  19.     return rowData.length;   
  20.   }  
  21.   public int getColumnCount() {  
  22.     return columnNames.length;  
  23.   }  
  24.   public Object getValueAt(int row, int col) {  
  25.     return rowData[row][col];  
  26.   }  
  27. };  
  28. JTable table = new JTable(model);  
  29. JScrollPane scrollPane = new JScrollPane(table);  

指定固定的JTable列
现在我们已经了解了TableModel与AbstractTableModel是如何描述数据的基础了，现在我们可以创建一个JTable了，其中一些列是固定的，而另一些不是。要创建不滚动的列，我们需要将第二个表格放在JScrollPane的行头视图中。然后，当用户垂直滚动表格时，两个表格就会保持同步。两个表格需要共享他们的ListSelectionModel。 这样，当一个表格中的一行被选中时，另一个表格中的行也会自动被选中。图18-9显示了具有一个固定列与四个滚动列的表格。

生成图18-9示例的源代码显示在列表18-4中。
[java] view plaincopyprint?
  1. package swingstudy.ch18;  
  2.    
  3. import java.awt.BorderLayout;  
  4. import java.awt.Dimension;  
  5. import java.awt.EventQueue;  
  6.    
  7. import javax.swing.JFrame;  
  8. import javax.swing.JScrollPane;  
  9. import javax.swing.JTable;  
  10. import javax.swing.JViewport;  
  11. import javax.swing.ListSelectionModel;  
  12. import javax.swing.table.AbstractTableModel;  
  13. import javax.swing.table.TableModel;  
  14.    
  15. public class FixedTable {  
  16.    
  17.     /** 
  18.      * @param args 
  19.      */  
  20.     public static void main(String[] args) {  
  21.         // TODO Auto-generated method stub   
  22.         final Object rowData[][] = {  
  23.                 {"1", "one", "ichi", "un", "I", "\u4E00"},  
  24.                 {"2", "two", "ni", "deux", "II", "\u4E8C"},  
  25.                 {"3", "three", "san", "trois", "III", "\u4E09"},  
  26.                 {"4", "four", "shi", "quatre", "IV", "\u56DB"},  
  27.                 {"5", "five", "go", "cinq", "V", "\u4E94"},  
  28.                 {"6", "six", "roku", "treiza", "VI", "\u516D"},  
  29.                 {"7", "seven", "shichi", "sept", "VII", "\u4E03"},  
  30.                 {"8", "eight", "hachi", "huit", "VIII", "\u516B"},  
  31.                 {"9", "nine", "kyu", "neur", "IX", "\u4E5D"},  
  32.                 {"10", "ten", "ju", "dix", "X", "\u5341"}  
  33.         };  
  34.    
  35.         final String columnNames[] = {  
  36.                 "#", "English", "Japanese", "French", "Roman", "Kanji"    
  37.         };  
  38.    
  39.         final TableModel fixedColumnModel = new AbstractTableModel() {  
  40.             public int getColumnCount() {  
  41.                 return 1;  
  42.             }  
  43.    
  44.             public String getColumnName(int column) {  
  45.                 return columnNames[column];  
  46.             }  
  47.    
  48.             public int getRowCount() {  
  49.                 return rowData.length;  
  50.             }  
  51.    
  52.             public Object getValueAt(int row, int column) {  
  53.                 return rowData[row][column];  
  54.             }  
  55.         };  
  56.    
  57.         final TableModel mainModel = new AbstractTableModel() {  
  58.             public int getColumnCount() {  
  59.                 return columnNames.length-1;  
  60.             }  
  61.    
  62.             public String getColumnName(int column) {  
  63.                 return columnNames[column+1];  
  64.             }  
  65.    
  66.             public int getRowCount() {  
  67.                 return rowData.length;  
  68.             }  
  69.    
  70.             public Object getValueAt(int row, int column) {  
  71.                 return rowData[row][column+1];  
  72.             }  
  73.         };  
  74.    
  75.         Runnable runner = new Runnable() {  
  76.             public void run() {  
  77.                 JTable fixedTable = new JTable(fixedColumnModel);  
  78.                 fixedTable.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);  
  79.    
  80.                 JTable mainTable = new JTable(mainModel);  
  81.                 mainTable.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);  
  82.    
  83.                 ListSelectionModel model = fixedTable.getSelectionModel();  
  84.                 mainTable.setSelectionModel(model);  
  85.    
  86.                 JScrollPane scrollPane = new JScrollPane(mainTable);  
  87.                 Dimension fixedSize = fixedTable.getPreferredSize();  
  88.                 JViewport viewport = new JViewport();  
  89.                 viewport.setView(fixedTable);  
  90.                 viewport.setPreferredSize(fixedSize);  
  91.                 viewport.setMaximumSize(fixedSize);  
  92.                 scrollPane.setCorner(JScrollPane.UPPER_LEFT_CORNER, fixedTable.getTableHeader());  
  93.                 scrollPane.setRowHeaderView(viewport);  
  94.    
  95.                 JFrame frame = new JFrame("Fixed Column Table");  
  96.                 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
  97.                 frame.add(scrollPane, BorderLayout.CENTER);  
  98.                 frame.setSize(300, 150);  
  99.                 frame.setVisible(true);  
  100.             }  
  101.         };  
  102.    
  103.         EventQueue.invokeLater(runner);  
  104.     }  
  105.    
  106. }  

激活默认的表格单元渲染器
在前面的章节中，我们提到，JTable为Date与Number类提供了默认渲染器。现在我们了解一下AbstractTableModel类并且了解如何激活这些渲染器。
TableModel的public Class getColumnClass(int column)方法为数据模型中的列返回类类型。如果JTable类为这个特定类安装了特殊的渲染器，则会使用这个渲染器来显示这个类。默认情况下，TableModel的AbstractTableModel（以及DefaultTableModel）实现会为所有的事情返回Object.class。AbstractTableModel类并不会尝试聪明的猜测什么在列中。然而，如果我们知道数据模型中的特定列总是数字，日期或是其他的类，我们可以使得数据模型返回类类型。这就会允许JTable尝试更为聪明并且使用更好的渲染器。
表18-5显示了JTable的预安装的渲染器。例如，如果我们有一个满是数字的表格或是有一个数字列，我们可以重写getColumnClass()来相应的列返回Number.class；我们的数字将会右对齐而不是左对齐。对于日期，为Date类使用默认渲染器会产生更好的观感以及本地化输出。

图18-10显示了激活渲染器之前与之后的样子。

我们可以选择为列硬编码类名或是使得getColumnClass()方法通用并且在列元素上调用getClass()方法。将下面的代码添加到AbstractTableModel实现中将会使得JTable使用其默认渲染器。这个实现假定特定列的所有实体是同一个类类型。
[java] view plaincopyprint?
  1. public Class getColumnClass(int column) {  
  2.   return (getValueAt(0, column).getClass());  
  3. }  

18.3.2 DefaultTableModel类
DefaultTableModel类是AbstractTableModel的子类，他为存储提供了自己的Vector数据。数据模型中的所有内容在内部都是存储在向量中的即使当数据初始时是数组的一部分也是如此。换句话说，如果我们已经将我们的数据放在一个适当的数据结构中，则不要使用DefaultTableModel。创建一个使用该数据结构的AbstractTableModel，而不要使用DefaultTableModel为我们转换数据结构。
创建DefaultTableModel
有六个构造函数可以用来创建DefaultTableModel：
[java] view plaincopyprint?
  1. public DefaultTableModel()  
  2. TableModel model = new DefaultTableModel()  
  3. public DefaultTableModel(int rows, int columns)  
  4. TableModel model = new DefaultTableModel(2, 3)  
  5. public DefaultTableModel(Object rowData[][], Object columnNames[])  
  6. Object rowData[][] = {{"Row1-Column1", "Row1-Column2", "Row1-Column3"},  
  7.   {"Row2-Column1", "Row2-Column2", "Row2-Column3"}};  
  8. Object columnNames[] = {"Column One", "Column Two", "Column Three"};  
  9. TableModel model = new DefaultTableModel(rowData, columnNames);  
  10.    
  11. public DefaultTableModel(Vector rowData, Vector columnNames)  
  12. Vector rowOne = new Vector();  
  13. rowOne.addElement("Row1-Column1");  
  14. rowOne.addElement("Row1-Column2");  
  15. rowOne.addElement("Row1-Column3");  
  16. Vector rowTwo = new Vector();  
  17. rowTwo.addElement("Row2-Column1");  
  18. rowTwo.addElement("Row2-Column2");  
  19. rowTwo.addElement("Row2-Column3");  
  20. Vector rowData = new Vector();  
  21. rowData.addElement(rowOne);  
  22. rowData.addElement(rowTwo);  
  23. Vector columnNames = new Vector();  
  24. columnNames.addElement("Column One");  
  25. columnNames.addElement("Column Two");  
  26. columnNames.addElement("Column Three");  
  27. TableModel model = new DefaultTableModel(rowData, columnNames);  
  28.    
  29. public DefaultTableModel(Object columnNames[], int rows)  
  30. TableModel model = new DefaultTableModel(columnNames, 2);  
  31. public DefaultTableModel(Vector columnNames, int rows)  
  32. TableModel model = new DefaultTableModel(columnNames, 2);  

其中四个构造函数直接映射到JTable构造函数，而其余的两个则允许我们由一个列头集合创建一个具有固定行数的空表格。一旦我们创建了DefaultTableModel，我们就可以将传递给JTable构造函数来创建实际的表格，然后将这个表格放在JScrollPane中。
填充DefaultTableModel
如果我们选择使用DefaultTableModel，我们必须使用JTable要显示的数据来进行填充。除了填充数据结构的基本例程以外，还有一些移除数据或是替换整个内容的额外方法：
下面的方法允许我们添加列：
[java] view plaincopyprint?
  1. public void addColumn(Object columnName);  
  2. public void addColumn(Object columnName, Vector columnData);  
  3. public void addColumn(Object columnName, Object columnData[ ]);  

使用下面的方法来添加行：
[java] view plaincopyprint?
  1. public void addRow(Object rowData[ ]);  
  2. public void addRow(Vector rowData);  

下面的方法可以插入行：
[java] view plaincopyprint?
  1. public void insertRow(int row, Object rowData[ ]);  
  2. public void insertRow(int row, Vector rowData);  

这个方法可以移除行：
[java] view plaincopyprint?
  1. public void removeRow( int row);  

最后，我们可以使用下面的方法来替换内容：
[java] view plaincopyprint?
  1. public void setDataVector(Object newData[ ][ ], Object columnNames[ ]);  
  2. public void setDataVector(Vector newData, Vector columnNames);  

DefaultTableModel属性
除了由AbstractTableModel继承的rowCount与columnCount属性以外，DefaultTableModel还有两个其他的属性，如表18-6所示。设置rowCount属性可以使得我们按照我们的意愿扩大或是缩小表格尺寸。如果我们正在扩展模型，其他的行会保持为空。

创建一个稀疏的表格模型
默认的表格模型实现用于填满数据的表格，而不是用于由大多数空表格单元的组成的数据表。当表格中的单元大部分为空时，DefaultTableModel的默认数据结构就会学浪费大量的空间。以为每一个位置创建一个Point为代价，我们可以创建一个使用HashMap的稀疏表格模型。列表18-5演示了这种实现。
[java] view plaincopyprint?
  1. package swingstudy.ch18;  
  2.    
  3. import java.awt.Point;  
  4. import java.util.HashMap;  
  5. import java.util.Map;  
  6.    
  7. import javax.swing.table.AbstractTableModel;  
  8.    
  9. public class SparseTableModel extends AbstractTableModel {  
  10.    
  11.     private Map<Point, Object> lookup;  
  12.     private final int rows;  
  13.     private final int columns;  
  14.     private final String headers[];  
  15.    
  16.     public SparseTableModel(int rows, String columnHeaders[]) {  
  17.         if((rows<0) || (columnHeaders == null)) {  
  18.             throw new IllegalArgumentException("Invalida row count/columnHeaders");  
  19.         }  
  20.         this.rows = rows;  
  21.         this.columns = columnHeaders.length;  
  22.         headers = columnHeaders;  
  23.         lookup = new HashMap<Point, Object>();  
  24.     }  
  25.     @Override  
  26.     public int getRowCount() {  
  27.         // TODO Auto-generated method stub   
  28.         return rows;  
  29.     }  
  30.    
  31.     @Override  
  32.     public int getColumnCount() {  
  33.         // TODO Auto-generated method stub   
  34.         return columns;  
  35.     }  
  36.    
  37.     public String getColumnName(int column) {  
  38.         return headers[column];  
  39.     }  
  40.    
  41.     @Override  
  42.     public Object getValueAt(int row, int column) {  
  43.         // TODO Auto-generated method stub   
  44.         return lookup.get(new Point(row, column));  
  45.     }  
  46.    
  47.     public void setValueAt(Object value, int row, int column) {  
  48.         if((rows<0) || (columns<0)) {  
  49.             throw new IllegalArgumentException("Invalid row/column setting");  
  50.         }  
  51.         if((row<rows) && (column<columns)) {  
  52.             lookup.put(new Point(row, column), value);  
  53.         }  
  54.     }  
  55. }  

测试这个示例涉及到创建并填充模型，如下面的代码所示：
[java] view plaincopyprint?
  1. String headers[] = { "English", "Japanese"};  
  2. TableModel model = new SparseTableModel(10, headers);  
  3. JTable table = new JTable(model);  
  4. model.setValueAt("one", 0, 0);  
  5. model.setValueAt("ten", 9, 0);  
  6. model.setValueAt("roku - \ u516D", 5, 1);  
  7. model.setValueAt("hachi - \ u516B", 8, 1);  

使用TableModelListener监听JTable事件
如果我们需要动态更新我们的表格数据，我们可以使用TableModelListener来确定数据何时发生变化。这个接口由一个可以告诉我们表格数据何时发生变化的方法构成。
[java] view plaincopyprint?
  1. public interface TableModelListener extends EventListener {  
  2.   public void tableChanged(TableModelEvent e);  
  3. }  

在TableModelListener得到通知以后，我们可以向TableModelEvent查询所发生的事件的类型以及受到影响的行与列的范围。表18-7显示了我们可以查询的TableModelEvent的属性。

事件类型可以是TableModeleEvent三个类型常量中的一个：INSERT, UPDATE或是DELETE。
如果TableModelEvent的column属性设置为ALL_COLUMNS，那么数据模型中所有的列都会受到影响。如果firstRow属性为HEADER_ROW，则意味着表格头发生了变化。
18.3.4 排序JTable元素
JTable组件并没有内建的排序支持。然而，却经常需要这一特性。排序并不需要改变数据模型，但是他却需要改变JTable所具有的数据模型视图。这种改变类型是通过装饰者模式来描述的，在这种模式中我们维护到数据的相同的API，但是向视图添加排序功能。装饰者设计模式的设计如下：
  1. Component：组件定义了将要装饰的服务接口。 
  2. ConcreteComponent：具体组件是将要装饰的对象。 
  3. Decorator：装饰者是到具体组件的一个抽象封装；他维护服务接口。 
  4. ConcreteDecorator(s)[A,B,C,...]：具体装饰者对象通过添加装饰功能扩展装饰者，然而维护相同的编程接口。他们将服务请求重定向到由抽象超类所指向的具体组件。
注意，java.io包的流是装饰者模式的示例。各种过滤器流向基本的流类添加功能并且维护相同的访问API。
在表格排序这个特定例子中，只需要Component，ConcreteComponent与Decorator，因为只有一个具体装饰者。Component是TableModel接口，ConcreteComponent是实际的模型，而Decorator是排序模型。
为了排序，我们需要维护一个真实数据到排序数据的一个映射。由用户接口，我们必须允许用户选择一个列头标签来激活特定列的排序。
要使用排序功能，我们告诉自定义TableSorter类关于我们数据模型的情况，装饰这个模型，并且由装饰模型而不是原始模型创建一个JTable。要通过点击列头标签来激活排序，我们需要调用TableHeaderSorter类的install()方法，如下面的TableSorter类的源码所示：
[java] view plaincopyprint?
  1. TableSorter sorter = new TableSorter(model);  
  2. JTable table = new JTable(sorter);  
  3. TableHeaderSorter.install(sorter, table);  

TableSorter类的主要源码显示在列表18-6中。他扩展了TableMap类，该类显示在列表18-7中。TableSorter类是所有动作所在的位置。该类执行排序并且通知其他类数据已经发生变化。
[java] view plaincopyprint?
  1. package swingstudy.ch18;  
  2.    
  3. import java.sql.Date;  
  4. import java.util.Vector;  
  5.    
  6. import javax.swing.event.TableModelEvent;  
  7. import javax.swing.event.TableModelListener;  
  8. import javax.swing.table.TableModel;  
  9.    
  10. public class TableSorter extends TableMap implements TableModelListener {  
  11.    
  12.     int indexes[] = new int[0];  
  13.     Vector sortingColumns = new Vector();  
  14.     boolean ascending = true;  
  15.    
  16.     public TableSorter() {  
  17.    
  18.     }  
  19.    
  20.     public TableSorter(TableModel model) {  
  21.         setModel(model);  
  22.     }  
  23.    
  24.     public void setModel(TableModel model) {  
  25.         super.setModel(model);  
  26.         reallocateIndexes();  
  27.         sortByColumn(0);  
  28.         fireTableDataChanged();  
  29.     }  
  30.    
  31.     public int compareRowsByColumn(int row1, int row2, int column) {  
  32.         Class type = model.getColumnClass(column);  
  33.         TableModel data = model;  
  34.    
  35.         // check for nulls   
  36.         Object o1 = data.getValueAt(row1, column);  
  37.         Object o2 = data.getValueAt(row2, column);  
  38.    
  39.         // if both values are null return 0   
  40.         if(o1 == null && o2 == null) {  
  41.             return 0;  
  42.         }  
  43.         else if(o1 == null) { // define null less than everything   
  44.             return -1;  
  45.         }  
  46.         else if(o2 == null) {  
  47.             return 1;  
  48.         }  
  49.    
  50.         if(type.getSuperclass() == Number.class) {  
  51.             Number n1 = (Number)data.getValueAt(row1, column);  
  52.             double d1 = n1.doubleValue();  
  53.             Number n2 = (Number)data.getValueAt(row1, column);  
  54.             double d2 = n2.doubleValue();  
  55.    
  56.             if(d1<d2) {  
  57.                 return -1;  
  58.             }  
  59.             else if(d1>d2) {  
  60.                 return 1;  
  61.             }  
  62.             else {  
  63.                 return 0;  
  64.             }  
  65.         }  
  66.         else if(type == String.class) {  
  67.             String s1 = (String)data.getValueAt(row1, column);  
  68.             String s2 = (String)data.getValueAt(row2, column);  
  69.             int result = s1.compareTo(s2);  
  70.    
  71.             if(result < 0)  
  72.                 return -1;  
  73.             else if(result > 0)  
  74.                 return 1;  
  75.             else return 0;  
  76.         }  
  77.         else if(type == java.util.Date.class) {  
  78.             Date d1 = (Date)data.getValueAt(row1, column);  
  79.             long n1 = d1.getTime();  
  80.             Date d2 = (Date)data.getValueAt(row2, column);  
  81.             long n2 = d2.getTime();  
  82.    
  83.             if(n1 < n2)  
  84.                 return -1;  
  85.             else if(n1 > n2)  
  86.                 return 1;  
  87.             else  
  88.                 return 0;  
  89.         }  
  90.         else if(type == Boolean.class) {  
  91.             Boolean bool1 = (Boolean)data.getValueAt(row1, column);  
  92.             boolean b1 = bool1.booleanValue();  
  93.             Boolean bool2 = (Boolean)data.getValueAt(row2, column);  
  94.             boolean b2 = bool2.booleanValue();  
  95.    
  96.             if(b1 == b2) {  
  97.                 return 0;  
  98.             }  
  99.             else if(b1) // define false < true   
  100.                 return 1;  
  101.             else  
  102.                 return -1;  
  103.         }  
  104.         else {  
  105.             Object v1 = data.getValueAt(row1, column);  
  106.             String s1 = v1.toString();  
  107.             Object v2 = data.getValueAt(row2, column);  
  108.             String s2 = v2.toString();  
  109.             int result = s1.compareTo(s2);  
  110.    
  111.             if(result < 0)  
  112.                 return -1;  
  113.             else if(result > 0)  
  114.                 return 1;  
  115.             else  
  116.                 return 0;  
  117.         }  
  118.     }  
  119.    
  120.     public int compare(int row1, int row2) {  
  121.         for(int level=0, n=sortingColumns.size(); level<n;level++) {  
  122.             Integer column = (Integer)sortingColumns.elementAt(level);  
  123.             int result = compareRowsByColumn(row1, row2, column.intValue());  
  124.             if(result != 0) {  
  125.                 return (ascending ? result : -result);  
  126.             }  
  127.         }  
  128.         return 0;  
  129.     }  
  130.    
  131.     public void reallocateIndexes() {  
  132.         int rowCount = model.getRowCount();  
  133.         indexes = new int[rowCount];  
  134.         for(int row=0; row<rowCount; row++) {  
  135.             indexes[row] = row;  
  136.         }  
  137.     }  
  138.    
  139.     @Override  
  140.     public void tableChanged(TableModelEvent e) {  
  141.         // TODO Auto-generated method stub   
  142.         super.tableChanged(e);  
  143.         reallocateIndexes();  
  144.         sortByColumn(0);  
  145.         fireTableStructureChanged();  
  146.     }  
  147.    
  148.     public void checkModel() {  
  149.         if(indexes.length != model.getRowCount()) {  
  150.             System.err.println("Sorter not informed of a change in model.");  
  151.         }  
  152.     }  
  153.    
  154.     public void sort() {  
  155.         checkModel();  
  156.         shuttlesort((int[])indexes.clone(), indexes, 0, indexes.length);  
  157.         fireTableDataChanged();  
  158.     }  
  159.    
  160.     public void shuttlesort(int from[], int to[], int low, int high) {  
  161.         if(high-low<2) {  
  162.             return ;  
  163.         }  
  164.         int middle = (low+high)/2;  
  165.         shuttlesort(to, from, low, middle);  
  166.         shuttlesort(to, from, middle, high);  
  167.    
  168.         int p = low;  
  169.         int q = middle;  
  170.    
  171.         for(int i=low; i<high; i++) {  
  172.             if(q>=high || (p<middle && compare(from[p], from[q]) <= 0)) {  
  173.                 to[i] = from[p++];  
  174.             }  
  175.             else {  
  176.                 to[i] = from[q++];  
  177.             }  
  178.         }  
  179.     }  
  180.    
  181.     private void swap(int first, int second) {  
  182.         int temp = indexes[first];  
  183.         indexes[first] = indexes[second];  
  184.         indexes[second] = temp;  
  185.     }  
  186.    
  187.     public Object getValueAt(int row, int column) {  
  188.         checkModel();  
  189.         return model.getValueAt(indexes[row], column);  
  190.     }  
  191.    
  192.     public void setValueAt(Object aValue, int row, int column) {  
  193.         checkModel();  
  194.         model.setValueAt(aValue, row, column);  
  195.     }  
  196.    
  197.     public void sortByColumn(int column) {  
  198.         sortByColumn(column, true);  
  199.     }  
  200.    
  201.     public void sortByColumn(int column, boolean ascending) {  
  202.         this.ascending = ascending;  
  203.         sortingColumns.removeAllElements();  
  204.         sortingColumns.addElement(new Integer(column));  
  205.         sort();  
  206.         super.tableChanged(new TableModelEvent(this));  
  207.     }  
  208. }  

显示在列表18-7中的TableMap类作为一个代理，将调用传递给相应的TableModel类。他是列表18-6中的TableSorter类的超类。
[java] view plaincopyprint?
  1. package swingstudy.ch18;  
  2.    
  3. import javax.swing.event.TableModelEvent;  
  4. import javax.swing.event.TableModelListener;  
  5. import javax.swing.table.AbstractTableModel;  
  6. import javax.swing.table.TableModel;  
  7.    
  8. public class TableMap extends AbstractTableModel implements TableModelListener {  
  9.    
  10.     TableModel model;  
  11.    
  12.     public TableModel getModel() {  
  13.         return model;  
  14.     }  
  15.    
  16.     public void setModel(TableModel model) {  
  17.         if(this.model != null) {  
  18.             this.model.removeTableModelListener(this);  
  19.         }  
  20.         this.model = model;  
  21.         if(this.model != null) {  
  22.             this.model.addTableModelListener(this);  
  23.         }  
  24.     }  
  25.    
  26.     public Class getcolumnClass(int column) {  
  27.         return model.getColumnClass(column);  
  28.     }  
  29.    
  30.     @Override  
  31.     public int getRowCount() {  
  32.         // TODO Auto-generated method stub   
  33.         return ((model == null)? 0 : model.getRowCount());  
  34.     }  
  35.    
  36.     @Override  
  37.     public int getColumnCount() {  
  38.         // TODO Auto-generated method stub   
  39.         return ((model == null)? 0 :model.getColumnCount());  
  40.     }  
  41.    
  42.     public String getColumnName(int column) {  
  43.         return model.getColumnName(column);  
  44.     }  
  45.    
  46.     @Override  
  47.     public Object getValueAt(int rowIndex, int columnIndex) {  
  48.         // TODO Auto-generated method stub   
  49.         return model.getValueAt(rowIndex, columnIndex);  
  50.     }  
  51.    
  52.     public void setValueAt(Object value, int row, int column) {  
  53.         model.setValueAt(value, row, column);  
  54.     }  
  55.    
  56.     public boolean isCellEditable(int row, int column) {  
  57.         return model.isCellEditable(row, column);  
  58.     }  
  59.    
  60.     @Override  
  61.     public void tableChanged(TableModelEvent e) {  
  62.         // TODO Auto-generated method stub   
  63.         fireTableChanged(e);  
  64.     }  
  65.    
  66. }  

排序例程的安装需要MouseListener的注册，如列表18-8所示，从而表格头中的选择会触发排序处理。通常的鼠标点击是升序排列；Shift点击为降序排列。
[java] view plaincopyprint?
  1. package swingstudy.ch18;  
  2.    
  3. import java.awt.event.InputEvent;  
  4. import java.awt.event.MouseAdapter;  
  5. import java.awt.event.MouseEvent;  
  6.    
  7. import javax.swing.JTable;  
  8. import javax.swing.table.JTableHeader;  
  9. import javax.swing.table.TableColumnModel;  
  10.    
  11. public class TableHeaderSorter extends MouseAdapter {  
  12.    
  13.     private TableSorter sorter;  
  14.     private JTable table;  
  15.    
  16.     private TableHeaderSorter() {  
  17.    
  18.     }  
  19.    
  20.     public static void install(TableSorter sorter, JTable table) {  
  21.         TableHeaderSorter tableHeaderSorter = new TableHeaderSorter();  
  22.         tableHeaderSorter.sorter = sorter;  
  23.         tableHeaderSorter.table = table;  
  24.         JTableHeader tableHeader = table.getTableHeader();  
  25.         tableHeader.addMouseListener(tableHeaderSorter);  
  26.     }  
  27.    
  28.     public void mouseClicked(MouseEvent event) {  
  29.         TableColumnModel columnModel = table.getColumnModel();  
  30.         int viewColumn = columnModel.getColumnIndexAtX(event.getX());  
  31.         int column = table.convertColumnIndexToModel(viewColumn);  
  32.         if(event.getClickCount() == 1 && column != -1) {  
  33.             System.out.println("Sorting ...");  
  34.             int shiftPressed = (event.getModifiers() & InputEvent.SHIFT_MASK);  
  35.             boolean ascending = (shiftPressed == 0);  
  36.             sorter.sortByColumn(column, ascending);  
  37.         }  
  38.     }  
  39. }  
18.4 TableColumnModel接口
TableColumnModel是那些位于背后并且不需要太多注意的接口之一。其基本作用就是管理当前通过JTable显示的列集合。除非触发去做其他一些事情，当JTable被创建时，组件就会由数据模型创建一个默认的列模型，指明显示列顺序与数据模型中的顺序相同。
当在设置JTable的数据模型之前将JTable的autoCreateColumnsFromModele属性设置为true，则TableColumnModel会自动被创建。另外，如果当前的设置需要重置，我们可以手动告诉JTable来创建默认的TableColumnModel。public void createDefaultColumnsFromModel()方法会为我们完成创建工作，并将新创建的对象赋给JTable的TableColumnModel。
既然所有都是为我们自动完成的，我们为什么需要了解TableColumnModel呢？通常，只有当我们不喜欢默认生成的TableModel或是我们需要手动移动一些内容时，我们需要使用这个接口。除了维护一个TableColumn对象集合，TableColumnModel管理第二个ListSelectionModel，从而允许用户由表格中选择列与行。
在我们深入默认实现之前我们先来了解一下该接口的定义：
[java] view plaincopyprint?
  1. public interface TableColumnModel {  
  2.   // Listeners   
  3.   public void addColumnModelListener(TableColumnModelListener l);  
  4.   public void removeColumnModelListener(TableColumnModelListener l);  
  5.   // Properties   
  6.   public int getColumnCount();  
  7.   public int getColumnMargin();  
  8.   public void setColumnMargin(int newMargin);  
  9.   public Enumeration getColumns();  
  10.   public boolean getColumnSelectionAllowed();  
  11.   public void setColumnSelectionAllowed(boolean flag);  
  12.   public int getSelectedColumnCount();  
  13.   public int[ ] getSelectedColumns();  
  14.   public ListSelectionModel getSelectionModel();  
  15.   public void setSelectionModel(ListSelectionModel newModel);  
  16.   public int getTotalColumnWidth();  
  17.   // Other methods   
  18.   public void addColumn(TableColumn aColumn);  
  19.   public TableColumn getColumn(int columnIndex);  
  20.   public int getColumnIndex(Object columnIdentifier);  
  21.   public int getColumnIndexAtX(int xPosition);  
  22.   public void moveColumn(int columnIndex, int newIndex);  
  23.   public void removeColumn(TableColumn column);  
  24. }  

18.4.1 DefaultTableColumnModel类
DefaultTableColumnModel类定义了系统所用的TableColumnModel接口的实现。他在JTable内通过跟踪空白，宽度，选择与数量来描述TableColumn对象的一般外观。表18-8显示了用于访问DefaultTableColumnModel设置的9个属性。

除了类属性，我们可以使用下面的方法通过TableColumn类来添加，移除与移动列，我们会在稍后进行讨论。
[java] view plaincopyprint?
  1. public void addColumn(TableColumn newColumn);  
  2. public void removeColumn(TableColumn oldColumn);  
  3. public void moveColumn(int currentIndex, int newIndex);  

18.4.2 使用TableColumnModelListener监听JTable事件
也许我们通过TableColumnModel要做的事情之一就是使用TableColumnModelListener来监听TableColumnModelEvent对象。监听器会得到列的添加，移除，移动或是选择，或是列空白变化的通知，如前面的接口定义所示。注意，当事件发生时不同的方法并不同有全部接收TableColumnModelEvent对象。
[java] view plaincopyprint?
  1. public interface TableColumnModelListener extends EventListener {  
  2.   public void columnAdded(TableColumnModelEvent e);  
  3.   public void columnMarginChanged(ChangeEvent e);  
  4.   public void columnMoved(TableColumnModelEvent e);  
  5.   public void columnRemoved(TableColumnModelEvent e);  
  6.   public void columnSelectionChanged(ListSelectionEvent e);  
  7. }  

因为监听器定义标明了事件类型，TableColumnModelEvent定义只定义了变化所影响的列的范围，如表18-9所示。

要查看TableColumnModelListener的演示，我们可以向我们的TableColumnModel对象关联一个监听器：
[java] view plaincopyprint?
  1. TableColumnModel columnModel = table.getColumnModel();  
  2. columnModel.addColumnModelListener(...);  

在列表18-9中我们可以看到这样的监听器。他除了输出信息以外并没有做其他的事情。然而我们可以用其来确定不同事情的发生。
[java] view plaincopyprint?
  1. TableColumnModelListener tableColumnModelListener =  
  2.     new TableColumnModelListener() {  
  3.   public void columnAdded(TableColumnModelEvent e) {  
  4.     System.out.println("Added");  
  5.   }  
  6.   public void columnMarginChanged(ChangeEvent e) {  
  7.     System.out.println("Margin");  
  8.   }  
  9.   public void columnMoved(TableColumnModelEvent e) {  
  10.     System.out.println("Moved");  
  11.   }  
  12.   public void columnRemoved(TableColumnModelEvent e) {  
  13.     System.out.println("Removed");  
  14.   }  
  15.   public void columnSelectionChanged(ListSelectionEvent e) {  
  16.     System.out.println("Selected");  
  17.   }  
  18. };  

当然我们需要编写一些代码来引出特定的事件。
[java] view plaincopyprint?
  1. package swingstudy.ch18;  
  2.    
  3. import java.awt.BorderLayout;  
  4. import java.awt.EventQueue;  
  5.    
  6. import javax.swing.JFrame;  
  7. import javax.swing.JScrollPane;  
  8. import javax.swing.JTable;  
  9. import javax.swing.event.ChangeEvent;  
  10. import javax.swing.event.ListSelectionEvent;  
  11. import javax.swing.event.TableColumnModelEvent;  
  12. import javax.swing.event.TableColumnModelListener;  
  13. import javax.swing.table.TableColumn;  
  14. import javax.swing.table.TableColumnModel;  
  15.    
  16. public class ColumnModelSample {  
  17.    
  18.     /** 
  19.      * @param args 
  20.      */  
  21.     public static void main(String[] args) {  
  22.         // TODO Auto-generated method stub   
  23.         final Object rows[][] = {  
  24.                 {"one", "ichi - \u4E00"},  
  25.                 {"two", "ni - \u4E8C"},  
  26.                 {"three", "san - \u4E09"},  
  27.                 {"four", "shi - \u56DB"},  
  28.                 {"five", "go - \u4E94"},  
  29.                 {"six", "roku - \u516D"},  
  30.                 {"seven", "shichi - \u4E03"},  
  31.                 {"eight", "kachi - \u516B"},  
  32.                 {"nine", "kyu - \u4E5D"},  
  33.                 {"ten", "ju - \u5341"}  
  34.         };  
  35.    
  36.         final Object headers[] = {"English", "Japanese"};  
  37.    
  38.         Runnable runner = new Runnable() {  
  39.             public void run() {  
  40.                 JFrame frame = new JFrame("Scrollless Table");  
  41.                 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
  42.                 JTable table = new JTable(rows, headers);  
  43.    
  44.                 TableColumnModelListener tableColumnModelListener = new TableColumnModelListener() {  
  45.                     public void columnAdded(TableColumnModelEvent e) {  
  46.                         System.out.println("Added");  
  47.                     }  
  48.    
  49.                     public void columnMarginChanged(ChangeEvent e) {  
  50.                         System.out.println("Margin");  
  51.                     }  
  52.    
  53.                     public void columnMoved(TableColumnModelEvent e) {  
  54.                         System.out.println("Moved");  
  55.                     }  
  56.    
  57.                     public void columnRemoved(TableColumnModelEvent e) {  
  58.                         System.out.println("Removed");  
  59.                     }  
  60.    
  61.                     public void columnSelectionChanged(ListSelectionEvent e) {  
  62.                         System.out.println("Selection Changed");  
  63.                     }  
  64.                 };  
  65.    
  66.                 TableColumnModel columnModel = table.getColumnModel();  
  67.                 columnModel.addColumnModelListener(tableColumnModelListener);  
  68.    
  69.                 columnModel.setColumnMargin(12);  
  70.    
  71.                 TableColumn column = new TableColumn(1);  
  72.                 columnModel.addColumn(column);  
  73.    
  74.                 JScrollPane pane = new JScrollPane(table);  
  75.                 frame.add(pane, BorderLayout.CENTER);  
  76.                 frame.setSize(300, 150);  
  77.                 frame.setVisible(true);  
  78.             }  
  79.         };  
  80.    
  81.         EventQueue.invokeLater(runner);  
  82.     }  
  83.    
  84. }  


18.4.3 TableColumn类
TableColumn是另一个很重要的幕后类。Swing表格由一个列集合构成，而列由表格单元构成。这个列中的每一个是通过TableColumn实例来描述的。TableColumn类的每一个实例存储相应的编辑器，渲染器，名字与尺寸信息。然后TableColumn对象被组合进TableColumnModel来构成当前要由JTable显示的列集合。在这里有一个有用的技巧，如果我们不希望某一列被显示，我们就将其TableColumn由TableColumnModel中移除，但是将保留在TableModel中。
创建TableColumn
如果我们选择自己来创建我们的TableColumn，我们可以使用以下四个构造函数中的一个。他们是通过添加构造函数参数来级联的。
[java] view plaincopyprint?
  1. public TableColumn()  
  2. TableColumn column = new TableColumn()  
  3. public TableColumn(int modelIndex)  
  4. TableColumn column = new TableColumn(2)  
  5. public TableColumn(int modelIndex, int width)  
  6. TableColumn column = new TableColumn(2, 25)  
  7. public TableColumn(int modelIndex, int width, TableCellRenderer  
  8.   renderer, TableCellEditor editor)  
  9. TableColumn column = new TableColumn(2, 25, aRenderer, aEditor)  

如果没有参数，例如列表中的第一个构造函数，我们就会获得一个空列，其具有默认宽度（75像素），默认编辑器，以及默认渲染器。modelIndex参数允许我们指定我们希望TableColumn在JTable中显示TableModel中的哪一列。如果我们不喜欢默认的设置，我们也可以指定宽度，渲染器，或是编辑器。如是我们喜欢其中的一个而不喜欢其他的，我们也可以为渲染器或是编辑器指定null。
TableColumn属性
列表18-10列出了TableColumn的12个属性。这些属性可以使得我们在初始的构造参数集合以外自定义列。大多数时候，我们可以基于TableModel配置所有的事情。然而，我们仍然可以通过TableColumn类来自定义单个列。除了监听器列表，所有的属性都是绑定的。

注意，如果列所有的默认头渲染器headerRenderer为null：TableCellRenderer headerRenderer = table.getTableHeader().getDefaultRenderer();则默认渲染器不会由getHeaderRenderer()方法返回。
在列头中使用图标
默认情况下，表格的头渲染器显示文本或是HTML。尽管我们可以使用HTML获得多行文本或是图片，但是有时我们希望在头中显示通常的Icon对象，如图18-11中的示例所示。要实现这一目的，我们必须修改头的渲染器。头渲染器只是另一个TableCellRenderer。
要创建一个可以显示图片的灵活渲染器，要使得渲染器将value数据看作为JLabel，而不是使用value来填充JLabel。列表18-11显示一个这样的渲染器，用于创建图18-11中的程序。
[java] view plaincopyprint?
  1. package swingstudy.ch18;  
  2.    
  3. import java.awt.Component;  
  4.    
  5. import javax.swing.JComponent;  
  6. import javax.swing.JTable;  
  7. import javax.swing.table.TableCellRenderer;  
  8.    
  9. public class JComponentTableCellRenderer implements TableCellRenderer {  
  10.    
  11.     @Override  
  12.     public Component getTableCellRendererComponent(JTable table, Object value,  
  13.             boolean isSelected, boolean hasFocus, int row, int column) {  
  14.         // TODO Auto-generated method stub   
  15.         return (JComponent)value;  
  16.     }  
  17.    
  18. }  


图18-11显示了这个渲染器如何使用DiamondIcon显示Icon。示例程序的源码显示在列表18-12中。
[java] view plaincopyprint?
  1. package swingstudy.ch18;  
  2.    
  3. import java.awt.BorderLayout;  
  4. import java.awt.Color;  
  5. import java.awt.EventQueue;  
  6.    
  7. import javax.swing.Icon;  
  8. import javax.swing.JFrame;  
  9. import javax.swing.JLabel;  
  10. import javax.swing.JScrollPane;  
  11. import javax.swing.JTable;  
  12. import javax.swing.UIManager;  
  13. import javax.swing.border.Border;  
  14. import javax.swing.table.TableCellRenderer;  
  15. import javax.swing.table.TableColumn;  
  16. import javax.swing.table.TableColumnModel;  
  17.    
  18. import swingstudy.ch04.DiamondIcon;  
  19.    
  20. public class LabelHeaderSample {  
  21.    
  22.     /** 
  23.      * @param args 
  24.      */  
  25.     public static void main(String[] args) {  
  26.         // TODO Auto-generated method stub   
  27.         final Object rows[][] = {  
  28.                 {"one", "ichi - \u4E00"},  
  29.                 {"two", "ni - \u4E8C"},  
  30.                 {"three", "san - \u4E09"},  
  31.                 {"four", "shi - \u56DB"},  
  32.                 {"five", "go - \u4E94"},  
  33.                 {"six", "roku - \u516D"},  
  34.                 {"seven", "shichi - \u4E03"},  
  35.                 {"eight", "kachi - \u516B"},  
  36.                 {"nine", "kyu - \u4E5D"},  
  37.                 {"ten", "ju - \u5341"}  
  38.         };  
  39.    
  40.         Runnable runner = new Runnable() {  
  41.             public void run() {  
  42.                 JFrame frame = new JFrame("Label Header");  
  43.                 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
  44.                 String headers[] = {"English", "Japanese"};  
  45.                 JTable table = new JTable(rows, headers);  
  46.                 JScrollPane scrollPane = new JScrollPane(table);  
  47.    
  48.                 Icon redIcon = new DiamondIcon(Color.RED);  
  49.                 Icon blueIcon = new DiamondIcon(Color.BLUE);  
  50.    
  51.                 Border headerBorder = UIManager.getBorder("TableHeader.cellBorder");  
  52.    
  53.                 JLabel blueLabel = new JLabel(headers[0], blueIcon, JLabel.CENTER);  
  54.                 blueLabel.setBorder(headerBorder);  
  55.                 JLabel redLabel = new JLabel(headers[1], redIcon, JLabel.CENTER);  
  56.                 redLabel.setBorder(headerBorder);  
  57.    
  58.                 TableCellRenderer renderer =  new JComponentTableCellRenderer();  
  59.    
  60.                 TableColumnModel columnModel = table.getColumnModel();  
  61.    
  62.                 TableColumn column0 = columnModel.getColumn(0);  
  63.                 TableColumn column1 = columnModel.getColumn(1);  
  64.    
  65.                 column0.setHeaderRenderer(renderer);  
  66.                 column0.setHeaderValue(blueLabel);  
  67.    
  68.                 column1.setHeaderRenderer(renderer);  
  69.                 column1.setHeaderValue(redLabel);  
  70.    
  71.                 frame.add(scrollPane, BorderLayout.CENTER);  
  72.                 frame.setSize(300, 150);  
  73.                 frame.setVisible(true);  
  74.             }  
  75.         };  
  76.         EventQueue.invokeLater(runner);  
  77.     }  
  78.    
  79. }  


	
				
		









 linux中文版系统下载
    		linux中文版系统下载



原创粉丝点击



		

热门IT博客


知乎怎么同步关注知乎怎么同步关注




软件开发个人简历软件开发个人简历




java 守护进程




linux编辑保存退出




淘宝anna家的创始人




deepin linux 下载




驾校一点通软件




南风知我意二txt下载




电脑上怎么发淘宝链接




淘宝卖家电话采集软件




excel如何制作数据库




stm32与51单片机区别




建筑学需要用的软件




中山大学取消网络教育




手机淘宝客服在哪里




互助保险 知乎




手机sd卡数据恢复软件




千月软件序列号




mysql性能怎么样




java 获取视频尺寸



		

热门问题
    老师的惩罚
    人脸识别
    我在镇武司摸鱼那些年
    重生之率土为王
    我在大康的咸鱼生活
    盘龙之生命进化
    天生仙种
    凡人之先天五行
    春回大明朝
    姑娘不必设防，我是瞎子
    油模温机
    模温机导热油
    进口模温机
    急冷急热模温机
    注塑模温机
    水式模温机
    反应釜模温机
    防爆模温机
    模温机加热管
    水模温机
    模温机品牌
    什么是模温机
    模温机多少钱
    模温机报价
    模温机多少钱一台
    模温机厂
    温模温机
    油温机模温机
    奥德模温机
    蒸气模温机
    科基模温机
    环保模温机
    single 模温机
    hb模温机
    百旺模温机
    模温机冷水机
    注塑机模温机
    single模温机
    压铸机模温机
    信易模温机
    模温机使用
    模温机功能
    模温机说明书
    模温机作用
    压铸模模温机
    模温机泵
    松田模温机
    robamat模温机
    模温机控制器
    模温机行业
    模温机结构


	










程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里