Java 通过单击列标题进行SWT表排序

在swt表中-字符串排序工作如何对整型值、双精度值和日期值进行排序。这只适用于字符串升序。有谁能提出更好的方法吗

    TableItem item = new TableItem(table, SWT.NONE);
    item.setText(new String[] { "1", "v", "1.1", "20/03/2013" });
    item = new TableItem(table, SWT.NONE);
    item.setText(new String[] { "10", "z", "1.5", "20/04/2013" });
    item = new TableItem(table, SWT.NONE);
    item.setText(new String[] { "3", "a", "1.3", "30/01/2013" });

    Listener sortListener = new Listener() {
        public void handleEvent(Event e) {
            TableItem[] items = table.getItems();
            Collator collator = Collator.getInstance(Locale.getDefault());
            TableColumn column = (TableColumn) e.widget;
            int index = column == tblclmnNumber ? 0 : 1;
            for (int i = 1; i < items.length; i++) {
                String value1 = items[i].getText(index);
                for (int j = 0; j < i; j++) {
                    String value2 = items[j].getText(index);
                    if (collator.compare(value1, value2) < 0) {
                        String[] values = { items[i].getText(0),
                                items[i].getText(1), items[i].getText(2),
                                items[i].getText(3) };
                        items[i].dispose();
                        TableItem item = new TableItem(table, SWT.NONE, j);
                        item.setText(values);
                        items = table.getItems();
                        break;
                    }
                }
            }
            table.setSortColumn(column);
        }
    };
    tblclmnNumber.addListener(SWT.Selection, sortListener);
    tblclmnName.addListener(SWT.Selection, sortListener);
    tblclmnDeci.addListener(SWT.Selection, sortListener);
    tblclmnDate.addListener(SWT.Selection, sortListener);
    table.setSortColumn(tblclmnNumber);
    table.setSortDirection(SWT.UP);

