compare和compareTo的区别有哪些呢，我看混了

Comparable：让元素自身具备比较性，需要元素对象实现Comparable接口，覆盖compareTo方法

如下面的代码：学生对象是不具备比较性的所以让他实现Comparable接口具备比较性

1. 
   
2. <P>package doo;
   
3. /*
   
4. * |--TreeSet：可以对Set集合中的元素进行排序
   
5. *
   
6. * 需求：往集TreeSet合中存储自定义对象学生
   
7. * 想按照学生的年龄进行排序
   
8. *
   
9. * 记住：排序时当主要条件相同时，一定要判断一下次要条件
   
10. */
    
11. import java.util.*;
    
12. class Student implements Comparable{//强制让元素具备比较性
    
13. private String name;
    
14. private int age;
    
15. Student(String name,int age){
    
16. this.name=name;
    
17. this.age=age;
    
18. }
    
19. //复写这个接口中的方法，并且让他具备想要的比较性</P>
    
20. <P>public int compareTo(Object obj){
    
21. if(!(obj instanceof Student))
    
22. throw new RuntimeException("不是学生对象！");
    
23. Student s=(Student)obj;
    
24. System.out.println(this.name+"**Comparable**"+s.name);
    
25. if(this.age>s.age)
    
26. return 1;
    
27. if(this.age==s.age){
    
28. return this.name.compareTo(s.name);
    
29. }
    
30. 
    
31. 
    
32. return -1;
    
33. }
    
34. public String getName(){
    
35. return name;
    
36. }
    
37. public int getAge(){
    
38. return age;
    
39. }
    
40. }
    
41. public class VectorDemo {
    
42. 
    
43. public static void main(String[] args) {
    
44. TreeSet ts=new TreeSet();
    
45. //TreeSet会为元素进行排序，但是要求元素具备比较性
    
46. //这里是对象没有比较性，所以要让他具备比较性
    
47. ts.add(new Student("lisi04",24));
    
48. ts.add(new Student("lisi01",20));
    
49. ts.add(new Student("lisi03",22));
    
50. ts.add(new Student("lisi02",21));
    
51. ts.add(new Student("lisi05",24));
    
52. 
    
53. Iterator it=ts.iterator();
    
54. while(it.hasNext()){
    
55. Student s=(Student)it.next();
    
56. sop(s.getName()+"****"+s.getAge());
    
57. 
    
58. }
    
59. }
    
60. 
    
61. public static void sop(Object obj){
    
62. System.out.println(obj);
    
63. }
    
64. 
    
65. }</P>

复制代码

Comparator:让集合自身具备比较性，需要定义一个实现了Comparator接口的比较器，并覆盖compare方法，并将类该对象作为实际参数传递给TreeSet集合的构造函数
如代码：

1. package doo;
   
2. /*
   
3. * 练习：按照字符串长度排序
   
4. * 字符串本身具备比较性，但是他的比较方式不是所需要的
   
5. * 这时就能使用比较器
   
6. */
   
7. import java.util.*;
   
8. public class VectorDemo {
   
9. 
   
10. public static void main(String[] args) {
    
11. TreeSet ts=new TreeSet(new StrLenCompare());//将类该对象作为实际参数传递给TreeSet集合的构造函数
    
12. ts.add("abd");
    
13. ts.add("ab");
    
14. ts.add("aaa");
    
15. ts.add("acdsd");
    
16. ts.add("acvd");
    
17. ts.add("a");
    
18. Iterator it=ts.iterator();
    
19. while(it.hasNext()){
    
20. sop(it.next());
    
21. }
    
22. }
    
23. 
    
24. public static void sop(Object obj){
    
25. System.out.println(obj);
    
26. }
    
27. 
    
28. }
    
29. class StrLenCompare implements Comparator{
    
30. public int compare(Object o1,Object o2){
    
31. String s1=(String)o1;
    
32. String s2=(String)o2;
    
33. // if(s1.length()>s2.length())
    
34. // return 1;
    
35. // if(s1.length()==s2.length())
    
36. // return 0;
    
37. int num=new Integer(s1.length()).compareTo(new Integer(s2.length()));
    
38. if(num==0)
    
39. return s1.compareTo(s2);
    
40. return num;
    
41. }
    
42. 
    
43. }

复制代码

第二种方式较为灵活。而且当两种方式都存在时，以比较器为主

燿陚√揚葳 发表于 2014-6-30 12:29
Comparable：让元素自身具备比较性，需要元素对象实现Comparable接口，覆盖compareTo方法

如下面的代码： ...

直接比较元素，复写compareTo   而定义比较器就要复写compare可以这么理解吧，也就是说compareTo就是提供成员比较的，而compare是进行对象比较么？但是这个compare也可以参与到元素的比较之中，可以这么理解么

刚看完这个视频，说下我的理解。
TREESET两种自定义排序的实现方式
从功能上说，其实他们都是一样的。用谁都可以实现，只不过实现的方式不一样。
compareTo()需要在自定义类中实现(implements)Comparable接口并在类中重写compareTo()方法形成自己的比较方法。
当自定义类中没有我们自定义的compareTo()，或者具备的比较性（也就是自定义类中的comparaTo()）不是所需要的时候，我们用comparable接口来扩展我们的比较方式，这会比直接到程序里边修改我们的代码方式好，并不是说不能去修改

24岁？？？ 发表于 2014-6-30 15:36
直接比较元素，复写compareTo   而定义比较器就要复写compare可以这么理解吧，也就是说compareTo就是提供 ...

Comparable让元素自身具备比较性，TreeSet底层就是调用这个方法进行比较的，你里面存放String类型对象他就可以比较，是因为String复写了compareTo方法，可如果元素是一个自定义类的对象的话，它是没有比较性的，也就是说集合在给这个对象进行比较时它都没有compareTo这个比较的方法，集合底层在调用这个方法，所以要让他实现Comparable，让元素具备比较性，其实就是为了复写compareTo方法，让TreeSet集合调用
这种比较方式也称为元素的自然顺序，或者叫做默认顺序

Comparator让集合具备比较性，将一个实现了Comparator接口的类的对象传递给TreeSet，就是告诉TreeSet集合让他不要按照默认方式比较，按照比较器比较，这就是让集合自身具备比较性

你可以理解成一个是默认的比较方式，一个是自定义的比较方式，但是两种方法都是让对象元素具备某种比较性

自建类，如Person，Student本身是不具备比较性的，因为Person与Person之间，Student与Student之间没法比，比啥?身高，年龄，学号？你没说程序就不知道，想让Person、Student具备比较性，这两个class就必须实现Comparable接口，可以查一下某些具备比较性的类，如String、Integer，它们就是实现了Comparable，这才具备了比较性。而在Comparable接口中，只有一个compareTo()方法，既然继承了Comparable接口，那么就要复写它。
而如果你自建的类没有比较性（也就是没有继承Comparable接口），那么只能让集合类中的对象具备比较性，这时候就需要看一下集合类中的构造方法。TreeSet类中的构造方法，其中有一种是可以传入一个比较器（Comparator），既然要传入比较器，自然要新建一个比较器类，这样才能new对象。既然是新建比较器对象，那么不实现Comparator接口怎么行。类Comparator中比较性的方法是compare，复写了之后就行。
第二种灵活，但一般来说，你在自建类时，一定要想到比较性，第二种是在更新换代时才用。所以来说，自建类时，要继承Comparable，复写其中的CompareTo()方法。Comparator接口是补救措施（这个说法不太准确，明白意思吧。）

从字面上看，Comparable是形容词，可比较的。而Comparator是名词，比较器。