集合TreeSet的使用

　　集合中的TreeSet是集合体系结构中的底层实现，是Collection的孙子，Set的儿子。TreeSet除拥有父接口的特点外，还有其自身的特点。下面就看看TreeSet的排序是怎么实现的。从它的构造方法看，提供了无参和带参两种。
　　常用到的两个构造：
　　无参构造　　public TreeSet()
　　　　构造一个新的空set，该set根据其元素的自然顺序进行排序。插入该set的所有元素都必须实现Comparable接口。
　　带参构造　　public TreeSet(Comparator<? super E> comparator)
　　　　构造一个新的空TreeSet，它根据指定比较器进行排序。
　　API文档里面已经描述的很清楚，要实现排序，要么实现Comparable接口，要么指定比较器Comparator。接下来就分别用两种方式来实现这个过程。
　　描述一个Person类。拥有成员：name、age、有参、无参构造、getters、setters。

package cn.dolphin;

public class Person {
    private String name;
    private int age;
    public Person() {super();}
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

第一种方式：
　　使用有参构造，传递Comparator比较器。而Comparator是接口，所以没有对象，这时传递的就是实现了Comparator接口的子类的对象，而如果这个对象只用到一次又可以写成匿名内部类，于是就有了下面的代码。

package cn.dolphin;

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

public class TreeSetDemo {
    public static void main(String[] args) {
        // 创建TreeSet对象，用来存储Person类型对象。
        TreeSet<Person> ts = new TreeSet<>(new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                int num1 = o1.getName().length() - o2.getName().length();
                int num2 = num1 == 0 ? o1.getName().compareTo(o2.getName()) : num1;
                int num3 = num2 == 0 ? o1.getAge() - o2.getAge() : num2;
                return num3;
            }
        });
        // 创建Person对象并添加到ts集合。
        ts.add(new Person("aidengbao", 30));
        ts.add(new Person("bosideng", 21));
        ts.add(new Person("yichun", 18));
        ts.add(new Person("yichun", 18));
        for (Person s : ts) {
            System.out.println(s.getName() + ":" + s.getAge());
        }
    }
}

当然也可不写成匿名内部类，只是这样就必须得定义一个类来实现Comparator接口，于是用下面的代码：

package cn.dolphin;

import java.util.Comparator;

public class ComparatorImplements implements Comparator<Person>{
    @Override
    public int compare(Person o1, Person o2) {
        //主要条件，按照Person的姓名长度排序，如不相同，则添加到集合。
        int num1 = o1.getName().length() - o2.getName().length();
        //如果姓名长度一样，再比较姓名是否相同。如不相同，则添加到集合。
        int num2 = num1 == 0 ? o1.getName().compareTo(o2.getName()) : num1;
        //如果姓名也相同，再比较年龄是不是相同，如果相同，则不添加到集合，保证数据的唯一。
        int num3 = num2 == 0 ? o1.getAge() - o2.getAge() : num2;
        return num3;
    }
}

这样，有了ComparatorImplements类实现Comparator接口后，就可以用多态的方式创建ComparatorImplements的对象传递给TreeSet。接着看代码：

package cn.dolphin;

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

public class TreeSetDemo {
    public static void main(String[] args) {
        // 创建TreeSet对象，用来存储Person类型对象。
        Comparator<Person> ci = new ComparatorImplements();
        TreeSet<Person> ts = new TreeSet<>(ci);
        // 创建Person对象并添加到ts集合。
        ts.add(new Person("aidengbao", 30));
        ts.add(new Person("bosideng", 21));
        ts.add(new Person("yichun", 18));
        ts.add(new Person("yichun", 18));
        for (Person s : ts) {
            System.out.println(s.getName() + ":" + s.getAge());
        }
    }
}

通过上面的代码，明显看到使用匿名内部类的好处就是简单方便，接下来，再看看用无参构造的实现。
第二种方式：
　　使用无参构造，Person类自己实现Comparable接口。

package cn.dolphin;

public class Person implements Comparable<Person>{
    private String name;
    private int age;
    public Person() {super();}
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public int compareTo(Person o) {
        int num1 = this.name.length() - o.name.length();
        int num2 = num1 == 0 ? this.name.compareTo(o.name) : num1;
        int num3 = num2 == 0 ? this.age - o.age : num2;
        return num3;
    }
}

好像看起来这样要好一点点，因为在这里可以直接使用name和age成员变量，而上面只能过过getName()和getAge()来获取，因为定义的成员在开发中可能都是私有的。Person类实现了Comparable接口，就可以使用无参的构造来对对象进行唯一性判断和对集合排序。

package cn.dolphin;

import java.util.TreeSet;

public class TreeSetDemo {
    public static void main(String[] args) {
        // 创建TreeSet对象，用来存储Person类型对象。
        TreeSet<Person> ts = new TreeSet<>();
        // 创建Person对象并添加到ts集合。
        ts.add(new Person("aidengbao", 30));
        ts.add(new Person("bosideng", 21));
        ts.add(new Person("yichun", 18));
        ts.add(new Person("yichun", 18));
        for (Person s : ts) {
            System.out.println(s.getName() + ":" + s.getAge());
        }
    }
}

虽然写了这么长，但是TreeSet并不是多么重要，用到并不多，所以也就当个了解内容吧，不过多知道点儿总归不是坏事儿。