如何对带有空行的 java JTable 进行排序并强制空行始终位于最后？

Question

我使用 JTable，在表底部有一个空行，以便能够向表中添加新行。

在空行中插入或写入数据后，我将自动在其下方添加一个新的空行。 （它应该像微软可视化表一样）

我正在使用java默认行排序器，

问题是我需要空行一直是最后一行！但对表进行排序后，它成为第一行。

DefaultRowSorter 类的“compare(int model1, int model2)”方法获取 2 行号，如果第一行的值为 null 和 1，则返回 -1如果第二行的值为空。如果是 DESCENDING，则乘以 -1 以获得倒序。

            //Treat nulls as < then non-null
            if (v1 == null) {
                if (v2 == null) {
                    result = 0;
                } else {
                    result = -1;
                }
            } else if (v2 == null) {
                result = 1;
            } else {
                result = sortComparators[counter].compare(v1, v2);
            }
            if (sortOrder == SortOrder.DESCENDING) {
                result *= -1;
            }

空行按最小值排序，在 DESCENDING 的情况下，它将成为第一行（因为乘以 -1）并导致很多问题。

我可以覆盖它，并且如果空行（通常是最后一行）在降序模式下不会乘以 -1，并且它将是任何排序后的最后一行。 但问题是“compare”方法及其调用者“Row”内部类在DefaultRowSorter内部是私有的。

有没有办法避免对空行进行排序并使其始终是最后一行？

Answer 1

我尝试了一下，我想我找到了解决方案。

我没有在 TableModel 中创建该空行，而是在 JTable 中伪造它，并且仅在用户实际输入一些数据时才创建它。

RowSorter 仅对 TableModel 的行进行排序，因此我们的行不受影响并保留为最后一行。

public class NewLineTable extends JTable {

    @Override
    public int getRowCount() {
        // fake an additional row
        return super.getRowCount() + 1;
    }

    @Override
    public Object getValueAt(int row, int column) {
        if(row < super.getRowCount()) {
            return super.getValueAt(row, column);
        }
        return ""; // value to display in new line
    }

    @Override
    public int convertRowIndexToModel(int viewRowIndex) {
        if(viewRowIndex < super.getRowCount()) {
            return super.convertRowIndexToModel(viewRowIndex);
        }
        return super.getRowCount(); // can't convert our faked row
    }

    @Override
    public void setValueAt(Object aValue, int row, int column) {
        if(row < super.getRowCount()) {
            super.setValueAt(aValue, row, column);
        }
        else {
            Object[] rowData = new Object[getColumnCount()];
            Arrays.fill(rowData, "");
            rowData[convertColumnIndexToModel(column)] = aValue;
            // That's where we insert the new row.
            // Change this to work with your model.
            ((DefaultTableModel)getModel()).addRow(rowData);
        }
    }
}

Answer 2

DefaultRowSorter 绝对是有缺陷的。

唯一的选择是基于 DefaultRowsorter 创建您自己的 RowSorter 并纠正问题。

Answer 3

我通过仅子类化 TableRowSorter 找到了另一个解决方案。

来自 DefaultRowSorter我们知道的文档：

比较器永远不会传递 null

当子类化 DefaultRowSorter.ModelWrapper 时，我们可以返回一个特殊的 Null 对象并创建一个处理该值的自定义比较器。

这是我的代码。它可能不如自定义 RowSorter 实现那么高效，并且可能仍然包含一些错误，我没有测试所有内容，但对于我的要求，它可以工作。

class EmptyTableRowSorter<M extends AbstracTableModel> extends TableRowSorter<M> {

    private static final EmptyValue emptyValue = new EmptyValue();

    public EmptyTableRowSorter(M model) {
        super(model);
    }

    @Override
    public void modelStructureChanged() {
        // deletes comparators, so we must set again
        super.modelStructureChanged();

        M model = getModelWrapper().getModel();
        for (int i = 0; i < model.getColumnCount(); i++) {
            Comparator<?> comparator = this.getComparator(i);
            if (comparator != null) {
                Comparator wrapper = new EmptyValueComparator(comparator, this, i);
                this.setComparator(i, wrapper);
            }
        }
    }

    @Override
    public void setModel(M model) {
        // also calls setModelWrapper method
        super.setModel(model);

        ModelWrapper<M, Integer> modelWrapper = getModelWrapper();
        EmptyTableModelWrapper emptyTableModelWrapper = new EmptyTableModelWrapper(modelWrapper);

        // calls modelStructureChanged method
        setModelWrapper(emptyTableModelWrapper);
    }

