看着JDK做出了基础测试题目，用这两种方式都实现了，却不知道他们到底有什么区别，很多的类都实现了comparable接口，而comparator实现类很少，就这区别吗？望大神解答。谢谢。。。下面是代码：
实现comparable接口的：

1. package com.itheima;
   
2. 
   
3. import java.util.Iterator;
   
4. import java.util.TreeSet;
   
5. 
   
6. public class Test10 {
   
7.         public static void main(String[] args) {
   
8.                 //声明创建TreeSet集合泛型为Student
   
9.                 TreeSet<Student> set = new TreeSet<Student>();
   
10.                 //声明创建五个student并加入set集合
    
11.                 Student stu1 = new Student("小明", 23, 98.5);
    
12.                 Student stu2 = new Student("小红", 24, 45.6);
    
13.                 Student stu3 = new Student("小强", 25, 84.2);
    
14.                 Student stu4 = new Student("小刚", 26, 84.2);
    
15.                 Student stu5 = new Student("小松", 23, 98);
    
16.                 set.add(stu1);
    
17.                 set.add(stu2);
    
18.                 set.add(stu3);
    
19.                 set.add(stu4);
    
20.                 set.add(stu5);
    
21.                 System.out.println("set大小:" + set.size());
    
22.                 //调用所定义的对set集合的输出函数
    
23.                 Myout(set);
    
24.         }
    
25. 
    
26.         public static void Myout(TreeSet<Student> set) {
    
27.                 //迭代set集合
    
28.                 Iterator<Student> it = set.iterator();
    
29.                 //取出迭代器中的元素
    
30.                 while (it.hasNext()) {
    
31.                         Student stu = (Student) it.next();
    
32.                         System.out.println(stu.toString());
    
33.                 }
    
34. 
    
35.         }
    
36. 
    
37. }
    
38. /*
    
39. * 定义Student类，并继承Comparable并实现compareto()方法
    
40. * 在此我直接将泛型加入，省去compareto()中的强转
    
41. *
    
42. */
    
43. class Student implements Comparable<Student>{
    
44.         private String name;
    
45.         private int age;
    
46.         private double score;
    
47. 
    
48.         public Student() {
    
49.         }
    
50.         //增加带参数构造器方便添加数据
    
51.         public Student(String name, int age, double score) {
    
52.                 super();
    
53.                 this.name = name;
    
54.                 this.age = age;
    
55.                 this.score = score;
    
56.         }
    
57.         //增加get set 方法
    
58.         public String getName() {
    
59.                 return name;
    
60.         }
    
61.         public void setName(String name) {
    
62.                 this.name = name;
    
63.         }
    
64.         public int getAge() {
    
65.                 return age;
    
66.         }
    
67.         public void setAge(int age) {
    
68.                 this.age = age;
    
69.         }
    
70.         public double getScore() {
    
71.                 return score;
    
72.         }
    
73.         public void setScore(double score) {
    
74.                 this.score = score;
    
75.         }
    
76.         //覆盖compareTo()方法，定义出自己所需的情况
    
77.         @Override
    
78.         public int compareTo(Student o) {
    
79.                 Student stu = o;
    
80.                 //下面几个if else 语句实现了先通过分数进行排序和年龄进行排序
    
81.                 //如果两者都相同则通过姓名进行排序。
    
82.                 //返回的-1、1和0也可以是其它的证书或者负数
    
83.                 if (this.score < stu.score)
    
84.                         return (int) -1;
    
85.                 else if (this.score > stu.score)
    
86.                         return 1;
    
87.                 else if (this.age > stu.age)
    
88.                         return 1;
    
89.                 else if (this.age < stu.age)
    
90.                         return -1;
    
91.                 else if (this.score == stu.score && this.age == stu.age)
    
92.                         //分数年龄相同则返回姓名的字典顺序差。
    
93.                         return this.name.compareTo(stu.name);
    
94.                 return 0;
    
95.         }
    
96.         //覆盖toString()方法方便调试和显示
    
97.         @Override
    
98.         public String toString() {
    
99.                 return "Student [age=" + age + ", name=" + name + ", score=" + score
    
100.                                 + "]";
     
101.         }
     
102. 
     
103. }

