直通车：Java集合框架系列目录

1. 基本概念
2. 继承关系
3. 结构特点
4. 常用API
5. 遍历方式
6. 代码示例

1.基本概念

TreeSet：一种没有重复元素的有序集合。

2.继承关系

TreeSet是一个继承于AbstractSet的有序集。
TreeSet 实现了NavigableSet接口，意即支持一系列的导航方法。
TreeSet实现了Cloneable接口，即覆盖了函数clone()，能被克隆。
TreeSet实现java.io.Serializable接口，意即TreeSet支持序列化，能通过序列化传输。

public class TreeSet<E> extends AbstractSet<E>        
    implements NavigableSet<E>, Cloneable, java.io.Serializable{}

3.结构特点

• 基于TreeMap实现
  构造TreeSet对象时，本质上都是在构造TreeMap对象。

    public TreeSet() {
        this(new TreeMap<E,Object>());
    }
    public TreeSet(Comparator<? super E> comparator) {
        this(new TreeMap<>(comparator));
    }

• 没有重复元素
  哈希表判断元素是否相同：
  判断的是两个元素的哈希值是否相同(HashCode)，如果相同，再判断两个对象的内容是否相同(equals)。

如果equals不相等，那么hashcode可能相等；  
如果equals相等，那么hashcode一定相等。  
如果hashcode相等，那么equals可能相等；  
如果hashcode不相等，那么equals一定不相等。

• 不允许添加null元素

• 不是线程安全的
  可以用Collections的synchronizedSet方法使TreeSet具有线程安全的能力。

Set<T> set = new TreeSet<T>(); // 非同步，非线程安全的Set
Set<T> syncSet = Collections.synchronizedSet(set); 
// 返回了一个线程安全的Set

4.常用API

返回值	函数
boolean	add(E object)
boolean	addAll(Collection collection)
void	clear()
Object	clone()
boolean	contains(Object object)
E	first()
boolean	isEmpty()
E	last()
E	pollFirst()
E	pollLast()
E	lower(E e)
E	floor(E e)
E	ceiling(E e)
E	higher(E e)
boolean	remove(Object object)
int	size()
Comparator	comparator()
Iterator	iterator()
Iterator	descendingIterator()
SortedSet	headSet(E end)
NavigableSet	descendingSet()
NavigableSet	headSet(E end, boolean endInclusive)
SortedSet	subSet(E start, E end)
NavigableSet	subSet(E start, boolean startInclusive, E end, boolean endInclusive)
NavigableSet	tailSet(E start, boolean startInclusive)
SortedSet	tailSet(E start)

5.遍历方式

1.Iterator顺序遍历

for(Iterator iter = set.iterator(); iter.hasNext(); ) { 
    iter.next();
}   

// 假设set是TreeSet对象
for(Iterator iter = set.descendingIterator(); iter.hasNext(); ) { 
    iter.next();
}

2.forEach遍历TreeSet

// 假设set是TreeSet对象，并且set中元素是String类型
String[] arr = (String[])set.toArray(new String[0]);
for (String str:arr)
    System.out.printf("for each : %s\n", str);

6.代码示例

  import java.util.Comparator;  
   import java.util.TreeSet;  
   class  Emp implements Comparable<Emp>{  

       int id;  

       String name;  

       int salary;  

       public Emp(int id, String name, int salary) {  
           super();  
           this.id = id;  
           this.name = name;  
           this.salary = salary;  
       }  

       @Override  
       public String toString() {  
           return "{ 编号："+  this.id+" 姓名："+ this.name+" 薪水："+ this.salary+"}";  
       }  

       //@Override //元素与元素之间的比较规则。  
       // 负整数、零或正整数，根据此对象是小于、等于还是大于指定对象。   
       public int compareTo(Emp o) {  
   //      System.out.println(this.name+"compare"+ e.name);  
           return this.salary- o.salary;  
       }     
   }  


   //自定义一个比较器  
   class MyComparator implements Comparator<Emp>{  

       @Override  
       public int compare(Emp o1, Emp o2) {  
           return o1.id-o2.id;  
       }  

       //根据第一个参数小于、等于或大于第二个参数分别返回负整数、零或正整数。   
       /*@Override 
       public int compare(Object o1, Object o2) { 
           Emp e1 = (Emp) o1; 
           Emp e2 = (Emp) o2; 
           return e1.id - e2.id; 
       }*/  


   }  




   public class Demo6 {  

       public static void main(String[] args) {  
           //创建一个比较器对象  
           MyComparator comparator = new MyComparator();  
           //创建TreeSet的时候传入比较器  
           TreeSet tree = new TreeSet(comparator);  

           tree.add(new Emp(110, "老陆", 100));  
           tree.add(new Emp(113, "老钟", 200));  
           tree.add(new Emp(220, "老汤", 300));  
           tree.add(new Emp(120, "老蔡", 500));  
           System.out.println("集合的元素："+tree);  

       }  
   }  

如有谬误或不完善之处，恳请斧正！