50分---再开一帖求解释。。。

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