Java 按多列对JFace TableViewer排序

我很确定我要问的是不可能的，但我在任何地方都找不到对这个问题的明确否定，所以这里是这样的：

考虑以下工作示例：

public class TableViewerSorter {

private static final String DATA_COMPARATOR = "comparator";

public static void main(String[] args) {
    Display display = new Display();
    Shell shell = new Shell(display);
    shell.setLayout(new FillLayout());

    final TableViewer viewer = new TableViewer(shell, SWT.BORDER);
    Table table = viewer.getTable();
    table.setHeaderVisible(true);
    viewer.setContentProvider(ArrayContentProvider.getInstance());
    viewer.setSorter(new ViewerSorter() {

        @Override
        public int compare(Viewer v, Object e1, Object e2) {
            TableColumn sortColumn = table.getSortColumn();
            Comparator comparator = sortColumn == null ? null : (Comparator) sortColumn.getData(DATA_COMPARATOR);
            if (comparator != null && table.getSortDirection() == SWT.UP) {
                comparator = comparator.reversed();
            }
            return comparator == null ? 0 : comparator.compare(e1, e2);
        }
    });

    createTableViewerColumn(viewer, "ID", v -> v.ordinal());
    createTableViewerColumn(viewer, "Name", v -> v.getDisplayName());
    createTableViewerColumn(viewer, "Fruit", v -> v.isFruit());

    for (TableColumn column : table.getColumns()) {
        column.addListener(SWT.Selection, e -> {
            final Item sortColumn = table.getSortColumn();
            int direction = table.getSortDirection();

            if (column.equals(sortColumn)) {
                direction = direction == SWT.UP ? SWT.DOWN : SWT.UP;
            } else {
                table.setSortColumn(column);
                direction = SWT.UP;
            }
            table.setSortDirection(direction);
            viewer.refresh();
        });
    }
    viewer.setInput(Value.values());

    shell.pack();
    shell.open();

    while (!shell.isDisposed()) {
        if (!display.readAndDispatch()) {
            display.sleep();
        }
    }
    display.dispose();
}

private static <T extends Comparable<T>> TableViewerColumn createTableViewerColumn(TableViewer viewer, String name,
        Function<Value, T> propertyFunction) {
    TableViewerColumn viewerColumn = new TableViewerColumn(viewer, SWT.NONE);
    viewerColumn.setLabelProvider(new ColumnLabelProvider() {
        @Override
        public String getText(Object element) {
            return propertyFunction.apply((Value) element).toString();
        }
    });

    TableColumn column = viewerColumn.getColumn();
    column.setText(name);
    column.setWidth(100);
    column.setData(DATA_COMPARATOR, (Comparator<Value>) (v1, v2) -> propertyFunction.apply(v1).compareTo(propertyFunction.apply(v2)));
    return viewerColumn;
}

static enum Value {
    APPLE, BANANA, CABBAGE, DILL, EGGPLANT;

    String getDisplayName() {
        return name().substring(0, 1) + name().substring(1).toLowerCase();
    }

    boolean isFruit() {
        return this != CABBAGE && this != DILL;
    }
}

static class LabelProvider<T> extends ColumnLabelProvider {

    private final Function<T, String> toStringFunction;

    public LabelProvider(final Function<T, String> toStringFunction) {
        this.toStringFunction = toStringFunction;
    }

    @Override
    public String getText(final Object element) {
        return element == null ? null : this.toStringFunction.apply((T) element);
    }

}
}

