jtable的排序问题!   点击table各个列头, 然后table中的数据就会按所点列排序  （用jdk1.5)

public class tablesorter extends abstracttablemodel {
    protected tablemodel tablemodel;

    public static final int descending = -1;
    public static final int not_sorted = 0;
    public static final int ascending = 1;

    private static directive empty_directive = new directive（-1, not_sorted);

    public static final comparator comparable_comaprator = new comparator（) {
        public int compare（object o1, object o2) {
            return （（comparable) o1).compareto（o2);
        }
    };
    public static final comparator lexical_comparator = new comparator（) {
        public int compare（object o1, object o2) {
            return o1.tostring（).compareto（o2.tostring（));
        }
    };

    private row[] viewtomodel;
    private int[] modeltoview;

    private jtableheader tableheader;
    private mouselistener mouselistener;
    private tablemodellistener tablemodellistener;
    private map columncomparators = new hashmap（);
    private list sortingcolumns = new arraylist（);

    public tablesorter（) {
        this.mouselistener = new mousehandler（);
        this.tablemodellistener = new tablemodelhandler（);
    }

    public tablesorter（tablemodel tablemodel) {
        this（);
        settablemodel（tablemodel);
    }

    public tablesorter（tablemodel tablemodel, jtableheader tableheader) {
        this（);
        settableheader（tableheader);
        settablemodel（tablemodel);
    }

    private void clearsortingstate（) {
        viewtomodel = null;
        modeltoview = null;
    }

    public tablemodel gettablemodel（) {
        return tablemodel;
    }

    public void settablemodel（tablemodel tablemodel) {
        if （this.tablemodel != null) {
            this.tablemodel.removetablemodellistener（tablemodellistener);
        }

        this.tablemodel = tablemodel;
        if （this.tablemodel != null) {
            this.tablemodel.addtablemodellistener（tablemodellistener);
        }

        clearsortingstate（);
        firetablestructurechanged（);
    }

    public jtableheader gettableheader（) {
        return tableheader;
    }

    public void settableheader（jtableheader tableheader) {
        if （this.tableheader != null) {
            this.tableheader.removemouselistener（mouselistener);
            tablecellrenderer defaultrenderer = this.tableheader.getdefaultrenderer（);
            if （defaultrenderer instanceof sortableheaderrenderer) {
                this.tableheader.setdefaultrenderer（（（sortableheaderrenderer) defaultrenderer).tablecellrenderer);
            }
        }
        this.tableheader = tableheader;
        if （this.tableheader != null) {
            this.tableheader.addmouselistener（mouselistener);
            this.tableheader.setdefaultrenderer（
                    new sortableheaderrenderer（this.tableheader.getdefaultrenderer（)));
        }
    }

    public boolean issorting（) {
        return sortingcolumns.size（) != 0;
    }

    private directive getdirective（int column) {
        for （int i = 0; i < sortingcolumns.size（); i++) {
            directive directive = （directive)sortingcolumns.get（i);
            if （directive.column == column) {
                return directive;
            }
        }
        return empty_directive;
    }

    public int getsortingstatus（int column) {
        return getdirective（column).direction;
    }

    private void sortingstatuschanged（) {
        clearsortingstate（);
        firetabledatachanged（);
        if （tableheader != null) {
            tableheader.repaint（);
        }
    }

    public void setsortingstatus（int column, int status) {
        directive directive = getdirective（column);
        if （directive != empty_directive) {
            sortingcolumns.remove（directive);
        }
        if （status != not_sorted) {
            sortingcolumns.add（new directive（column, status));
        }
        sortingstatuschanged（);
    }

    protected icon getheaderrenderericon（int column, int size) {
        directive directive = getdirective（column);
        if （directive == empty_directive) {
            return null;
        }
        return new arrow（directive.direction == descending, size, sortingcolumns.indexof（directive));
    }

    private void cancelsorting（) {
        sortingcolumns.clear（);
        sortingstatuschanged（);
    }

    public void setcolumncomparator（class type, comparator comparator) {
        if （comparator == null) {
            columncomparators.remove（type);
        } else {
            columncomparators.put（type, comparator);
        }
    }

    protected comparator getcomparator（int column) {
        class columntype = tablemodel.getcolumnclass（column);
        comparator comparator = （comparator) columncomparators.get（columntype);
        if （comparator != null) {
            return comparator;
        }
        if （comparable.class.isassignablefrom（columntype)) {
            return comparable_comaprator;
        }
        return lexical_comparator;
    }

    private row[] getviewtomodel（) {
        if （viewtomodel == null) {
            int tablemodelrowcount = tablemodel.getrowcount（);
            viewtomodel = new row[tablemodelrowcount];
            for （int row = 0; row < tablemodelrowcount; row++) {
                viewtomodel[row] = new row（row);
            }

            if （issorting（)) {
                arrays.sort（viewtomodel);
            }
        }
        return viewtomodel;
    }

    public int modelindex（int viewindex) {
        return getviewtomodel（)[viewindex].modelindex;
    }

    private int[] getmodeltoview（) {
        if （modeltoview == null) {
            int n = getviewtomodel（).length;
            modeltoview = new int[n];
            for （int i = 0; i < n; i++) {
                modeltoview[modelindex（i)] = i;
            }
        }
        return modeltoview;
    }


    public int getrowcount（) {
        return （tablemodel == null) ? 0 : tablemodel.getrowcount（);
    }

    public int getcolumncount（) {
        return （tablemodel == null) ? 0 : tablemodel.getcolumncount（);
    }

    public string getcolumnname（int column) {
        return tablemodel.getcolumnname（column);
    }

    public class getcolumnclass（int column) {
        return tablemodel.getcolumnclass（column);
    }

    public boolean iscelleditable（int row, int column) {
        return tablemodel.iscelleditable（modelindex（row), column);
    }

    public object getvalueat（int row, int column) {
        return tablemodel.getvalueat（modelindex（row), column);
    }

    public void setvalueat（object avalue, int row, int column) {
        tablemodel.setvalueat（avalue, modelindex（row), column);
    }