复制代码

实现comparator接口的

1. package com.itheima;
   
2. 
   
3. import java.util.Comparator;
   
4. import java.util.Iterator;
   
5. import java.util.TreeSet;
   
6. 
   
7. public class Test10 {
   
8. 
   
9.         /**
   
10.          * 10、声明类Student，包含3个成员变量：name、age、score，创建5个对象装入TreeSet，
    
11.          * 按照成绩排序输出结果（考虑成绩相同的问题）。
    
12.          */
    
13.         public static void main(String[] args) {
    
14.                 //声明创建TreeSet集合泛型为Student
    
15.                 TreeSet<Student> set = new TreeSet<Student>(new myStudentComparactor());
    
16.                 //声明创建五个student并加入set集合
    
17.                 Student stu1 = new Student("小明", 23, 98.5);
    
18.                 Student stu2 = new Student("小红", 24, 45.6);
    
19.                 Student stu3 = new Student("小强", 25, 84.2);
    
20.                 Student stu4 = new Student("小刚", 26, 84.2);
    
21.                 Student stu5 = new Student("小松", 23, 98);
    
22.                 set.add(stu1);
    
23.                 set.add(stu2);
    
24.                 set.add(stu3);
    
25.                 set.add(stu4);
    
26.                 set.add(stu5);
    
27.                 System.out.println("set大小:" + set.size());
    
28.                 //调用所定义的对set集合的输出函数
    
29.                 Myout(set);
    
30.         }
    
31. 
    
32.         public static void Myout(TreeSet<Student> set) {
    
33.                 //迭代set集合
    
34.                 Iterator<Student> it = set.iterator();
    
35.                 //取出迭代器中的元素
    
36.                 while (it.hasNext()) {
    
37.                         Student stu = (Student) it.next();
    
38.                         System.out.println(stu.toString());
    
39.                 }
    
40. 
    
41.         }
    
42. 
    
43. }
    
44. 
    
45. class Student {
    
46.         private String name;
    
47.         private int age;
    
48.         private double score;
    
49. 
    
50.         public Student() {
    
51.         }
    
52.         //增加带参数构造器方便添加数据
    
53.         public Student(String name, int age, double score) {
    
54.                 super();
    
55.                 this.name = name;
    
56.                 this.age = age;
    
57.                 this.score = score;
    
58.         }
    
59.         //增加get set 方法
    
60.         public String getName() {
    
61.                 return name;
    
62.         }
    
63.         public void setName(String name) {
    
64.                 this.name = name;
    
65.         }
    
66.         public int getAge() {
    
67.                 return age;
    
68.         }
    
69.         public void setAge(int age) {
    
70.                 this.age = age;
    
71.         }
    
72.         public double getScore() {
    
73.                 return score;
    
74.         }
    
75.         public void setScore(double score) {
    
76.                 this.score = score;
    
77.         }
    
78.        
    
79.        
    
80.         //覆盖toString()方法方便调试和显示
    
81.         @Override
    
82.         public String toString() {
    
83.                 return "Student [age=" + age + ", name=" + name + ", score=" + score
    
84.                                 + "]";
    
85.         }
    
86. 
    
87. }
    
88. //自定义排序器
    
89. class myStudentComparactor implements Comparator<Student>{
    
90. 
    
91. 
    
92.         @Override
    
93.         public int compare(Student o1, Student o2) {
    
94.                 if (o1.getScore() > o2.getScore())
    
95.                         return (int) -1;
    
96.                 else if (o1.getScore() < o2.getScore())
    
97.                         return 1;
    
98.                 else if (o1.getAge() > o2.getAge())
    
99.                         return 1;
    
100.                 else if (o1.getAge() < o2.getAge())
     
101.                         return -1;
     
102.                 else if (o1.getScore() == o2.getScore() && o1.getAge() == o2.getAge())
     
103.                         return o1.getName().compareTo(o2.getName());
     
104.                 return 0;
     
105.         }
     
106.        
     
107. }