公共类TableViewerSorter{
私有静态最终字符串数据\u COMPARATOR=“COMPARATOR”；
公共静态void main（字符串[]args）{
显示=新显示（）；
外壳=新外壳（显示）；
setLayout（新的FillLayout（））；
最终的TableViewer=新的TableViewer（shell，SWT.BORDER）；
Table=viewer.getTable（）；
表.setheadervible（true）；
setContentProvider（ArrayContentProvider.getInstance（））；
viewer.setSorter（新ViewerSorter（）{
@凌驾
公共整数比较（查看器v、对象e1、对象e2）{
TableColumn-sortColumn=table.getSortColumn（）；
Comparator Comparator=sortColumn==null？null：（Comparator）sortColumn.getData（DATA\u Comparator）；
if（comparator！=null&&table.getSortDirection（）==SWT.UP）{
比较器=比较器。反转（）；
}
返回比较器==null？0：比较器。比较（e1，e2）；
}
});
createTableViewerColumn（查看器，“ID”，v->v.ordinal（））；
createTableViewerColumn（查看器，“名称”，v->v.getDisplayName（））；
createTableViewerColumn（查看器，“水果”，v->v.isFruit（））；
for（TableColumn列：table.getColumns（））{
column.addListener（SWT.Selection，e->{
最终项目sortColumn=table.getSortColumn（）；
int direction=table.getSortDirection（）；
if（列等于（sortColumn））{
方向=方向==SWT.UP？SWT.DOWN：SWT.UP；
}否则{
表1.setSortColumn（列）；
方向=SWT.UP；
}
表.设置端口方向（方向）；
viewer.refresh（）；
});
}
viewer.setInput（Value.values（））；
shell.pack（）；
shell.open（）；
而（！shell.isDisposed（））{
如果（！display.readAndDispatch（））{
display.sleep（）；
}
}
display.dispose（）；
}
私有静态TableViewerColumn createTableViewerColumn（TableViewer查看器，字符串名称，
函数属性（函数）{
TableViewerColumn viewerColumn=新的TableViewerColumn（查看器，SWT.NONE）；
viewerColumn.setLabelProvider（新ColumnLabelProvider（）{
@凌驾
公共字符串getText（对象元素）{
返回propertyFunction.apply（（Value）元素）.toString（）；
}
});
TableColumn column=viewerColumn.getColumn（）；
column.setText（名称）；
列。设置宽度（100）；
column.setData（DATA_COMPARATOR，（COMPARATOR）（v1，v2）->propertyFunction.apply（v1）.compareTo（propertyFunction.apply（v2））；
返回viewerColumn；
}
静态枚举值{
苹果、香蕉、卷心菜、莳萝、茄子；
字符串getDisplayName（）{
返回name（）.substring（0，1）+name（）.substring（1.toLowerCase（）；
}
布尔isFruit（）{
退回这个！=卷心菜和这个！=莳萝；
}
}
静态类LabelProvider扩展了ColumnLabelProvider{
私有final函数到stringfunction；
公共LabelProvider（最终函数到字符串函数）{
this.toStringFunction=toStringFunction；
}
@凌驾
公共字符串getText（最终对象元素）{
return元素==null？null：this.toStringFunction.apply（（T）元素）；
}
}
}

我希望用户先单击第二列，然后单击第三列，然后按第三列对输入进行排序，当值相等时，按第二列对输入进行排序

当然，我可以只将单击列的列表添加到

ViewerSorter

，或者（根据排序算法）只使用最后排序的元素列表作为排序的基础，而不是查看器的输入

这是最简单的部分

---

困难的部分是如何向用户传达这个特定的表是按两列排序的。API似乎不支持该用例，但我想确定：JFace表是否可以按多列排序？如果是，怎么做？

目前没有标准方法来指示多个排序列。有一个长期存在的错误，要求支持多个

setSortColumn

列，但从未执行过任何操作。

是。greg-449到目前为止还没有标准实现，这是正确的。如果您真的很想知道如何让它工作，我有一个解决方法，使用

TableColumn.setImage（image）

，在列上设置正确的排序图像。在

TableColumn.setData（key，value）

和

Table.setData（key，value）

中的所有排序列中保持排序顺序，并且从不使用或设置

Table.setortdirection（direction）

和

Table.setortcolumn（）。