private class row implements comparable {
        private int modelindex;

        public row（int index) {
            this.modelindex = index;
        }

        public int compareto（object o) {
            int row1 = modelindex;
            int row2 = （（row) o).modelindex;

            for （iterator it = sortingcolumns.iterator（); it.hasnext（);) {
                directive directive = （directive) it.next（);
                int column = directive.column;
                object o1 = tablemodel.getvalueat（row1, column);
                object o2 = tablemodel.getvalueat（row2, column);

                int comparison = 0;

                if （o1 == null && o2 == null) {
                    comparison = 0;
                } else if （o1 == null) {
                    comparison = -1;
                } else if （o2 == null) {
                    comparison = 1;
                } else {
                    comparison = getcomparator（column).compare（o1, o2);
                }
                if （comparison != 0) {
                    return directive.direction == descending ? -comparison : comparison;
                }
            }
            return 0;
        }
    }

    private class tablemodelhandler implements tablemodellistener {
        public void tablechanged（tablemodelevent e) {
           
            if （!issorting（)) {
                clearsortingstate（);
                firetablechanged（e);
                return;
            }
                
            if （e.getfirstrow（) == tablemodelevent.header_row) {
                cancelsorting（);
                firetablechanged（e);
                return;
            }
            int column = e.getcolumn（);
            if （e.getfirstrow（) == e.getlastrow（)
                    && column != tablemodelevent.all_columns
                    && getsortingstatus（column) == not_sorted
                    && modeltoview != null) {
                int viewindex = getmodeltoview（)[e.getfirstrow（)];
                firetablechanged（new tablemodelevent（tablesorter.this, 
                                                     viewindex, viewindex, 
                                                     column, e.gettype（)));
                return;
            }

            clearsortingstate（);
            firetabledatachanged（);
            return;
        }
    }

    private class mousehandler extends mouseadapter {
        public void mouseclicked（mouseevent e) {
            jtableheader h = （jtableheader) e.getsource（);
            tablecolumnmodel columnmodel = h.getcolumnmodel（);
            int viewcolumn = columnmodel.getcolumnindexatx（e.getx（));
            int column = columnmodel.getcolumn（viewcolumn).getmodelindex（);
            if （column != -1) {
                int status = getsortingstatus（column);
                if （!e.iscontroldown（)) {
                    cancelsorting（);
                }
                status = status + （e.isshiftdown（) ? -1 : 1);
                status = （status + 4) % 3 - 1; 
                setsortingstatus（column, status);
            }
        }
    }

    private static class arrow implements icon {
        private boolean descending;
        private int size;
        private int priority;

        public arrow（boolean descending, int size, int priority) {
            this.descending = descending;
            this.size = size;
            this.priority = priority;
        }

        public void painticon（component c, graphics g, int x, int y) {
            color color = c == null ? color.gray : c.getbackground（);             

            int dx = （int)（size/2*math.pow（0.8, priority));
            int dy = descending ? dx : -dx;

            y = y + 5*size/6 + （descending ? -dy : 0);
            int shift = descending ? 1 : -1;
            g.translate（x, y);

            g.setcolor（color.darker（));
            g.drawline（dx / 2, dy, 0, 0);
            g.drawline（dx / 2, dy + shift, 0, shift);
            
            g.setcolor（color.brighter（));
            g.drawline（dx / 2, dy, dx, 0);
            g.drawline（dx / 2, dy + shift, dx, shift);
            
            if （descending) {
                g.setcolor（color.darker（).darker（));
            } else {
                g.setcolor（color.brighter（).brighter（));
            }
            g.drawline（dx, 0, 0, 0);

            g.setcolor（color);
            g.translate（-x, -y);
        }

        public int geticonwidth（) {
            return size;
        }

        public int geticonheight（) {
            return size;
        }
    }

    private class sortableheaderrenderer implements tablecellrenderer {
        private tablecellrenderer tablecellrenderer;

        public sortableheaderrenderer（tablecellrenderer tablecellrenderer) {
            this.tablecellrenderer = tablecellrenderer;
        }

        public component gettablecellrenderercomponent（jtable table, 
                                                       object value,
                                                       boolean isselected, 
                                                       boolean hasfocus,
                                                       int row, 
                                                       int column) {
            component c = tablecellrenderer.gettablecellrenderercomponent（table, 
                    value, isselected, hasfocus, row, column);
            if （c instanceof jlabel) {
                jlabel l = （jlabel) c;
                l.sethorizontaltextposition（jlabel.left);
                int modelcolumn = table.convertcolumnindextomodel（column);
                l.seticon（getheaderrenderericon（modelcolumn, l.getfont（).getsize（)));
            }
            return c;
        }
    }

    private static class directive {
        private int column;
        private int direction;

        public directive（int column, int direction) {
            this.column = column;
            this.direction = direction;
        }
    }
}