    /**
     * The DefaulRowSorter implementation does not pass null values from the table
     * to the comparator.
     * This implementation is a wrapper around the default ModelWrapper,
     * returning a non null object for our empty row that our comparator can handle.
     */
    private class EmptyTableModelWrapper extends DefaultRowSorter.ModelWrapper {

        private final DefaultRowSorter.ModelWrapper modelWrapperImplementation;

        public EmptyTableModelWrapper(ModelWrapper modelWrapperImplementation) {
            this.modelWrapperImplementation = modelWrapperImplementation;
        }

        @Override
        public Object getModel() {
            return modelWrapperImplementation.getModel();
        }

        @Override
        public int getColumnCount() {
            return modelWrapperImplementation.getColumnCount();
        }

        @Override
        public int getRowCount() {
            return modelWrapperImplementation.getRowCount();
        }

        @Override
        public Object getValueAt(int row, int column) {
            M model = EmptyTableRowSorter.this.getModel();

            // my model has the empty row always at the end,
            // change this depending on your needs
            int lastRow = model.getRowCount() - 1;
            if (row == lastRow) {
                return emptyValue;
            }
            return modelWrapperImplementation.getValueAt(row, column);
        }

        //@Override
        //public String getStringValueAt(int row, int column) {
        //    //  also override this if there is no comparator definied for a column
        //}

        @Override
        public Object getIdentifier(int row) {
            return modelWrapperImplementation.getIdentifier(row);
        }

    }

     /**
      * This is a wrapper around another comparator.
      * We handle our empty value and if none, we invoke the base comparator.
      */
    private class EmptyValueComparator implements Comparator {

        private final Comparator defaultComparator;

        private final TableRowSorter tableRowSorter;

        private final int columnIndex;

        public EmptyValueComparator(Comparator defaultComparator, TableRowSorter tableRowSorter, int columnIndex) {
            this.defaultComparator = defaultComparator;
            this.tableRowSorter = tableRowSorter;
            this.columnIndex = columnIndex;
        }

        @Override
        public int compare(Object o1, Object o2) {
            if (o1 instanceof EmptyValue && o2 instanceof EmptyValue) {
                return 0;
            }
            if (o1 instanceof EmptyValue) {
                return adjustSortOrder(1);
            }
            if (o2 instanceof EmptyValue) {
                return adjustSortOrder(-1);
            }
            return defaultComparator.compare(o1, o2);
        }

        /**
         * Changes the result so that the empty row is always at the end,
         * regardless of the sort order.
         */
        private int adjustSortOrder(int result) {
            List sortKeys = tableRowSorter.getSortKeys();
            for (Object sortKeyObject : sortKeys) {
                SortKey sortKey = (SortKey) sortKeyObject;
                if (sortKey.getColumn() == columnIndex) {
                    SortOrder sortOrder = sortKey.getSortOrder();
                    if (sortOrder == SortOrder.DESCENDING) {
                        result *= -1;
                    }
                    return result;
                }
            }
            return result;
        }

    }

    private static class EmptyValue {}

}

现在您可以在表中启用排序。

JTable table = ...;
TableRowSorter tableRowSorter = new EmptyTableRowSorter(table.getModel());
table.setRowSorter(tableRowSorter);

Answer 4

我知道这是一个旧线程，但我被困在这里试图找到一种方法。如果有以前未提及的新方法，请告诉我。实际上，这是我关于 SO 的第一篇文章，但由于我花了很多时间寻找解决方案，所以我决定分享。

我解决了这个排序问题，而不是使用“null”作为“新条目”，而是创建了一个特定的对象（在我的例子中是来自 Object 类本身，但它可能是更有意义的东西，比如“NewEntryDoNotCompareWithMePleaseLetMeBeTheLastEntryIBegYouDoNotSortMe”空类）。

比较时，我首先检查要比较的“对象”是否是对象。当然不是“instanceof”，而是(obj.getClass() == Object.class)。 -- 如果是这种情况，请检查排序顺序并返回 1 或 -1。

请随意评论您发现的任何问题，如果有人需要代码，我可以尝试创建一个小型工作版本。

干杯，
丹尼尔

Answer 5

使用 DefaultRowSorter 的 setComparator 方法。