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

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

例如：[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(数组名);
希望对您有帮助。