求详解 两者区别
已解决，谢谢各位l！！！

comparable&   Comparator    都是用来实现集合中的排序的，只是Comparable是在集合内部定义的方法实现的排序，Comparator是在集合外部实现的排序，所以，如想实现排序，就需要在集合外定义Comparator接口的方法compare()或在集合内实现Comparable接口的方法compareTo()。

Comparable是一个对象本身就已经支持自比较所需要实现的接口（如String    Integer自己就可以完成比较大小操作）   
   
   而Comparator是一个专用的比较器，当这个对象不支持自比较或者自比较函数不能满足你的要求时，你可以写一个比较器来完成两个对象之间大小的比较。

Thinking java 里面的解释：
Comparable是一个对象本身就已经支持自比较所需要实现的接口（如String   Integer自己就可以完成比较大小操作）   
   
  而Comparator是一个专用的比较器，当这个对象不支持自比较或者自比较函数不能满足你的要求时，你可以写一个比较器来完成两个对象之间大小的比较。      
   
  可以说一个是自已完成比较，一个是外部程序实现比较的差别而已。

当需要排序的集合或数组不是单纯的数字型时，通常可以使用Comparator或Comparable，以简单的方式实现对象排序或自定义排序。下面通过两个例子分别用Comparable和Comparator实现对User对象中年龄排序。



1.通过实现Comparable接口，根据User的年龄进行排序。



Java代码  
1.import java.util.Arrays;   
2.  
3./**  
4. * @author pengcqu  
5. *   
6. */  
7.public class ComparableUser implements Comparable {   
8.  
9.    private String id;   
10.    private int age;   
11.  
12.    public ComparableUser(String id, int age) {   
13.        this.id = id;   
14.        this.age = age;   
15.    }   
16.  
17.    public int getAge() {   
18.        return age;   
19.    }   
20.  
21.    public void setAge(int age) {   
22.        this.age = age;   
23.    }   
24.  
25.    public String getId() {   
26.        return id;   
27.    }   
28.  
29.    public void setId(String id) {   
30.        this.id = id;   
31.    }   
32.  
33.    public int compareTo(Object o) {   
34.        return this.age - ((ComparableUser) o).getAge();   
35.    }   
36.  
37.    /**  
38.     * 测试方法  
39.     */  
40.    public static void main(String[] args) {   
41.        ComparableUser[] users = new ComparableUser[] {   
42.                new ComparableUser("u1001", 25),   
43.                new ComparableUser("u1002", 20),   
44.                new ComparableUser("u1003", 21) };   
45.        Arrays.sort(users);   
46.        for (int i = 0; i < users.length; i++) {   
47.            ComparableUser user = users[i];   
48.            System.out.println(user.getId() + " " + user.getAge());   
49.        }   
50.    }   
51.  
52.}  
import java.util.Arrays;

/**
* @author pengcqu
*
*/
public class ComparableUser implements Comparable {

        private String id;
        private int age;

        public ComparableUser(String id, int age) {
                this.id = id;
                this.age = age;
        }

        public int getAge() {
                return age;
        }

        public void setAge(int age) {
                this.age = age;
        }

        public String getId() {
                return id;
        }

        public void setId(String id) {
                this.id = id;
        }

        public int compareTo(Object o) {
                return this.age - ((ComparableUser) o).getAge();
        }

        /**
         * 测试方法
         */
        public static void main(String[] args) {
                ComparableUser[] users = new ComparableUser[] {
                                new ComparableUser("u1001", 25),
                                new ComparableUser("u1002", 20),
                                new ComparableUser("u1003", 21) };
                Arrays.sort(users);
                for (int i = 0; i < users.length; i++) {
                        ComparableUser user = users[i];
                        System.out.println(user.getId() + " " + user.getAge());
                }
        }

}



2. 通过实现Comparator接口，根据User的年龄进行排序。



Java代码  
1.public class User {   
2.  
3.    private String id;   
4.    private int age;   
5.  
6.    public User(String id, int age) {   
7.        this.id = id;   
8.        this.age = age;   
9.    }   
10.  
11.    public int getAge() {   
12.        return age;   
13.    }   
14.  
15.    public void setAge(int age) {   
16.        this.age = age;   
17.    }   
18.  
19.    public String getId() {   
20.        return id;   
21.    }   
22.  
23.    public void setId(String id) {   
24.        this.id = id;   
25.    }   
26.      
27.  
28.}  
public class User {

        private String id;
        private int age;

        public User(String id, int age) {
                this.id = id;
                this.age = age;
        }

        public int getAge() {
                return age;
        }

        public void setAge(int age) {
                this.age = age;
        }

        public String getId() {
                return id;
        }

        public void setId(String id) {
                this.id = id;
        }
       

}