复制代码

好恐怖的代码，完全看不懂啊

飘过的云 发表于 2015-5-20 23:54
好恐怖的代码，完全看不懂啊

是我写的太乱吗？:o

今天学了，两种 方法都可以实现，采用第二种方法更合理些，它更符合面向对象的思想。

Comparator相当于过滤器  你来啥对象 都通过这个过滤掉
comparable对象本身自定义的比较器

tanzhixue 发表于 2015-5-21 00:15
Comparator相当于过滤器  你来啥对象 都通过这个过滤掉
comparable对象本身自定义的比较器 ...

学习了，都是大神啊

王建伟 发表于 2015-5-21 00:03
是我写的太乱吗？

还没学到那，目前还在面向对象ING

飘过的云 发表于 2015-5-21 00:28
学习了，都是大神啊

你是不是0508的？哪位？看你笔记和我的都差不多一样的

当TreeSet创建对象的时候使用第一种也就是无参构造函数的时候，如果不去实现Comparable接口的话，会报一个类型转换异常的错误，因为TreeSet这种集合本身是不保证迭代顺序的但是它会默认给存入的元素通过魔种方式排序，而Set类的集合元素都是要保证唯一性的，所以TreeSet使用无参构造的时候必须实现Comparable接口重写里面的方法，根据返回值来给写入的元素排序，如果返回值是0那么只添加一个元素，如果元素为正，Java会认为所有元素都不相等会全部添加进去而且是正序的，如果返回值是负数也会全部添加但是是倒序的。

而TreeSet使用带参构造的时候，传入的就是一个Comparator比较器对象，比较器一般都是自己写的，但是必须得实现了Comparator接口的比较器对象，这样我们就通过了比较器来判断了排序条件，而且这样的好处是明显的，符合了开发中对修改关闭，对扩展开放的原则。如果要改变条件可以多些几个比较器文件，这样比较方便也比较安全。

实现comprarable 是让元素自身具备比较性，实现了compatator的类是自定义的比较器啊，有时候即便你的元素自身具备了比较性，后期用的时候发现比较顺序不是你想要的，但是返回去改代码就不太现实，就可以根据现在的需求自定义比较器

....一个是在定义函数的时候 让函数具备比较方法    一个是自定义的比较器

andre 发表于 2015-5-21 00:13
今天学了，两种 方法都可以实现，采用第二种方法更合理些，它更符合面向对象的思想。 ...

是的，不污染要比较的类的代码了。。。

tanzhixue 发表于 2015-5-21 00:15
Comparator相当于过滤器  你来啥对象 都通过这个过滤掉
comparable对象本身自定义的比较器 ...

恩恩，好像是这样。。。。

想要那片海 发表于 2015-5-21 08:04
实现comprarable 是让元素自身具备比较性，实现了compatator的类是自定义的比较器啊，有时候即便你的元素自 ...

恩恩，这样啊。。。。现在只是看着jdk写了出来，看你们说的才发现这么多东西呢，呵呵，谢谢了

志行 发表于 2015-5-21 08:51
....一个是在定义函数的时候 让函数具备比较方法    一个是自定义的比较器

恩恩，是的。。。。。。

王连涛 发表于 2015-5-21 07:48
而TreeSet使用带参构造的时候，传入的就是一个Comparator比较器对象，比较器一般都是自己写的，但是必须得 ...

对修改关闭对扩展开放是什么啊？:(

用自定义类实现Comparable接口，那么这个类就具有排序功能，Comparable和具体你要进行排序的类的实例邦定。而Comparator比较灵活，它没有和任何类绑定，实现它的自定义类仅仅定义了一种排序方式或排序规则。不言而喻，这种方式比较灵活。我们的要排序的类可以分别和多个实现Comparator接口的类绑定，从而达到可以按自己的意愿实现按多种方式排序的目的。Comparable——“静态绑定排序”,Comparator——“动态绑定排序”。

我怎么觉得你是大神呢.亲

Comparator相当于过滤器你来啥对象 都通过这个过滤掉
comparable对象本身自定义的比较器