TableItem项目=新的TableItem（表，SWT.NONE）；
项目.setText（新字符串[]{“1”、“v”、“1.1”、“20/03/2013”}）；
项目=新表项目（表，SWT.NONE）；
项目.setText（新字符串[]{“10”、“z”、“1.5”、“20/04/2013”}）；
项目=新表项目（表，SWT.NONE）；
项目.setText（新字符串[]{“3”、“a”、“1.3”、“30/01/2013”}）；
Listener sortListener=new Listener（）{
公共无效handleEvent（事件e）{
TableItem[]items=table.getItems（）；
Collator-Collator=Collator.getInstance（Locale.getDefault（））；
TableColumn=（TableColumn）e.widget；
int index=列==TBLCLMNNNUMBER？0:1；
对于（int i=1；i

我修改了带有排序的SWT代码段，以显示如何对具有不同数据类型的列进行排序

/*
 * Table example snippet: sort a table by column
 *
 * For a list of all SWT example snippets see
 * http://www.eclipse.org/swt/snippets/
 * 
 * @since 3.2
 */
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Date;

import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Event;
import org.eclipse.swt.widgets.Listener;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Table;
import org.eclipse.swt.widgets.TableColumn;
import org.eclipse.swt.widgets.TableItem;

public class SortTable {
    private TableRow rows[] = new TableRow[] {
            new TableRow(1, "aaa", new Date(1363784269000L)),
            new TableRow(2, "abc", new Date(1367784269000L)),
            new TableRow(3, "efc", new Date(1363584269000L)),
            new TableRow(4, "ccc", new Date(1363734269000L)),
        };
    private Table table;
    private TableColumn intColumn;
    private TableColumn strColumn;
    private TableColumn dateColumn;

    public SortTable() {
        Display display = new Display();
        Shell shell = new Shell(display);
        shell.setLayout(new FillLayout());
        table = new Table(shell, SWT.BORDER);
        table.setHeaderVisible(true);
        intColumn = new TableColumn(table, SWT.NONE);
        intColumn.setText("int");
        intColumn.setWidth(50);
        strColumn = new TableColumn(table, SWT.NONE);
        strColumn.setText("string");
        strColumn.setWidth(50);
        dateColumn = new TableColumn(table, SWT.NONE);
        dateColumn.setText("date");
        dateColumn.setWidth(100);

        updateTable();

        Listener sortListener = new Listener() {
            public void handleEvent(Event e) {
                TableColumn column = (TableColumn) e.widget;
                if (column == intColumn) Arrays.sort(rows, BY_VAL);
                if (column == strColumn) Arrays.sort(rows, BY_STR);
                if (column == dateColumn) Arrays.sort(rows, BY_DATE);
                table.setSortColumn(column);
                updateTable();
            }
        };
        intColumn.addListener(SWT.Selection, sortListener);
        strColumn.addListener(SWT.Selection, sortListener);
        dateColumn.addListener(SWT.Selection, sortListener);
        shell.setSize(shell.computeSize(SWT.DEFAULT, SWT.DEFAULT).x, 300);
        shell.open();
        while (!shell.isDisposed()) {
            if (!display.readAndDispatch())
                display.sleep();
        }
        display.dispose();
    }

    private void updateTable() {
        table.removeAll();
        for (TableRow row : rows) {
            TableItem item = new TableItem(table, SWT.NONE);
            item.setText(row.asString());
        }
    }

    public final Comparator<TableRow> BY_VAL = new Comparator<TableRow>() {
        @Override
        public int compare(TableRow o1, TableRow o2) {
            if (o1.val < o2.val) return -1;
            if (o1.val > o2.val) return 1;
            return 0;
        }
    }; 

    public final Comparator<TableRow> BY_STR = new Comparator<TableRow>() {
        @Override
        public int compare(TableRow o1, TableRow o2) {
            return o1.str.compareTo(o2.str);
        }
    }; 

    public final Comparator<TableRow> BY_DATE = new Comparator<TableRow>() {
        @Override
        public int compare(TableRow o1, TableRow o2) {
            return o1.date.compareTo(o2.date);
        }
    };

    private class TableRow {
        private int val;
        private String str;
        private Date date;
        private SimpleDateFormat format = new SimpleDateFormat();


        public TableRow(int val, String str, Date date) {
            this.val = val;
            this.str = str;
            this.date = date;
        }

        public String[] asString() {
            return new String[] {Integer.toString(val), str, format.format(date)};
        }
    }

    public static void main(String[] args) {
        new SortTable();
    }
}

/*
*表示例代码段：按列对表进行排序
*
*有关所有SWT示例代码段的列表，请参见
* http://www.eclipse.org/swt/snippets/
* 
*@自3.2
*/
导入java.text.simpleDataFormat；
导入java.util.array；
导入java.util.Comparator；
导入java.util.Date；
导入org.eclipse.swt.swt；
导入org.eclipse.swt.layout.FillLayout；
导入org.eclipse.swt.widgets.Display；
导入org.eclipse.swt.widgets.Event；
导入org.eclipse.swt.widgets.Listener；
导入org.eclipse.swt.widgets.Shell；
导入org.eclipse.swt.widgets.Table；
导入org.eclipse.swt.widgets.TableColumn；
导入org.eclipse.swt.widgets.TableItem；
公共类可排序{
私有表行[]=新表行[]{
新表行（1，“aaa”，新日期（1363784269000L）），
新表格行（2，“abc”，新日期（1367784269000L）），
新表格行（3，“efc”，新日期（1363584269000L）），
新表行（4，“ccc”，新日期（1363734269000L）），
};
私人餐桌；
private TableColumn intColumn；
私有表列结构列；
私有表列dateColumn；
公共排序表（）{
显示=新显示（）；
外壳=新外壳（显示）；
setLayout（新的FillLayout（））；
表=新表（外壳、SWT.边框）；
表.setheadervible（true）；
intColumn=新表列（表，SWT.NONE）；
intColumn.setText（“int”）；
intColumn.setWidth（50）；
strColumn=新表列（表，SWT.NONE）；
strColumn.setText（“字符串”）；
立柱设置宽度（50）；
dateColumn=新表列（表，SWT.NONE）；
dateColumn.setText（“日期”）；
dateColumn.setWidth（100）；
updateTable（）；
Listener sortListener=new Listener（）{
公共无效handleEvent（事件e）{
TableColumn=（TableColumn）e.widget；
if（column==intColumn）array.sort（rows，BY_VAL）；
if（column==strColumn）Arrays.sort（rows，BY_STR）；
if（column==dateColumn）Arrays.sort（行，按日期）；
表1.setSortColumn（列）；
updateTable（）；
}
};
addListener（SWT.Selection，sortListener）；
strColumn.addListener（SWT.Selection，sortListener）；
dateColumn.addListener（SWT.Selection，sortListener）；
shell.setSize（shell.computeSize（SWT.DEFAULT，SWT.DEFAULT）.x300）；
shell.open（）；
而（！shell.isDisposed（））{
如果（！display.readAndDispatch（））
display.sleep（）；
}
display.dispose（）；
}
私有void updateTable（）{
table.removeAll（）；
用于（表格行：行）{
TableItem项目=新的TableItem（表，SWT.NONE）；
item.setText（row.asString（））；
}
}
公共最终比较器由_VAL=新比较器（）提供{
@凌驾
公共整数比较（表行o1，表行o2）{
如果（o1.valo2.val）返回1；
返回0；
}
}; 
_STR=新比较器（）的公共最终比较器{
@凌驾
公共整数比较（表行o1，表行o2）{
返回o1.str.compareTo（o2.str）；
}
}; 
截止日期的公共最终比较器=新比较器（）{
@凌驾
公共整数比较（表行o1，表行o2）{
返回o1.日期比较（o2.日期）；
}
};
私人类表格行{
私人国际旅行社；
私有字符串str；
私人日期；
私有SimpleDataFormat格式=新SimpleDataFormat（）；
公共表行（int-val，String-str，Date）{
this.val=val；
this.str=str；
this.date=日期；
}
公众的
intColumn = new TableColumn(table, SWT.NONE);
intColumn.setText("int");
intColumn.setWidth(50);
intColumn.setData(new Comparator<TableItem>() {
    @Override
    public int compare(TableItem t1, TableItem t2) {
        int i1 = Integer.parseInt(t1.getText(0));
        int i2 = Integer.parseInt(t2.getText(0));
        if (i1.val < i2.val) return -1;
        if (i1.val > i2.val) return 1;
        return 0;
    }
};
strColumn = new TableColumn(table, SWT.NONE);
strColumn.setText("string");
strColumn.setWidth(50);
strColumn.setData(new Comparator<TableItem>() {
    @Override
    public int compare(TableItem t1, TableItem t2) {
        return t1.getText(1).compareTo(t2.getText(1));
    }
};
dateColumn = new TableColumn(table, SWT.NONE);
dateColumn.setText("date");
dateColumn.setWidth(100);
dateColumn.setData(new Comparator<TableItem>() {
    @Override
    public int compare(TableItem t1, TableItem t2) {
        return Date.parse(t1.getText(2)).compareTo(Date.parse(t2.getText(2)));
    }
};

Listener sortListener = e -> {
    TableColumn sortColumn = table.getSortColumn();
    TableColumn selectedColumn = (TableColumn) e.widget;
    int dir = table.getSortDirection();
    if (sortColumn == selectedColumn) {
        dir = dir == SWT.UP ? SWT.DOWN : SWT.UP;
    } else {
        table.setSortColumn(selectedColumn);
        dir = SWT.UP;
    }
    TableItem[] items = table.getItems();
    final Comparator<TableItem> comparator = (Comparator<TableItem>) selectedColumn.getData();
    for (int i = 1; i < items.length; i++) {
        for (int j = 0; j < i; j++) {
            if ((comparator.compare(items[i], items[j]) < 0 && dir == SWT.UP) || (comparator.compare(items[i], items[j]) > 0 && dir == SWT.DOWN)) {
                String[] oldItem = new String[table.getColumnCount()];
                for (int h = 0; h < table.getColumnCount(); h++) {
                    item[h] = items[i].getText(h);
                }
                items[i].dispose();
                TableItem newItem = new TableItem(table, SWT.NONE, j);
                newItem.setText(oldItem);
                items = table.getItems();
                break;
            }
        }
    }
    table.setSortDirection(dir);
};