好吧,给你个可运行的!
我把它贴在javaworld了.
给你个连接
http://www.javaworld.com.tw/jute/post/view?bid=35&id=67635&sty=1&tpg=1&age=0
我把它贴在javaworld了.
给你个连接
http://www.javaworld.com.tw/jute/post/view?bid=35&id=67635&sty=1&tpg=1&age=0
解决方案 »
- 急,求助java连接oracle 10g问题
- ibatis框架与hibernate框架的区别
- 【讨论】关于xfire开发webservice
- JSP 页面显示图片问题
- 如何用Jsp获取当前文件的文件名?
- 关于get的中文乱麻问题
- hibernatetemplate查询会造成sql注入吗
- 研究各大公司(SUN,微软,IBM,HP)身份验证和单点登录(SSO)系统得群,希望有兴趣得人都来研究一下!qq群号码:9993425
- 用jb9中的database pilot测试连数据库时,怎么连不上。
- 在JBX下,如何建立EJB中SESSION BEAN和实体BEAN的本地引用?(搞定马上结贴)
- JTable的数据排序问题
- 豁出去了,一个蔡鸟问题,解决给分,100分
//看这个
package uemc.common.component;
import java.awt.*;
import java.awt.event.*;
import java.util.*;
import java.util.List;
import java.util.ArrayList;
import javax.swing.*;
import javax.swing.event.TableModelEvent;
import javax.swing.event.TableModelListener;
import javax.swing.table.*;/**
* TableSorter is a decorator for TableModels; adding sorting
* functionality to a supplied TableModel. TableSorter does
* not store or copy the data in its TableModel; instead it maintains
* a map from the row indexes of the view to the row indexes of the
* model. As requests are made of the sorter (like getValueAt(row, col))
* they are passed to the underlying model after the row numbers
* have been translated via the internal mapping array. This way,
* the TableSorter appears to hold another copy of the table
* with the rows in a different order.
* <p>
* TableSorter registers itself as a listener to the underlying model,
* just as the JTable itself would. Events revieved from the model
* are examined, sometimes manipulated (typically widened), and then
* passed on to the TableSorter's listeners (typically the JTable).
* If a change to the model has invalidated the order of TableSorter's
* rows, a note of this is made and the sorter will resort the
* rows the next time a value is requested.
* <p>
* When the tableHeader property is set, either by using the
* setTableHeader() method or the two argument constructor, the
* table header may be used as a complete UI for TableSorter.
* The default renderer of the tableHeader is decorated with a renderer
* that indicates the sorting status of each column. In addition,
* a mouse listener is installed with the following behavior:
* <ul>
* <li>
* Mouse-click: Clears the sorting status of all other columns
* and advances the sorting status of that column through three
* values: {NOT_SORTED, ASCENDING, DESCENDING} (then back to
* NOT_SORTED again).
* <li>
* SHIFT-mouse-click: Clears the sorting status of all other columns
* and cycles the sorting status of the column through the same
* three values, in a different order: {NOT_SORTED, DESCENDING, ASCENDING}.
* <li>
* CONTROL-mouse-click and CONTROL-SHIFT-mouse-click: as above except
* that the changes to the column do not cancel the statuses of columns
* that are already sorting - giving a way to initiate a compound
* sort.
* </ul>
*
* @author Philip Milne
* @author Brendon McLean
* @author Dan van Enckevort
* @author Parwinder Sekhon
*
*/ /*
* This is a, long overdue, rewrite of a class of the same name that
* first appeared in the swing table demos in 1997. This version was
* last updated on: 25:2:2004
*/
public class TableSorter extends DefaultTableModel {
protected DefaultTableModel tableModel;
/*降序排列*/
public static final int DESCENDING = -1;
/*没有排序*/
public static final int NOT_SORTED = 0;
/*升序排列*/
public static final int ASCENDING = 1;
/**/
private static Directive EMPTY_DIRECTIVE = new Directive(-1, NOT_SORTED);
/*比较的接口*/
public static final Comparator COMPARABLE_COMAPRATOR = new Comparator() {
public int compare(Object o1, Object o2) {
return ((Comparable) o1).compareTo(o2);
}
};
/*比较的接口*/
public static final Comparator LEXICAL_COMPARATOR = new Comparator() {
public int compare(Object o1, Object o2) {
return o1.toString().compareTo(o2.toString());
}
};
/**/
private Row[] viewToModel;
private int[] modelToView;
/**/
private JTableHeader tableHeader;
private MouseListener mouseListener;
private TableModelListener tableModelListener;
private Map columnComparators = new HashMap();
private List sortingColumns = new ArrayList();
/**/
public TableSorter() {
this.mouseListener = new MouseHandler();
this.tableModelListener = new TableModelHandler();
}
/**/
public TableSorter(DefaultTableModel tableModel) {
this();
setTableModel(this.getChangedM(tableModel));
}
/**/
public TableSorter(DefaultTableModel tableModel, JTableHeader tableHeader) {
this();
setTableHeader(tableHeader);
setTableModel(this.getChangedM(tableModel));
}
/**/
private void clearSortingState() {
viewToModel = null;
modelToView = null;
}
/**/
public TableModel getTableModel() {
return tableModel;
}
/**/
public void setTableModel(DefaultTableModel tableModel) {
if (this.tableModel != null) {
this.tableModel.removeTableModelListener(tableModelListener);
} this.tableModel = tableModel;
if (this.tableModel != null) {
this.tableModel.addTableModelListener(tableModelListener);
}
/**/
clearSortingState();
fireTableStructureChanged();
}
/**/
public JTableHeader getTableHeader() {
return tableHeader;
}
public void setTableHeader(JTableHeader tableHeader) {
if (this.tableHeader != null) {
this.tableHeader.removeMouseListener(mouseListener);
TableCellRenderer defaultRenderer = this.tableHeader.getDefaultRenderer();
if (defaultRenderer instanceof SortableHeaderRenderer) {
this.tableHeader.setDefaultRenderer(((SortableHeaderRenderer) defaultRenderer).tableCellRenderer);
}
}
this.tableHeader = tableHeader;
if (this.tableHeader != null) {
this.tableHeader.addMouseListener(mouseListener);
this.tableHeader.setDefaultRenderer(
new SortableHeaderRenderer(this.tableHeader.getDefaultRenderer()));
}
}
/**/
public boolean isSorting() {
return sortingColumns.size() != 0;
}
/**/
private Directive getDirective(int column) {
for (int i = 0; i < sortingColumns.size(); i++) {
Directive directive = (Directive)sortingColumns.get(i);
if (directive.column == column) {
return directive;
}
}
return EMPTY_DIRECTIVE;
}
/**/
public int getSortingStatus(int column) {
return getDirective(column).direction;
}
/**/
private void sortingStatusChanged() {
clearSortingState();
fireTableDataChanged();
tableHeader.repaint();
}
/**/
public void setSortingStatus(int column, int status) {
Directive directive = getDirective(column);
if (directive != EMPTY_DIRECTIVE) {
sortingColumns.remove(directive);
}
if (status != NOT_SORTED) {
sortingColumns.add(new Directive(column, status));
}
sortingStatusChanged();
}
/**/
protected Icon getHeaderRendererIcon(int column, int size) {
Directive directive = getDirective(column);
if (directive == EMPTY_DIRECTIVE) {
return null;
}
return new Arrow(directive.direction == DESCENDING, size, sortingColumns.indexOf(directive));
}
/**/
private void cancelSorting() {
sortingColumns.clear();
sortingStatusChanged();
}
/**/
public void setColumnComparator(Class type, Comparator comparator) {
if (comparator == null) {
columnComparators.remove(type);
} else {
columnComparators.put(type, comparator);
}
}
/**/
protected Comparator getComparator(int column) {
Class columnType = tableModel.getColumnClass(column);
Comparator comparator = (Comparator) columnComparators.get(columnType);
if (comparator != null) {
return comparator;
}
if (Comparable.class.isAssignableFrom(columnType)) {
return COMPARABLE_COMAPRATOR;
}
return LEXICAL_COMPARATOR;
}
/**/
private Row[] getViewToModel() {
if (viewToModel == null) {
int tableModelRowCount = tableModel.getRowCount();
viewToModel = new Row[tableModelRowCount];
for (int row = 0; row < tableModelRowCount; row++) {
viewToModel[row] = new Row(row);
} if (isSorting()) {
Arrays.sort(viewToModel);
}
}
return viewToModel;
}
/**/
public int modelIndex(int viewIndex) {
return getViewToModel()[viewIndex].modelIndex;
}
private int[] getModelToView() {
if (modelToView == null) {
int n = getViewToModel().length;
modelToView = new int[n];
for (int i = 0; i < n; i++) {
modelToView[modelIndex(i)] = i;
}
}
return modelToView;
}
/**/
// TableModel interface methods
/*得到行数值*/
public int getRowCount() {
return (tableModel == null) ? 0 : tableModel.getRowCount();
}
/*得到列数值*/
public int getColumnCount() {
return (tableModel == null) ? 0 : tableModel.getColumnCount();
}
/*获得某列的名字,而目前各列的名字保存在字符串数组columnNames中*/
public String getColumnName(int column) {
return tableModel.getColumnName(column);
}
/*判断每个单元格的类型*/
public Class getColumnClass(int column) {
return tableModel.getColumnClass(column);
}
/*将表格声明为可编辑的*/
public boolean isCellEditable(int row, int column) {
return tableModel.isCellEditable(modelIndex(row), column);
}
/*获得某行某列的数据,而数据保存在对象数组TableModel中*/
public Object getValueAt(int row, int column) {
return tableModel.getValueAt(modelIndex(row), column);
}
/*改变某个数据的值*/
public void setValueAt(Object aValue, int row, int column) {
tableModel.setValueAt(aValue, modelIndex(row), column);
} // 辅助类; private class Row implements Comparable {
private int modelIndex; public Row(int index) {
this.modelIndex = index;
} public int compareTo(Object o) {
int row1 = modelIndex;
int row2 = ((Row) o).modelIndex; for (Iterator it = sortingColumns.iterator(); it.hasNext();) {
Directive directive = (Directive) it.next();
int column = directive.column;
Object o1 = tableModel.getValueAt(row1, column);
Object o2 = tableModel.getValueAt(row2, column); int comparison = 0;
// Define null less than everything, except null.
if (o1 == null && o2 == null) {
comparison = 0;
} else if (o1 == null) {
comparison = -1;
} else if (o2 == null) {
comparison = 1;
} else {
comparison = getComparator(column).compare(o1, o2);
}
if (comparison != 0) {
return directive.direction == DESCENDING ? -comparison : comparison;
}
}
return 0;
}
} private class TableModelHandler implements TableModelListener {
public void tableChanged(TableModelEvent e) {
// If we're not sorting by anything, just pass the event along.
if (!isSorting()) {
fireTableChanged(e);
return;
}