Java 如何对SWT列进行降序排序

如何进行升序和降序排序。在下面的SWT代码中，升序成功，但当我单击表格标题时，降序不起作用。该怎么办

下面是我的代码

package test;
 import java.text.DecimalFormat;
 import java.text.NumberFormat;
 import java.text.SimpleDateFormat;
 import java.util.Arrays;
 import java.util.Collections;
 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), 0.000565529),
             new TableRow(2, "abc", new Date(1367784269000L),1.09E-06),
            new TableRow(3, "efc", new Date(1363584269000L),0.000273487),
            new TableRow(4, "ccc", new Date(1363734269000L),0.000170431),
           new TableRow(5, "ddd", new Date(1363734269000L),1.09E-06),
           new TableRow(6, "fff", new Date(1363734269000L),0.000273487),
           new TableRow(7, "ggg", new Date(1363734269000L),0.000170431),

};
private Table table;
private TableColumn intColumn;
private TableColumn strColumn;
private TableColumn dateColumn;
private TableColumn scientificColumn;

   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);

    scientificColumn = new TableColumn(table, SWT.NONE);
    scientificColumn.setText("scientificvalue");
    scientificColumn.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);
            if (column == scientificColumn) Arrays.sort(rows,BY_VAL );
            table.setSortColumn(column);
            updateTable();
        }
    };

    Listener reverseSortListener = new Listener() {
        public void handleEvent(Event e) {
            TableColumn column = (TableColumn) e.widget;
            if (column == intColumn) Arrays.sort(rows, Collections.reverseOrder());
            if (column == strColumn) Arrays.sort(rows, Collections.reverseOrder());
            if (column == dateColumn) Arrays.sort(rows, Collections.reverseOrder());
            if (column == scientificColumn) Arrays.sort(rows,Collections.reverseOrder() );
            table.setSortColumn(column);
            updateTable();
        }
    };
      //        intColumn.addListener(SWT.Selection, sortListener);
      //        strColumn.addListener(SWT.Selection, sortListener);
      //        dateColumn.addListener(SWT.Selection, sortListener);
      //        scientificColumn.addListener(SWT.Selection, sortListener);

    intColumn.addListener(SWT.Selection, reverseSortListener);
    strColumn.addListener(SWT.Selection, reverseSortListener);
    dateColumn.addListener(SWT.Selection, reverseSortListener);
    scientificColumn.addListener(SWT.Selection, reverseSortListener);

    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());
        item.setText(row.asDouble());
    }
}

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 double sciVal;

    private SimpleDateFormat format = new SimpleDateFormat();
  //        private   NumberFormat formatter = new DecimalFormat("###.#####");  

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

    public String[] asString() {
        return new String[] {Integer.toString(val), str, format.format(date)};
    }
    public String[] asDouble() {
        return new String[] {Integer.toString(val), str, format.format(date),String.format("%.3E", sciVal)};
    }
}

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

封装测试；
导入java.text.DecimalFormat；
导入java.text.NumberFormat；
导入java.text.simpleDataFormat；
导入java.util.array；
导入java.util.Collections；
导入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），0.000565529），
新表行（2，“abc”，新日期（1367784269000L），1.09E-06），
新表格行（3，“efc”，新日期（1363584269000L），0.000273487），
新表行（4，“ccc”，新日期（1363734269000L），0.000170431），
新表行（5，“ddd”，新日期（1363734269000L），1.09E-06），
新表格行（6，“fff”，新日期（1363734269000L），0.000273487），
新表格行（7，“ggg”，新日期（1363734269000L），0.000170431），
};
私人餐桌；
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）；
scientificColumn=新表列（表，SWT.NONE）；
scientificColumn.setText（“scientificvalue”）；
科学列。设置宽度（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（行，按日期）；
if（column==scientificColumn）array.sort（rows，BY_VAL）；
表1.setSortColumn（列）；
updateTable（）；
}
};
Listener reverseSortListener=new Listener（）{
公共无效handleEvent（事件e）{
TableColumn=（TableColumn）e.widget；
if（column==intColumn）Arrays.sort（rows，Collections.reverseOrder（））；
if（column==strColumn）Arrays.sort（rows，Collections.reverseOrder（））；
if（column==dateColumn）Arrays.sort（rows，Collections.reverseOrder（））；
if（column==scientificColumn）array.sort（rows，Collections.reverseOrder（））；
表1.setSortColumn（列）；
updateTable（）；
}
};
//addListener（SWT.Selection，sortListener）；
//strColumn.addListener（SWT.Selection，sortListener）；
//dateColumn.addListener（SWT.Selection，sortListener）；
//scientificColumn.addListener（SWT.Selection，sortListener）；
addListener（SWT.Selection，reverseSortListener）；
strColumn.addListener（SWT.Selection，reverseSortListener）；
addListener（SWT.Selection，reverseSortListener）；
scientificColumn.addListener（SWT.Selection，reverseSortListener）；
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（））；
item.setText（row.asDouble（））；
}
}
公共最终比较器由_VAL=新比较器（）提供{
@凌驾
公共整数比较（表行o1，表行o2）{
如果（o1.valo2.val）返回1；
返回0；
}
}; 
_STR=新比较器（）的公共最终比较器{
@凌驾
公共整数比较（表行o1，表行o2）{
返回o1.str.compareTo（o2.str）；
}
}; 
截止日期的公共最终比较器=新比较器（）{
@凌驾
公共整数比较（表行o1，表行o2）{
返回o1.日期比较（o2.日期）；
}
};
私人类表格行{
私人国际旅行社；
私有字符串str；
私人日期；
私人双保险；
私有SimpleDataFormat格式=新SimpleDataFormat（）；
//private NumberFormat formatter=新的十进制格式（“####.#####”）；
公共表行（int-val、String-str、Date-Date、double-sciVal）{
this.val=val；
this.str=str；
this.date=日期；
this.sciVal=sciVal；
}
公共字符串[]asString（）{
返回新字符串[]{Integer.toString（val），str，format.format（date）}；
}
公共字符串[]asDouble（）{
返回新字符串[]{Integer.toString（val），str，format.format（date），String.format（“%.3E”，sciVal）}；
}
}
公共静态void main（字符串[]args）{
新的排序表（）；
}

---

}

Collections.reverseOrder（）

返回一个比较器，该比较器根据数组内容的自然顺序对数组进行反向排序。这不是您在这里所需要的，因为您希望对列进行排序

改用