这是我基础测试题中的一道题目：声明类Student，包含3个成员变量：name、age、score，创建5个对象装入TreeSet， 按照成绩排序输出结果（考虑成绩相同的问题）。

下面是我做的答案

1. /**
   
2. * 第10题：声明类Student，包含3个成员变量：name、age、score，创建5个对象装入TreeSet，
   
3. * 按照成绩排序输出结果（考虑成绩相同的问题）。
   
4. *
   
5. *
   
6. *
   
7. *
   
8. *
   
9. *
   
10. * */
    
11. import java.util.*;
    
12. public class Test10
    
13. {
    
14. 
    
15. public static void main(String[] args)
    
16. {
    
17. TreeSet<Student> ts=new TreeSet<Student>();
    
18. 
    
19. ts.add(new Student("程序员06",23,89.2));
    
20. ts.add(new Student("程序员10",45,96.0));
    
21. ts.add(new Student("程序员08",32,98.5));
    
22. ts.add(new Student("程序员02",34,96.0)); //成绩相同
    
23. ts.add(new Student("程序员05",14,95.5));
    
24. 
    
25. Iterator<Student> it=ts.iterator();
    
26. while(it.hasNext())
    
27. {
    
28. Student stu=(Student)it.next();
    
29. System.out.println(stu.getName()+"******"+stu.getAge()+"******"+stu.getscore());
    
30. }
    
31. 
    
32. }
    
33. 
    
34. }
    
35. 
    
36. class Student implements Comparable //该接口强制让学生具备比较性
    
37. <Object>
    
38. {
    
39. private String name;
    
40. private int age;
    
41. private double score;
    
42. 
    
43. Student(String name,int age,double score)
    
44. {
    
45. this.name=name;
    
46. this.age=age;
    
47. this.score=score;
    
48. }
    
49. 
    
50. public int compareTo(Object obj)
    
51. {
    
52. if(!(obj instanceof Student))
    
53. throw new RuntimeException("不是学生类型");
    
54. Student s=(Student)obj;
    
55. 
    
56. if(this.score<s.score)
    
57. return 1;
    
58. if(this.score==s.score)
    
59. {
    
60. //成绩相同时比较姓名
    
61. return this.age.compareTo(s.age);
    
62. }
    
63. return -1;
    
64. }
    
65. 
    
66. public String getName()
    
67. {
    
68. return name;
    
69. }
    
70. 
    
71. public int getAge()
    
72. {
    
73. return age;
    
74. }
    
75. 
    
76. public double getscore()
    
77. {
    
78. return score;
    
79. }
    
80. }
    

复制代码

本来是想要在出现成绩相同的情况下，比较年龄

1. if(this.score==s.score)
   
2. {
   
3. //成绩相同时比较年龄
   
4. return this.age.compareTo(s.age);
   
5. }

复制代码

结果提示就报错了，那么代码如何写能比较年龄呢？为什么？

this.age.compareTo(s.age); 改为：return new Integer(this.age).compareTo(new Integer(s.age));   compareTo只适合实现了Comparable的对象类型

if(this.score<s.score)
return 1;
if(this.score==s.score)
{
//成绩相同时比较姓名
return (this.age-s.age);//相减
}
return -1;
}

compareTo用于比较引用数据类型，你的age是int型，直接用> == <，比较就好了
或者把age定义成对象也可以

return this.age.compareTo(s.age);

修改为 return this.age-s.age;

你的代码：
if(this.score==s.score)
{
//成绩相同时比较年龄
return this.age.compareTo(s.age);
}
报错的原因是你的age定义的是int类型的，注意基本数据类型是没有compareTo()方法的
最简单的修改，把你的age改为int的包装类Integer类型

只需要改这一行代码：
private int age;
改为private Integer age;

==整数是用==

1. package cn.com.problem;
   
2. 
   
3. import java.util.*;
   
4. 
   
5. public class ggg {
   
6. 
   
7.         public static void main(String[] args) {
   
8.                 TreeSet<Student> ts = new TreeSet<Student>();
   
9. 
   
10.                 ts.add(new Student("程序员06", 23, 89.2));
    
11.                 ts.add(new Student("程序员10", 45, 96.0));
    
12.                 ts.add(new Student("程序员08", 32, 98.5));
    
13.                 ts.add(new Student("程序员02", 34, 96.0)); // 成绩相同
    
14.                 ts.add(new Student("程序员05", 14, 95.5));
    
15. 
    
16.                 Iterator<Student> it = ts.iterator();
    
17.                 while (it.hasNext()) {
    
18.                         Student stu = (Student) it.next();
    
19.                         System.out.println(stu.getName() + "******" + stu.getAge()
    
20.                                         + "******" + stu.getscore());
    
21.                 }
    
22. 
    
23.         }
    
24. 
    
25. }
    
26. 
    
27. class Student implements Comparable // 该接口强制让学生具备比较性
    
28.                 <Object> {
    
29.         private String name;
    
30.         private int age;
    
31.         private double score;
    
32. 
    
33.         Student(String name, int age, double score) {
    
34.                 this.name = name;
    
35.                 this.age = age;
    
36.                 this.score = score;
    
37.         }
    
38. 
    
39.         public int compareTo(Object obj) {
    
40.                 if (!(obj instanceof Student))
    
41.                         throw new RuntimeException("不是学生类型");
    
42.                 Student s = (Student) obj;
    
43. 
    
44.                 if (this.score < s.score)
    
45.                         return 1;
    
46.                 if (this.score == s.score) {
    
47.                         // 成绩相同时比较姓名
    
48. //                        return this.age.compareTo(s.age);
    
49.                         //Cannot invoke compareTo(int) on the primitive type int这是在将鼠标放在上面那句话时，出现的错误。
    
50.                         //你好好跟一下就知道问题所在了。invoke是调用方法的意思。错误的原因是：不能再基础类型int上调用compareTo方法与基本类型int比较
    
51.                         //所以解决发放很明显，你int强制转换成一个不是int类型的就可以了，比如说Integer、String都行
    
52.                         //        return new Integer(this.age).compareTo(new Integer(s.age));//这种写法也可以
    
53.                         return new String(String.valueOf(this.age)).compareTo(String.valueOf(s.age));//百度一下，就能看见compareTo用于字符串的字符顺序比较。
    
54.                         //所以将其换成字符串
    
55.                 }
    
56.                 return -1;
    
57.         }
    
58. 
    
59.         public String getName() {
    
60.                 return name;
    
61.         }
    
62. 
    
63.         public int getAge() {
    
64.                 return age;
    
65.         }
    
66. 
    
67.         public double getscore() {
    
68.                 return score;
    
69.         }
    
70. }
    

复制代码

comperTo只能比较一些对象，而int和Integer区别恰好就在这里

把int型包装成Integer型，还有加了泛型，迭代就不用强转了，看了不自在