我想请问下各位，在treeset集合中，如果集合自身具有了比较器，而集合中的对象也实现了comparable接口，具有了比较性，那么这个程序中，到底是参考哪个呢？谢谢。

哥们，说错了请见谅，我认为如果集合自身具有了比较器，而集合中的对象也实现了comparable接口，原因可能是对象比较方式不是所需要的，这是就需要使用集合自身具有了比较器

尽量使用对象的比较性吧,因为我们学的就是面向对象,各种对象用到的比较多,我们可能会修干用到对象的比较性,treeset集合不一定会一直用到

我们一般都用Arraylist对吧?treeset,用的比较少对不对?那么这个嘶吼treeset集合的比较性对我们来讲究没有意义了,所以,我个人认为用对象的比较性比较好,我们会养成一个习惯的

在treeset集合中，如果集合自身具有了比较器，而集合中的对象也实现了comparable接口，具有了比较性，那么这个程序中，到底是参考哪个呢

在TreeSet集合中，如果对象类实现了comparable接口，是可以实现TreeSet的“指定顺序”排序。


但是在开发中，添加的对象类，很可能不是由我们书写，我们无法更改；
或者对象类中所实现的排序方法我们不适用


这样就需要我们让集合自身来可以排序（实现Comparator，重写compare方法）。
这样可以清晰的明确，排序方法优先级：


如果集合自身无比较性，按照集合对象类中的方法排序。
如果集合自身有比较性，优先按照集合自身的比较性排序。

代码举例：
/**
        需求：实现TreeSet 自定义排序两种并存，查看当两种方式并存时，按照哪种方式排序。        

       @author 李小然
*/


import java.util.Iterator;
import java.util.TreeSet;
import java.util.Comparator;


class Person
{
        private String name;
        private int age;
        
        public Person(String _name, int _age)
        {
                this.name = _name;
                this.age = _age;
        }
        
        //按照年龄排序
        public int compareTo(Object obj)
        {
                Person p = (Person)obj;
               
                return this.getAge()-p.getAge();
        }
        
        public void setName(String _name)
        {
                this.name = _name;
        }
        public String getName()
        {
                return name;
        }
        
        public void setAge(int _age)
        {
                this.age = _age;
        }
        public int getAge()
        {
                return age;
        }
}


class CompareToByNameAndAge implements Comparator
{
        //按照名字顺序排序
        @Override
        public int compare(Object o1, Object o2)
        {
                Person p1 = (Person)o1;
                Person p2 = (Person)o2;
               
                return (p1.getName()).compareTo(p2.getName());
        }
}


public class TreeSetBothMethod
{
        public static void main(String[] args)
        {
                TreeSet ts = new TreeSet(new CompareToByNameAndAge());
               
                ts.add(new Person("zhangsan", 20) );
                ts.add(new Person("lisi", 21) );
                ts.add(new Person("wangwu", 19) );
                ts.add(new Person("zhaoqi", 30) );
                ts.add(new Person("gaoba", 25) );
               
                Iterator it = ts.iterator();
               
                while(it.hasNext())
                {
                        Person p = (Person)it.next();
                        System.out.println("name: " + p.getName() +
                                                         " age: " + p.getAge());
                }
        }
}

最后的结果是按照名字的字母顺序排序的，验证完毕。

下面以代码解析吧。。。。。

public class TreeSe {

                public static void main(String[]args)
                {
                        TreeSet ts = new TreeSet(new Mycompare());//指定使用比较器进行排序
                       
                        ts.add(new StuTwo("lisi01",32));
                        ts.add(new StuTwo("lisi007",33));
                        ts.add(new StuTwo("lisi06",30));
                        ts.add(new StuTwo("lisi08",31));
                       
                        Iterator it = ts.iterator();
                       
                        while(it.hasNext())
                        {
                                StuTwo s = (StuTwo)it.next();
                                System.out.println(s.getAge()+".."+s.getName());
                        }
                }
}
//比较器：comparetor
class Mycompare implements Comparator
{
        public int compare(Object o1,Object o2)
        {
                StuTwo s1 = (StuTwo)o1;
                StuTwo s2 = (StuTwo)o2;
               
                int num = s1.getName().compareTo(s2.getName());
               
                //如果主要条件相同，也就是等于0，就判断次要条件，
                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;
        }
}

class StuTwo
{
        private String name;
        private int age;
        public String getName()
        {
                return name;
        }
        public int getAge()
        {
                return age;
        }
        StuTwo(String name,int age)
        {
                this.name=name;
                this.age=age;
        }
        public int compareTo(Object obj)
        {
                if(!(obj instanceof StuTwo))
                {
                        throw new RuntimeException("不是学生对象");
                }
                StuTwo st = (StuTwo)obj;
                if(this.age>st.age)
                {
                        return 1;
                }
                if(this.age==st.age)
                {
                        return this.name.compareTo(st.getName());
                }
                return -1;
        }
}

希望对你有所帮助。。。。