Java代码  
1.import java.util.Arrays;   
2.import java.util.Comparator;   
3.  
4./**  
5. * @author pengcqu  
6. *   
7. */  
8.public class UserComparator implements Comparator {   
9.  
10.    public int compare(Object arg0, Object arg1) {   
11.        return ((User) arg0).getAge() - ((User) arg1).getAge();   
12.    }   
13.  
14.    /**  
15.     * 测试方法  
16.     */  
17.    public static void main(String[] args) {   
18.        User[] users = new User[] { new User("u1001", 25),   
19.                new User("u1002", 20), new User("u1003", 21) };   
20.        Arrays.sort(users, new UserComparator());   
21.        for (int i = 0; i < users.length; i++) {   
22.            User user = users[i];   
23.            System.out.println(user.getId() + " " + user.getAge());   
24.        }   
25.    }   
26.}  
import java.util.Arrays;
import java.util.Comparator;

/**
* @author pengcqu
*
*/
public class UserComparator implements Comparator {

        public int compare(Object arg0, Object arg1) {
                return ((User) arg0).getAge() - ((User) arg1).getAge();
        }

        /**
         * 测试方法
         */
        public static void main(String[] args) {
                User[] users = new User[] { new User("u1001", 25),
                                new User("u1002", 20), new User("u1003", 21) };
                Arrays.sort(users, new UserComparator());
                for (int i = 0; i < users.length; i++) {
                        User user = users[i];
                        System.out.println(user.getId() + " " + user.getAge());
                }
        }
}


选择Comparable接口还是Comparator？

一个类实现了Comparable接口则表明这个类的对象之间是可以相互比较的，这个类对象组成的集合就可以直接使用sort方法排序。

Comparator可以看成一种算法的实现，将算法和数据分离，Comparator也可以在下面两种环境下使用：
1、类的设计师没有考虑到比较问题而没有实现Comparable，可以通过Comparator来实现排序而不必改变对象本身
2、可以使用多种排序标准，比如升序、降序等。

TreeSet排序的第一种方式:让元素自身具备比较性,元素需要实现Comparable接口,覆盖compareTo方法.
        这种方式也称为元素的自然顺序,或者叫默认顺序.
        CompareTo方法如果返回0是相等,1是大于,-1是小于.

TreeSet的第二种排序方式.
        当元素自身不具备比较性时,或者具备的比较性不是所需要的时.
        这时就需要让容器自身具备比较性.
        在集合初始化时,传入一个比较器Comparator对象就有了比较方式.

当两种排序都存在时,以比较器为主.

定义一个类,实现comparator接口,覆盖compare方法.
*/

import java.util.*;
class Student implements Comparable//该接口强制让学生具备比较性重写排序依据
{
        private String name;
        private int age;

        Student(String name,int age)
        {
                this.name=name;
                this.age=age;
        }

        //实现Comparable以后必须复写的方法ComparaTo()
        public int compareTo(Object obj)
        {
                //return 1;如果把整个函数就返回一个1的话,将会怎么放进去,怎么取出来.
                if(!(obj instanceof Student))
                        throw new RuntimeException("不是学生对象");
                Student s=(Student)obj;
               
                //system.out.pritnln(this.name+".....compareto..."+s.name);
                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;
        }
}

class TreeSetDemo2  
{
        public static void main(String[] args)
        {
                TreeSet ts=new TreeSet(new MyCompare());//在集合初始化时传入比较器对象

                ts.add(new Student("lisi02",22));
                ts.add(new Student("lis007",20));
                ts.add(new Student("lisi09",19));
                ts.add(new Student("lisi01",40));

                Iterator it =ts.iterator();

                while (it.hasNext())
                {
                        //System.out.println(it.next());
                        Student stu =(Student)it.next();
                        System.out.println(stu.getName()+"..."+stu.getAge());
                }
               
        }
}

//定义比较器须实现Comparator类。
class MyCompare implements Comparator
{
        public int compare(Object o1,Object o2)
        {
                Student s1=(Student)o1;
                Student s2=(Student)o2;
               
                int num=s1.getName().compareTo(s2.getName());
                if(num==0)
                {
                       
                        //if(s1.getAge()>s2.getAge())
                        //        return 1;
                        //if(s1.getAge()==s2.getAge())
                        //        return 0;
                        //return -1;
                       
                        return new Integer (s1.getAge()).compareTo(new Integer(s2.getAge()));
                }
                return num;

        }

}

实现comparable  是让对象具有比较性， 自动调用里面的compareTo()，实现Comparator是让容器具有比较性，定义一个器 满足我们想要的要求，将比较器传给TreeSet()的构造函数

一个类实现了Comparable接口则表明这个类的对象之间是可以相互比较的，这个类对象组成的集合就可以直接使用sort方法排序。
Comparator可以看成一种算法的实现，将算法和数据分离，Comparator也可以在下面两种环境下使用：
   1、类的设计师没有考虑到比较问题而没有实现Comparable，可以通过Comparator来实现排序而不必改变对象本身
   2、可以使用多种排序标准，比如升序、降序等。
示例代码楼上的都给出了，我就不再刷屏了！

comparator： 是比较器接口，是集合存储时需要的，
comparable ：实现该接口的的类，就具备了自然顺序，