jtable table = new jtable（);
tablesorter sorter = new tablesorter（table.getmodel, table.gettableheader（));
table.setmodel（sorter);

import javax.swing.event.listselectionlistener;
import javax.swing.table.abstracttablemodel;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class columnmodeltest{
     
    public columnmodeltest（) {
    
       jframe f = new jframe（);
  
       
        
        f.addwindowlistener（new windowadapter（) {
            public void windowclosing（windowevent e) {
                system.exit（0);
            }
        });
    }

    public static void main（string args[]) {
        jframe f = new jframe（);
         mytablemodel tm=new mytablemodel（);
         tablesorter sorter = new tablesorter（tm); 
       
        jtable table = new jtable（sorter);       
       sorter.settableheader（table.gettableheader（)); 
        table.setpreferredscrollableviewportsize（new dimension（550, 100));
         jscrollpane s = new jscrollpane（table);
         f.getcontentpane（).add（s, borderlayout.center);
         f.settitle（"columnmodeltest");
         f.pack（);
         f.setvisible（true);
         
               
    
    }
      
}

import javax.swing.event.tablemodellistener;
import javax.swing.table.tablemodel;

class mytablemodel implements tablemodel{

     
    object[][] p = {
            {new boolean（false), "人事部","12311","无名", "男", "19920103","本科","物理"},
            {new boolean（false), "人事部","12312","无名", "男", "19920103","本科","物理"},
            {new boolean（false), "人事部","12313","无名", "男", "19920103","本科","物理"},
            {new boolean（false), "人事部","12314","无名", "男", "19920103","本科","物理"}};
    string[] n = {"选择","部门","教师编码","姓名","性别","生日","最终学历","研究领域"};
     
        public int getcolumncount（) {
            return n.length;
        }

        public int getrowcount（) {
            return p.length;
        }

        public string getcolumnname（int col) {
            return n[col];
        }

        public object getvalueat（int row, int col) {
            return p[row][col];
        }
        public class getcolumnclass（int c) {
            return getvalueat（0, c).getclass（);
        }
        public boolean iscelleditable（int rowindex, int columnindex) {
            return true;    
        }
        public void setvalueat（object value, int row, int col) {
            p[row][col] = value;
            firetablecellupdated（row, col);
        }
        private void firetablecellupdated（int row, int col) {
            // todo auto-generated method stub
            
        }

        public void addtablemodellistener（tablemodellistener l){
            
        }
        public void removetablemodellistener（tablemodellistener l){
            
        }
}

   

