Java tutorial
/* * Copyright (c) 2005, 2006, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ package javax.swing.table; import java.text.Collator; import java.util.*; import javax.swing.DefaultRowSorter; import javax.swing.RowFilter; import javax.swing.SortOrder; /** * An implementation of <code>RowSorter</code> that provides sorting * and filtering using a <code>TableModel</code>. * The following example shows adding sorting to a <code>JTable</code>: * <pre> * TableModel myModel = createMyTableModel(); * JTable table = new JTable(myModel); * table.setRowSorter(new TableRowSorter(myModel)); * </pre> * This will do all the wiring such that when the user does the appropriate * gesture, such as clicking on the column header, the table will * visually sort. * <p> * <code>JTable</code>'s row-based methods and <code>JTable</code>'s * selection model refer to the view and not the underlying * model. Therefore, it is necessary to convert between the two. For * example, to get the selection in terms of <code>myModel</code> * you need to convert the indices: * <pre> * int[] selection = table.getSelectedRows(); * for (int i = 0; i < selection.length; i++) { * selection[i] = table.convertRowIndexToModel(selection[i]); * } * </pre> * Similarly to select a row in <code>JTable</code> based on * a coordinate from the underlying model do the inverse: * <pre> * table.setRowSelectionInterval(table.convertRowIndexToView(row), * table.convertRowIndexToView(row)); * </pre> * <p> * The previous example assumes you have not enabled filtering. If you * have enabled filtering <code>convertRowIndexToView</code> will return * -1 for locations that are not visible in the view. * <p> * <code>TableRowSorter</code> uses <code>Comparator</code>s for doing * comparisons. The following defines how a <code>Comparator</code> is * chosen for a column: * <ol> * <li>If a <code>Comparator</code> has been specified for the column by the * <code>setComparator</code> method, use it. * <li>If the column class as returned by <code>getColumnClass</code> is * <code>String</code>, use the <code>Comparator</code> returned by * <code>Collator.getInstance()</code>. * <li>If the column class implements <code>Comparable</code>, use a * <code>Comparator</code> that invokes the <code>compareTo</code> * method. * <li>If a <code>TableStringConverter</code> has been specified, use it * to convert the values to <code>String</code>s and then use the * <code>Comparator</code> returned by <code>Collator.getInstance()</code>. * <li>Otherwise use the <code>Comparator</code> returned by * <code>Collator.getInstance()</code> on the results from * calling <code>toString</code> on the objects. * </ol> * <p> * In addition to sorting <code>TableRowSorter</code> provides the ability * to filter. A filter is specified using the <code>setFilter</code> * method. The following example will only show rows containing the string * "foo": * <pre> * TableModel myModel = createMyTableModel(); * TableRowSorter sorter = new TableRowSorter(myModel); * sorter.setRowFilter(RowFilter.regexFilter(".*foo.*")); * JTable table = new JTable(myModel); * table.setRowSorter(sorter); * </pre> * <p> * If the underlying model structure changes (the * <code>modelStructureChanged</code> method is invoked) the following * are reset to their default values: <code>Comparator</code>s by * column, current sort order, and whether each column is sortable. The default * sort order is natural (the same as the model), and columns are * sortable by default. * <p> * <code>TableRowSorter</code> has one formal type parameter: the type * of the model. Passing in a type that corresponds exactly to your * model allows you to filter based on your model without casting. * Refer to the documentation of <code>RowFilter</code> for an example * of this. * <p> * <b>WARNING:</b> <code>DefaultTableModel</code> returns a column * class of <code>Object</code>. As such all comparisons will * be done using <code>toString</code>. This may be unnecessarily * expensive. If the column only contains one type of value, such as * an <code>Integer</code>, you should override <code>getColumnClass</code> and * return the appropriate <code>Class</code>. This will dramatically * increase the performance of this class. * * @param <M> the type of the model, which must be an implementation of * <code>TableModel</code> * @see javax.swing.JTable * @see javax.swing.RowFilter * @see javax.swing.table.DefaultTableModel * @see java.text.Collator * @see java.util.Comparator * @since 1.6 */ public class TableRowSorter<M extends TableModel> extends DefaultRowSorter<M, Integer> { /** * Comparator that uses compareTo on the contents. */ private static final Comparator<?> COMPARABLE_COMPARATOR = new ComparableComparator(); /** * Underlying model. */ private M tableModel; /** * For toString conversions. */ private TableStringConverter stringConverter; /** * Creates a <code>TableRowSorter</code> with an empty model. */ public TableRowSorter() { this(null); } /** * Creates a <code>TableRowSorter</code> using <code>model</code> * as the underlying <code>TableModel</code>. * * @param model the underlying <code>TableModel</code> to use, * <code>null</code> is treated as an empty model */ public TableRowSorter(M model) { setModel(model); } /** * Sets the <code>TableModel</code> to use as the underlying model * for this <code>TableRowSorter</code>. A value of <code>null</code> * can be used to set an empty model. * * @param model the underlying model to use, or <code>null</code> */ public void setModel(M model) { tableModel = model; setModelWrapper(new TableRowSorterModelWrapper()); } /** * Sets the object responsible for converting values from the * model to strings. If non-<code>null</code> this * is used to convert any object values, that do not have a * registered <code>Comparator</code>, to strings. * * @param stringConverter the object responsible for converting values * from the model to strings */ public void setStringConverter(TableStringConverter stringConverter) { this.stringConverter = stringConverter; } /** * Returns the object responsible for converting values from the * model to strings. * * @return object responsible for converting values to strings. */ public TableStringConverter getStringConverter() { return stringConverter; } /** * Returns the <code>Comparator</code> for the specified * column. If a <code>Comparator</code> has not been specified using * the <code>setComparator</code> method a <code>Comparator</code> * will be returned based on the column class * (<code>TableModel.getColumnClass</code>) of the specified column. * If the column class is <code>String</code>, * <code>Collator.getInstance</code> is returned. If the * column class implements <code>Comparable</code> a private * <code>Comparator</code> is returned that invokes the * <code>compareTo</code> method. Otherwise * <code>Collator.getInstance</code> is returned. * * @throws IndexOutOfBoundsException {@inheritDoc} */ public Comparator<?> getComparator(int column) { Comparator<?> comparator = super.getComparator(column); if (comparator != null) { return comparator; } Class<?> columnClass = getModel().getColumnClass(column); if (columnClass == String.class) { return Collator.getInstance(); } if (Comparable.class.isAssignableFrom(columnClass)) { return COMPARABLE_COMPARATOR; } return Collator.getInstance(); } /** * {@inheritDoc} * * @throws IndexOutOfBoundsException {@inheritDoc} */ protected boolean useToString(int column) { Comparator<?> comparator = super.getComparator(column); if (comparator != null) { return false; } Class<?> columnClass = getModel().getColumnClass(column); if (columnClass == String.class) { return false; } if (Comparable.class.isAssignableFrom(columnClass)) { return false; } return true; } /** * Implementation of DefaultRowSorter.ModelWrapper that delegates to a * TableModel. */ private class TableRowSorterModelWrapper extends ModelWrapper<M, Integer> { public M getModel() { return tableModel; } public int getColumnCount() { return (tableModel == null) ? 0 : tableModel.getColumnCount(); } public int getRowCount() { return (tableModel == null) ? 0 : tableModel.getRowCount(); } public Object getValueAt(int row, int column) { return tableModel.getValueAt(row, column); } public String getStringValueAt(int row, int column) { TableStringConverter converter = getStringConverter(); if (converter != null) { // Use the converter String value = converter.toString(tableModel, row, column); if (value != null) { return value; } return ""; } // No converter, use getValueAt followed by toString Object o = getValueAt(row, column); if (o == null) { return ""; } String string = o.toString(); if (string == null) { return ""; } return string; } public Integer getIdentifier(int index) { return index; } } private static class ComparableComparator implements Comparator<Object> { @SuppressWarnings("unchecked") public int compare(Object o1, Object o2) { return ((Comparable) o1).compareTo(o2); } } }