实现TreeSet排序和遍历map的方法

TreeSet顾名思义是一种Set接口的实现类，然后它的官方解释如下：
public class TreeSet
extends AbstractSet
implements NavigableSet, Cloneable, Serializable
基于 TreeMap 的 NavigableSet 实现。使用元素的自然顺序对元素进行排序，或者根据创建 set 时提供的 Comparator 进行排序，具体取决于使用的构造方法。

此实现为基本操作（add、remove 和 contains）提供受保证的 log(n) 时间开销。

注意，如果要正确实现 Set 接口，则 set 维护的顺序（无论是否提供了显式比较器）必须与 equals 一致。（关于与 equals 一致 的精确定义，请参阅 Comparable 或 Comparator。）这是因为 Set 接口是按照 equals 操作定义的，但 TreeSet 实例使用它的 compareTo（或 compare）方法对所有元素进行比较，因此从 set 的观点来看，此方法认为相等的两个元素就是相等的。即使 set 的顺序与 equals 不一致，其行为也是 定义良好的；它只是违背了 Set 接口的常规协定。

注意，此实现不是同步的。如果多个线程同时访问一个 TreeSet，而其中至少一个线程修改了该 set，那么它必须 外部同步。这一般是通过对自然封装该 set 的对象执行同步操作来完成的。如果不存在这样的对象，则应该使用 Collections.synchronizedSortedSet 方法来“包装”该 set。此操作最好在创建时进行，以防止对 set 的意外非同步访问：

SortedSet s = Collections.synchronizedSortedSet(new TreeSet(…));
此类的 iterator 方法返回的迭代器是快速失败 的：在创建迭代器之后，如果从结构上对 set 进行修改，除非通过迭代器自身的 remove 方法，否则在其他任何时间以任何方式进行修改都将导致迭代器抛出 ConcurrentModificationException。因此，对于并发的修改，迭代器很快就完全失败，而不会冒着在将来不确定的时间发生不确定行为的风险。

注意，迭代器的快速失败行为无法得到保证，一般来说，存在不同步的并发修改时，不可能作出任何肯定的保证。快速失败迭代器尽最大努力抛出 ConcurrentModificationException。因此，编写依赖于此异常的程序的做法是错误的，正确做法是：迭代器的快速失败行为应该仅用于检测 bug。

此类是 Java Collections Framework 的成员。
.
TreeSet原理:
/*
* TreeSet存储对象的时候, 可以排序, 但是需要指定排序的算法
*
* Integer能排序(有默认顺序), String能排序(有默认顺序), 自定义的类存储的时候出现异常(没有顺序)
*
* 如果想把自定义类的对象存入TreeSet进行排序, 那么必须实现Comparable接口
* 在类上implement Comparable
* 重写compareTo()方法
* 在方法内定义比较算法, 根据大小关系, 返回正数负数或零
* 在使用TreeSet存储对象的时候, add()方法内部就会自动调用compareTo()方法进行比较, 根据比较结果使用二叉树形式进行存储
*/
然后下面举一个小例子来实现TreeSet的两种实现方式来实现排序。

//定义一个person1类
package com.dxl.day0411;
import java.util.Comparator;
public class Person1 {
    private int age;
    private String name;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Person1() {
        super();
    }
    public Person1(int age, String name) {
        super();
        this.age = age;
        this.name = name;
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Person1 other = (Person1) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
    @Override
    public String toString() {  
        return ""+age+" "+""+name  ;
    }
}
class Com implements Comparator{
    @Override
    public int compare(Object o1, Object o2) {
        Person1 p1=(Person1) o1;
        Person1 p2=(Person1) o2;
        int i1=p1.getAge()-p2.getAge();
        if (i1==0) {
            return p1.getName().compareTo(p2.getName());
        }else{
            return i1;
        }
    }
}

package com.dxl.day0411;

public class Person2 implements Comparable {
    private int age;
    private String name;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Person2() {
        super();
    }
    public Person2(int age, String name) {
        super();
        this.age = age;
        this.name = name;
    }
    @Override
    public int compareTo(Object o) {
        if (!(o instanceof Person2)) {
            throw new RuntimeException("不能进行转换");
        } else {
            Person2 p = (Person2) o;
            if (this.age > p.age) {
                return 1;
            } else if (this.age < p.age) {
                return -1;
            } else {
                return this.name.compareTo(p.name);
            }
        }
    }
    @Override
    public String toString() {
        return "Person2 [age=" + age + ", name=" + name + "]";
    }
}

package com.dxl.day0411;

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

public class Testreeset {
    public static void main(String[] args) {
        // 方式1：
        TreeSet treeset = new TreeSet(new Com());
        treeset.add(new Person1(15, "li"));
        treeset.add(new Person1(13, "zzi"));
        treeset.add(new Person1(15, "zhang"));
        treeset.add(new Person1(17, "ab"));
        /*
         * 方式2： TreeSet treeset = new TreeSet();// treeset.add(new
         * Person2(15,"li")); treeset.add(new Person2(13,"zzi"));
         * treeset.add(new Person2(15,"zhang")); treeset.add(new
         * Person2(17,"ab"));
         */
        for (Object object : treeset) {
            System.out.println(object);
        }
    }

}

然后第一个的结果是：
13 zzi
15 li
15 zhang
17 ab
第二个结果是：
Person2 [age=13, name=zzi]
Person2 [age=15, name=li]
Person2 [age=15, name=zhang]
Person2 [age=17, name=ab]