import javax.swing.event.listselectionlistener;
import javax.swing.table.abstracttablemodel;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class columnmodeltest{
     
    public columnmodeltest（) {
    
       jframe f = new jframe（);
  
       
        
        f.addwindowlistener（new windowadapter（) {
            public void windowclosing（windowevent e) {
                system.exit（0);
            }
        });
    }

    public static void main（string args[]) {
        jframe f = new jframe（);
         mytablemodel tm=new mytablemodel（);
         tablesorter sorter = new tablesorter（tm); 
       
        jtable table = new jtable（sorter);       
       sorter.settableheader（table.gettableheader（)); 
        table.setpreferredscrollableviewportsize（new dimension（550, 100));
         jscrollpane s = new jscrollpane（table);
         f.getcontentpane（).add（s, borderlayout.center);
         f.settitle（"columnmodeltest");
         f.pack（);
         f.setvisible（true);
         
               
    
    }
      
}

import javax.swing.event.tablemodellistener;
import javax.swing.table.tablemodel;

class mytablemodel implements tablemodel{

     
    object[][] p = {
            {new boolean（false), "人事部","12311","无名", "男", "19920103","本科","物理"},
            {new boolean（false), "人事部","12312","无名", "男", "19920103","本科","物理"},
            {new boolean（false), "人事部","12313","无名", "男", "19920103","本科","物理"},
            {new boolean（false), "人事部","12314","无名", "男", "19920103","本科","物理"}};
    string[] n = {"选择","部门","教师编码","姓名","性别","生日","最终学历","研究领域"};
     
        public int getcolumncount（) {
            return n.length;
        }

        public int getrowcount（) {
            return p.length;
        }

        public string getcolumnname（int col) {
            return n[col];
        }

        public object getvalueat（int row, int col) {
            return p[row][col];
        }
        public class getcolumnclass（int c) {
            return getvalueat（0, c).getclass（);
        }
        public boolean iscelleditable（int rowindex, int columnindex) {
            return true;    
        }
        public void setvalueat（object value, int row, int col) {
            p[row][col] = value;
            firetablecellupdated（row, col);
        }
        private void firetablecellupdated（int row, int col) {
            // todo auto-generated method stub
            
        }

        public void addtablemodellistener（tablemodellistener l){
            
        }
        public void removetablemodellistener（tablemodellistener l){
            
        }
}

   

jtable table = new jtable（);
tablesorter sorter = new tablesorter（table.getmodel（), table.gettableheader（));
table.setmodel（sorter);

/*
 * columnmodeltest.java
 *
 * created on 2008-1-11, 下午08:30:11
 */
package com.enrising.table;

import java.awt.borderlayout;

import javax.swing.jframe;
import javax.swing.jpanel;
import javax.swing.jscrollpane;
import javax.swing.jtable;
import javax.swing.event.tablemodellistener;
import javax.swing.table.tablemodel;

