1. import java.util.Iterator;
   
2. import java.util.TreeSet;
   
3. 
   
4. public class Student implements Comparable<Object> {
   
5. 
   
6.         private String name;
   
7.         private int age;
   
8.         private double score;
   
9. 
   
10.         Student(String name, int age, double score) {
    
11. 
    
12.                 this.name = name;
    
13.                 this.age = age;
    
14.                 this.score = score;
    
15.         }
    
16. 
    
17.         public void setName(String name) {
    
18.                 this.name = name;
    
19.         }
    
20. 
    
21.         public String getName() {
    
22.                 return name;
    
23.         }
    
24. 
    
25.         public void setAge(int age) {
    
26.                 this.age = age;
    
27.         }
    
28. 
    
29.         public int getAge() {
    
30.                 return age;
    
31.         }
    
32. 
    
33.         public void setScore(double score) {
    
34.                 this.score = score;
    
35.         }
    
36. 
    
37.         public double getScore() {
    
38.                 return score;
    
39.         }
    
40. 
    
41.         public static void main(String[] args) {
    
42. 
    
43.                 TreeSet<Student> ts = new TreeSet<Student>();
    
44.                 ts.add(new Student("zhangsan", 18, 87));
    
45.                 ts.add(new Student("lisi", 18, 76));
    
46.                 ts.add(new Student("wangwu", 19, 65));
    
47.                 ts.add(new Student("zhaoliu", 17, 69));
    
48.                 ts.add(new Student("zhouqi", 19, 92));
    
49.                 for (Iterator<Student> it = ts.iterator(); it.hasNext();) {
    
50.                         Student stu = (Student) it.next();
    
51.                         System.out.println("姓名:" + stu.getName() + "年齡:" + stu.getAge()
    
52.                                         + "成績" + stu.getScore());
    
53.                 }
    
54.         }
    
55. 
    
56.         public int compareTo(Object obj) {
    
57.         /*
    
58.         我记得在数据类型进行强转时需要健壮性判断
    
59.         我写的是if( obj instanceof Student),因为需要返回值，我突然不知道该怎么写了
    
60.         有谁能帮我分析一下，确定一下if(obj instanceof Student){}的范围
    
61.        */
    
62.                 Student stu = (Student) obj;
    
63.                 // int temp = (int)(this.score-stu.score);
    
64.                 // return temp==0?this.name.compareTo(stu.name):score;
    
65.                 if (stu.score > this.score) {
    
66.                         return 1;
    
67.                 }
    
68.                 if (stu.score < this.score) {
    
69.                         return -1;
    
70.                 } else {
    
71.                         return stu.name.compareTo(this.name);
    
72.                 }
    
73.         }
    
74. }
    

复制代码

• public int compareTo(Object obj) {        
•                 Student stu = (Student) obj;
  
•                  int temp = (int)(this.score-stu.score);
  
•                return temp==0?this.name.compareTo(stu.name):temp;
• }
  

哦了
不过我没测试啊

隋丙跃 发表于 2012-5-16 21:00

public int compareTo(Object obj) {        

                Student stu = (Student) obj;

我开始也是这样写的，但因为score(成绩)的数据类型是double,我没有想出该如何才能使用你的这种简写格式。我想弄明白在强转之前做出健壮性判断该怎么写，尤其是我如果写if(obj instanceof Student){}，我的{}的范围是什么，因为有返回值需要写return语句。不知说的是否清楚，还是麻烦跃哥帮忙瞧瞧。

if (!(obj instanceof Student)) {
}
其实，用到泛型以后，就不用这样写了。

高云飞 发表于 2012-5-16 21:08
if (!(obj instanceof Student)) {
}
其实，用到泛型以后，就不用这样写了。

我刚脑子转过来了，我加了个!就不用在为判断语句后面的{}犯愁了，你刚说加泛型就不需要这样写了？能不能再说得具体一点。

袁錦泰 发表于 2012-5-16 21:37
我刚脑子转过来了，我加了个!就不用在为判断语句后面的{}犯愁了，你刚说加泛型就不需要这样写了？能不能 ...

理解错了，不是针对这个的

嗯，我这是在基础测试时写的，也考虑到了score是小数，给你参考下
----------------
/**
5、定义一个学生类, 需要有
姓名, 年龄, 考试成绩三个成员属性.
属性(成员变量)需要私有并提供get, set方法,
可以通过构造函数进行初始化。
*/

public class StudentDemo
{
        public static void main(String[] args)
        {
                Student stu = new Student("harry", 15, 88.5) ; //构造一个学生对象；
                System.out.println(stu.getName() + "  " + stu.getAge() + "  " +stu.getScore());
                stu.setName("cobe");//设置 name ，age ，score；
                stu.setAge(26);
                stu.setScore(89.5);
                System.out.println(stu.getName() + "  " + stu.getAge() + "  " +stu.getScore());
        }
}

//将编译得到得Stduent.class和SortMyStuDemo类放同一目录一起编译；
class Student
{
        public Student(String name, int age, double score)
        {
                this.name = name ;
                this.age = age ;
                this.score = score;
        }

        public String getName()//获取姓名
        {
                return name;
        }
       
        public int getAge()//获取年龄
        {
                return age;
        }

        public double getScore()//获取分数
        {
                return score;
        }

        public void setName(String name)//设置姓名
        {
                this.name = name;
        }

        public void setAge(int age)//设置年龄
        {
                this.age = age;
        }

        public void setScore(double score)//设置分数
        {
                this.score = score;
        }

private String name;
private int age;
private double score;
}


----------------------------
import java.util.*;

public class SortMyStuDemo
{
        public static void main(String[] args)
        {
                TreeSet<Student> ts = new TreeSet<Student>(new MyCompare());//创建树集，使用MyCompare类排序
                ts.add(new Student("Harry" , 14, 87  ));
                ts.add(new Student("Ameily", 12, 87.5));
                ts.add(new Student("Cobber", 13, 85  ));
                ts.add(new Student("Obamar", 17, 84.5));
                ts.add(new Student("James" , 19, 86.5));

                Iterator<Student> it = ts.iterator();
                while(it.hasNext())
                {   Student stu = it.next();
                        System.out.println("name="+stu.getName()+"... age="+ stu.getAge()+
                                "...score="+stu.getScore());
                }
               
        }
}

class MyCompare implements Comparator<Student>
{
        public int compare(Student s1, Student s2)
        {
                double num = s1.getScore() - s2.getScore();
                if ( num == 0)    //分数相同则按照姓名排序
                                return s1.getName().compareTo(s2.getName());
                else if (num > 0) //使用分数的升序排序；
                        return 1;
                return -1;
        }
}

/*
不使用comparTo方法直接比较分数；而是利用了compareTo方法的返回值就可比较分数大小，从而返回treeset排序的依据；
*/

李文富 发表于 2012-5-17 13:54
嗯，我这是在基础测试时写的，也考虑到了score是小数，给你参考下
----------------
/**

谢谢你！