我们都知道TreeSet有默认的排序功能，你可以自定义一个排序类来实现Comparator或者Comparable接口，然后在类中重写相应的方法，请问两者的区别，请用代码举例说明？

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

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

Treeset保证元素的唯一性：
一法：
class Student implements Comparable//实现comparable接口，该接口强制让学生具备比较性。
{
        private String name;
        private int age;

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

        public int compareTo(Object obj)//覆盖compareTo方法
        {               
                if(!(obj instanceof Student))
                        throw new RuntimeException("不是学生对象");
                Student s = (Student)obj;
                System.out.println(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;
        }
}
二法：
当元素自身不具备比较性，或者具备的比较性不是所需要的。这时需要让容器自身具备比较性。定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。
当两种排序都存在时，以比较器为主。
定义一个类，实现Comparator接口，覆盖compar方法
import java.util.*;
class  TreeSetTest
{
        public static void main(String[] args)
        {
                TreeSet ts = new TreeSet(new StrLenComparator());

                ts.add("abcd");
                ts.add("cc");
                ts.add("cba");
                ts.add("aaa");
                ts.add("z");
                ts.add("hahaha");

                Iterator it = ts.iterator();

                while(it.hasNext())
                {
                        System.out.println(it.next());
                }
        }
}

class StrLenComparator implements Comparator//实现comparator接口{
        public int compare(Object o1,Object o2)[//color=Red]/覆盖compare方法
        {
                String s1 = (String)o1;
                String s2 = (String)o2;

                /*
                if(s1.length()>s2.length())
                        return 1;
                if(s1.length()==s2.length())
                        return 0;
                        */

                int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
                if(num==0)
                        return s1.compareTo(s2);
                return num;
        }
}

(二法传的时候出现点失误，正确的如下)
二法：
当元素自身不具备比较性，或者具备的比较性不是所需要的。这时需要让容器自身具备比较性。定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。
当两种排序都存在时，以比较器为主。
定义一个类，实现Comparator接口，覆盖compar方法
import java.util.*;
class  TreeSetTest
{
        public static void main(String[] args)
        {
                TreeSet ts = new TreeSet(new StrLenComparator());

                ts.add("abcd");
                ts.add("cc");
                ts.add("cba");
                ts.add("aaa");
                ts.add("z");
                ts.add("hahaha");

                Iterator it = ts.iterator();

                while(it.hasNext())
                {
                        System.out.println(it.next());
                }
        }
}

class StrLenComparator implements Comparator//实现comparator接口
{
        public int compare(Object o1,Object o2)//覆盖compare方法
        {
                String s1 = (String)o1;
                String s2 = (String)o2;

                /*
                if(s1.length()>s2.length())
                        return 1;
                if(s1.length()==s2.length())
                        return 0;
                        */

                int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
                if(num==0)
                        return s1.compareTo(s2);
                return num;
        }
}

这个地方容易记混淆，按单词的字面意义可以帮助记忆，Comparator----比较器（在集合类别定义了一个比较器，他的比较方法与元素无关）。  Comparabe---可比较的（针对的是装入集合的元素）