public class columnmodeltest extends jpanel {
    public columnmodeltest（) {
        super（new borderlayout（));
        jtable table = new jtable（new mytablemodel（));
        add（new jscrollpane（table), borderlayout.center);
        tablesorter ts = new tablesorter（table.getmodel（), table.gettableheader（));
        table.setmodel（ts);
    }

    public static void createandshowgui（) {
        jframe f = new jframe（"columnmodeltest");
        f.setdefaultcloseoperation（jframe.exit_on_close);
        f.getcontentpane（).add（new columnmodeltest（), borderlayout.center);
        f.pack（);
        f.setvisible（true);
    }

    public static void main（string args[]) {
        javax.swing.swingutilities.invokelater（new runnable（) {

            @override
            public void run（) {
                createandshowgui（);
            }
        });

    }

    public static class mytablemodel implements tablemodel {

        object[][] p = {
                {
                        new boolean（false), "人事部", "12311", "无名", "男", "19920103", "本科", "物理"
                }, {
                        new boolean（false), "人事部", "12312", "无名", "男", "19920103", "本科", "物理"
                }, {
                        new boolean（false), "人事部", "12313", "无名", "男", "19920103", "本科", "物理"
                }, {
                        new boolean（false), "人事部", "12314", "无名", "男", "19920103", "本科", "物理"
                }
        };
        string[] n = {
                "选择", "部门", "教师编码", "姓名", "性别", "生日", "最终学历", "研究领域"
        };

        public int getcolumncount（) {
            return n.length;
        }

        public int getrowcount（) {
            return p.length;
        }

        public string getcolumnname（int col) {
            return n[col];
        }

        public object getvalueat（int row, int col) {
            return p[row][col];
        }

        public class getcolumnclass（int c) {
            return getvalueat（0, c).getclass（);
        }

        public boolean iscelleditable（int rowindex, int columnindex) {
            return true;
        }

        public void setvalueat（object value, int row, int col) {
            p[row][col] = value;
            firetablecellupdated（row, col);
        }

        private void firetablecellupdated（int row, int col) {
            // todo auto-generated method stub

        }

        public void addtablemodellistener（tablemodellistener l) {

        }

        public void removetablemodellistener（tablemodellistener l) {

        }
    }

}

import java.awt.borderlayout;
import java.lang.runnable.*;
import javax.swing.jframe;
import javax.swing.jpanel;
import javax.swing.jscrollpane;
import javax.swing.jtable;
import javax.swing.event.tablemodellistener;
import javax.swing.table.tablemodel;

public class columnmodeltest extends jpanel {
    public columnmodeltest（) {
        super（new borderlayout（));
        jtable table = new jtable（new mytablemodel（));
        add（new jscrollpane（table), borderlayout.center);
        tablesorter ts = new tablesorter（table.getmodel（), table.gettableheader（));[color=#ff0000]//the constructor tablesorter（tablemodel,jtableheader)is undefined[/color]        table.setmodel（ts);
    }

    public static void createandshowgui（) {
        jframe f = new jframe（"columnmodeltest");
        f.setdefaultcloseoperation（jframe.exit_on_close);
        f.getcontentpane（).add（new columnmodeltest（), borderlayout.center);
        f.pack（);
        f.setvisible（true);
    }

    public static void main（string args[]) {
        javax.swing.swingutilities.invokelater（new runnable（) {

           
            public void run（) {
                createandshowgui（);
            }
        });

    }

    public static class mytablemodel implements tablemodel {

        object[][] p = {
                {
                        new boolean（false), "人事部", "12311", "无名", "男", "19920103", "本科", "物理"
                }, {
                        new boolean（false), "人事部", "12312", "无名", "男", "19920103", "本科", "物理"
                }, {
                        new boolean（false), "人事部", "12313", "无名", "男", "19920103", "本科", "物理"
                }, {
                        new boolean（false), "人事部", "12314", "无名", "男", "19920103", "本科", "物理"
                }
        };
        string[] n = {
                "选择", "部门", "教师编码", "姓名", "性别", "生日", "最终学历", "研究领域"
        };

        public int getcolumncount（) {
            return n.length;
        }

        public int getrowcount（) {
            return p.length;
        }

        public string getcolumnname（int col) {
            return n[col];
        }

        public object getvalueat（int row, int col) {
            return p[row][col];
        }

        public class getcolumnclass（int c) {
            return getvalueat（0, c).getclass（);
        }

        public boolean iscelleditable（int rowindex, int columnindex) {
            return true;
        }

        public void setvalueat（o