使用 Glazed Lists 和 JXTable 进行表外列排序

Question

我正在使用 Glazed Lists 来排序和过滤 JXTable。

如何对表外值进行排序？也就是说，我希望能够以自己的方式格式化列值，但对原始值进行排序。

我当前的相关代码：

EventList<Foo> foos = GlazedLists.threadSafeList(new BasicEventList<Foo>());
foos.add(new Foo("bar", 5000000));

ObservableElementList.Connector<Foo> fooConnector = GlazedLists.beanConnector(Foo.class);
EventList<Foo> observedFoos = new ObservableElementList<Foo>(foos, fooConnector);

SortedList<Foo> sortedFoos = new SortedList<Foo>(observedFoos, null);

EventTableModel tableModel = new EventTableModel(sortedFoos, someTableFormat);
JXTable t = new JXTable(tableModel);

new TableComparatorChooser<Foo>(t, sortedFoos, false);

在此示例中，我希望将第二列中的值格式化为 5.0M 而不是 5000000，但是如果我在列表中使用该值，它不会正确排序。

提前致谢。

Answer 1

也许您必须禁用 JXTable 排序，这样它就不会干扰 GL 排序？类似于：

jxtable.setSortable(false);
jxtable.setAutoCreateRowSorter(false);
jxtable.setRowSorter(null);

... 然后在表上安装 GlazedLists TableComparatorChooser ，例如：

TableComparatorChooser.install(jxtable, sortedFoos, TableComparatorChooser.SINGLE_COLUMN);

或者您的意思是，您想要在表中将 5000000 格式化为 5.0M，而不是在列表中？然后你只需要实现你的 TableFormat

public Object getColumnValue(E yourObject, int column)

来返回 5000000 的 5.0M 表示

。...很可能，我没有完全理解这个问题，这些答案没有帮助;-)

编辑：可运行的示例。 ..

查看 main 方法中的代码 - 特别是带有 START-END 注释的代码。
我自己做了一个非常简单的例子，但是你应该明白我的意思。

哦...抱歉类/变量/...的命名;-)

import ca.odell.glazedlists.BasicEventList;
import ca.odell.glazedlists.EventList;
import ca.odell.glazedlists.SortedList;
import ca.odell.glazedlists.gui.TableFormat;
import ca.odell.glazedlists.swing.EventTableModel;
import ca.odell.glazedlists.swing.TableComparatorChooser;
import java.util.Comparator;
import java.util.List;
import javax.swing.ComboBoxEditor;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import org.jdesktop.swingx.JXTable;

public class Tester {

    private static class MyObject implements Comparable<MyObject> {

        private final int number;
        private final String value;

        public MyObject(int number, String value) {
            this.number = number;
            this.value = value;
        }

        public int getNumber() {
            return number;
        }

        public String getValue() {
            return value;
        }

        @Override
        public int compareTo(MyObject t) {
            return value.compareTo(t.getValue());
        }
    }

    private static class MyTableFormat implements TableFormat<MyObject> {

        @Override
        public int getColumnCount() {
            return 2;
        }

        @Override
        public String getColumnName(int i) {
            switch (i) {
                case 0:
                    return "FormattedNumber";
                case 1:
                    return "String";
                default:
                    throw new IllegalStateException();
            }
        }

        @Override
        public Object getColumnValue(MyObject e, int i) {
            switch (i) {
                case 0:
                    return getNumberString(e.getNumber());
                case 1:
                    return e.getValue();
                default:
                    throw new IllegalStateException();
            }
        }

        private Object getNumberString(int number) {
            switch (number) {
                case 1:
                    return "One";
                case 2:
                    return "Two";
                case 3:
                    return "Three";
                default:
                    throw new IllegalStateException();
            }
        }
    }

    private static class MyComparator implements Comparator<MyObject> {

        @Override
        public int compare(MyObject t, MyObject t1) {
            return Integer.valueOf(t.getNumber()).compareTo(Integer.valueOf(t1.getNumber()));
        }

    }

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        EventList<MyObject> list = new BasicEventList<MyObject>();
        list.add(new MyObject(1, "A"));
        list.add(new MyObject(2, "B"));
        list.add(new MyObject(3, "C"));

        SortedList<MyObject> sortedList = new SortedList<MyObject>(list);

        EventTableModel<MyObject> tableModel = new EventTableModel<MyObject>(sortedList, new MyTableFormat());
        JXTable jxtable = new JXTable(tableModel);

        /** 
         * START
         * - Deactivate JXTables build-in sorting
         * - Install GlazedLists sorting
         * - Set the comparator for the "string number" column
         */

        // deactivate sorting of JXTable
        jxtable.setSortable(false);
        jxtable.setAutoCreateRowSorter(false);
        jxtable.setRowSorter(null);

        // enable GlazedLists sorting
        TableComparatorChooser<MyObject> tcc = TableComparatorChooser.install(jxtable, sortedList, TableComparatorChooser.SINGLE_COLUMN);

        // set the comparator for your "string number" column
        List<Comparator> comparators = tcc.getComparatorsForColumn(0);
        comparators.clear();
        comparators.add(new MyComparator());

        /**
         * END
         */

        JFrame f = new JFrame("Tester");
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.getContentPane().add(new JScrollPane(jxtable));
        f.pack();
        f.setVisible(true);
    }
}