如何使用对象的属性对对象进行排序？

Demo：按学生成绩进行排序
定义一个student类[code=java]package com.cast.heima;

public class Student {

        private int score;
       
        private int id;

        public int getScore() {
                return score;
        }

        public void setScore(int score) {
                this.score = score;
        }

        public int getId() {
                return id;
        }

        public void setId(int id) {
                this.id = id;
        }

        public Student(int score, int id) {
                super();
                this.score = score;
                this.id = id;
        }

        @Override
        public String toString() {
                return "Person [score=" + score + ", id=" + id + "]";
        }
}[/code]排序运行类[code=java]package com.cast.heima;

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

public class MySort {

        public static void main(String[] args) {
                @SuppressWarnings({ "rawtypes", "unused", "unchecked" })
                  //实例化一个TreeSet，初始化是传递一个Comparator比较器
                TreeSet<Student> set = new TreeSet<Student>(new Comparator(){

                        @Override
                        public int compare(Object o1, Object o2) {
                                Student p1 = (Student)o1;
                                Student p2 = (Student)o2;
                                return p1.getScore()-p2.getScore();
                        }
                       
                });
                  //实例化5个Student并对成员变量赋初始值
                Student student1 = new Student(100, 1);
                Student student2 = new Student(38, 2);
                Student student3 = new Student(60, 3);
                Student student4 = new Student(70, 4);
                Student student5 = new Student(45, 5);
                  //把五个对象放入带比较器的set中
                set.add(student1);
                set.add(student2);
                set.add(student3);
                set.add(student4);
                set.add(student5);
                //使用迭代器对set集合进行迭代并打印
                for(Iterator<Student> iter = set.iterator();iter.hasNext();){
                        System.out.println(iter.next());
                }
        }
}
运行结果：
                Student [score=38, id=2]
                Student [score=45, id=5]
                Student [score=60, id=3]
                Student [score=70, id=4]
                Student [score=100, id=1][/code]
[ 本帖最后由 杨志罡 于 2011-07-28  20:47 编辑 ]

谢谢  你的思路还是很清晰的 看得比较明白。

[code]import java.util.*;
class TreeSetDemo
{
  public static void main(String[] args)
  {
     TreeSet ts=new TreeSet();
     
     ts.add(new Student("zhangsan",11));
     ts.add(new Student("lisi",12));
     ts.add(new Student("wangwu",13));
     ts.add(new Student("zhaoliu",14));
     
     Iterator it=ts.iterator();
     while(it.hasNext())
     {
        //System.out.println(it.next());
        Student stu=(Student)it.next();
        System.out.println(stu.getName()+"::"+stu.getAge());
     }
     
  }
}

class Student implements Comparable        //Comparable接口强制让学生具备比较性。
{
   private String name;
   private int age;
   
   public Student(String name,int age)
   {
      this.name=name;
      this.age=age;
   }
   
   public int compareTo(Object obj)
   {
        if(!(obj instanceof Student))
            throw new RuntimeException("不是学生对象");
        Student s=(Student)obj;
        
        
        if(this.age>s.age)
            return 1;
        if(this.age==s.age)
        {
           return this.name.compareTo(s.name);//判断次要条件。
        }
        return -1;
     
            
   }
   public String getName()
   {
      return name;
   }
   
   public int getAge()
   {
      return age;
   }
}[/code]也可以让一个类继承Comparable接口。运行结果如下:
zhangsan::11
lisi::12
wangwu::13
zhaoliu::14

分别取出两个对象的某个属性（如成绩）并对比该两属性大小，得出大小后将[color=Red]整个对象进行交换[/color] 而不是单单交换比较的那两个属性[code=java]package com.student;

import java.util.ArrayList;
import java.util.List;

public class Student {
        private String name;
        public  int Score;
       
        public Student(){}
       
        public Student(String name, int corse) {
                super();
                this.name = name;
                this.Score = corse;
        }
       
        public String getName() {
                return name;
        }
        public void setName(String name) {
                this.name = name;
        }
        public int getCorse() {
                return Score;
        }
        public void setCorse(int corse) {
                this.Score = corse;
        }
       
        public static void sortByScore(List<Student> list){//因为排序不属于莫个成员变量特有的属性所这里用了static 修饰符
                Student s=null;
                for (int i = 0; i < list.size()-1; i++) {
                        for (int j = list.size()-1; j >i; j--) {
                                if(list.get(j).Score>list.get(j-1).Score){
                                        //交换的是整个Student对象
                                        s=list.get(j);
                                        list.set(j, list.get(j-1));
                                        list.set(j-1, s);
                                }
                        }
                }
        }

        public static void printout( ArrayList<Student>list){
                for (int i = 0; i < list.size(); i++) {
                        System.out.println(list.get(i).name+"  "+list.get(i).Score);
                }
        }
       
        public static void main(String []args){
                ArrayList<Student> list =new  ArrayList <Student>() ;
                Student stu=new Student("张三", 85);
                list.add(stu);
               
                Student stu1=new Student();
                stu1.setName("李四");
                stu1.setCorse(88);
                list.add(stu1);
               
                Student stu2=new Student();
                stu2.setName("王五");
                stu2.setCorse(68);
                list.add(stu2);
               
                Student stu3=new Student();
                stu3.setName("赵六");
                stu3.setCorse(98);
                list.add(stu3);
               
                Student stu4=new Student();
                stu4.setName("兰兰");
                stu4.setCorse(96);
                list.add(stu4);
               
                Student.sortByScore(list);
                Student.printout(list);
               
                int []a={4,7};
                a.toString();
        }
}[/code]结果[code=java]赵六  98
兰兰  96
李四  88
张三  85
王五  68[/code]一定要把整个Student对象交换

例如：[code]//对学生进行成绩排序
//应用Comparable 接口实现排序
import java.util.*;
class Student implements Comparable<Student>
{
        private String name;
        private int age;
        private double result;
        public Student(String n,int a,double r)
        {
                name = n;
                age = a;
                result = r;
                }
        public String getName()
    {
            return name;
            }
    public int getAge()
    {
            return age;
            }
    public double getResult()
    {
            return result;
            }
    public int compareTo(Student other)
    {
            if(result < other.result) return -1;
            if(result > other.result) return 1;
            return 0;
            }
}
public class StudentSortTest
{
        public static void main(String[] args)
        {
                Student[] staff = new Student[5];
               
                staff[0] = new Student("wang",13,50.5);
            staff[1] = new Student("wang",13,80.0);
                staff[2] = new Student("wang",13,90.5);
                staff[3] = new Student("wang",13,70.0);
                staff[4] = new Student("wang",13,60.5);
               
                Arrays.sort(staff);
                for(Student e : staff)
                 System.out.println("name=" + e.getName() + ",age=" + e.getName() + ",result=" + e.getResult());
                }
        }[/code]

我个人一般是先创建包含对象属性的数组，然后用快速排序即Arrays.sort(数组名);
希望对您有帮助。