TreeSet

 

 

public class Person implements Comparable<Person>{
	String name=null;
	Integer age=null;
	
	
	public Person(String name, Integer age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public int compareTo(Person o) {
	//	return 0;                //当compareTo方法返回0的时候集合中只有一个元素
    //  return 1;                //当compareTo方法返回正数的时候集合会怎么存就怎么取
    //  return -1;                //当compareTo方法返回负数的时候集合会倒序存储
		
		//为什么返回0，只会存一个元素，返回-1会倒序存储，返回1会怎么存就怎么取呢？原因在于TreeSet底层其实是一个二叉树机构，且每插入一个新元素(第一个除外)都会调用```compareTo()```方法去和上一个插入的元素作比较，并按二叉树的结构进行排列。
		//1. 如果将```compareTo()```返回值写死为0，元素值每次比较，都认为是相同的元素，这时就不再向TreeSet中插入除第一个外的新元素。所以TreeSet中就只存在插入的第一个元素。
		//2. 如果将```compareTo()```返回值写死为1，元素值每次比较，都认为新插入的元素比上一个元素大，于是二叉树存储时，会存在根的右侧，读取时就是正序排列的。
		//3. 如果将```compareTo()```返回值写死为-1，元素值每次比较，都认为新插入的元素比上一个元素小，于是二叉树存储时，会存在根的左侧，读取时就是倒序序排列的。
		int num = this.age - o.age;               // 年龄是比较的主要条件
		 return num == 0 ? this.name.compareTo(o.name) : num;//姓名是比较的次要条件
        
       // int num = this.name.compareTo(o.name);        //姓名是主要条件
      //  return num == 0 ? this.age - o.age : num;    //年龄是次要条件
	}
	

 

package com.cf.test.set;

import java.util.Comparator;
import java.util.Iterator;
import java.util.NavigableSet;
import java.util.SortedSet;

/**
 * Treeset底层是二叉树
 * 
 * @author 橘猫
 *
 */
public class TreeSet {
	@SuppressWarnings("all")
	public static void main(String[] args) {

		java.util.TreeSet<Person> tr = new java.util.TreeSet<>();
		tr.add(new Person("李一", 1));
		tr.add(new Person("李二", 2));
		tr.add(new Person("李三", 8));
		tr.add(new Person("李四", 9));
		tr.add(new Person("李五", 0));
		tr.add(new Person("李一", 1));
		System.out.println(tr);
		for (Iterator iterator = tr.iterator(); iterator.hasNext();) {
			Person person = (Person) iterator.next();
			System.out.println(person.age);
		}
		{
			// 将collection中的所有元素添加到此set中
			boolean addAll = tr.addAll(tr);
			System.out.println("是否成功-----" + addAll);
			// 这里返回是false 由此可见set是不能有重复数据的
		}
		{
			// ceiling返回此set中大于等于给定元素的最小元素，如果不存在这样的元素 ，则返回null
			Person ceiling = tr.ceiling(new Person("李大", 6));
			System.out.println("返回此set中大于等于给定元素的最小元素------" + ceiling);
		}
		{
			// 返回此set中严格小于给定元素的最大元素;如果不存在这个元素,则返回null
			Person lower = tr.lower(new Person("李一", 1));
			System.out.println("是否存在--------" + lower.name + "--------" + lower.age);
		}
		{
			// 返回此set中小于等于给定元素的最大元素；如果不存在这样的元素，则返回null
			Person floor = tr.floor(new Person("李五", 0));
			System.out.println("小于等于给定元素的最大元素-----" + floor.name + "-----" + floor.age);
		}
		{
			// 返回此set的部分试图,其元素严格小于toElement
			SortedSet<Person> headSet = tr.headSet(new Person("李一", 1));
			for (Person person : headSet) {
				System.out.println("返回此set中元素小于参数---------" + person.name + "-------" + person.age);
			}
		}
		{
			// comparator是对set中的元素进行排序的比较器，如果此set使用其元素的元素,则返回null
			Comparator<? super Person> comparator = tr.comparator();
			System.out.println(comparator);
		}
		{
			// 返回set中的元素数
			int size = tr.size();
			System.out.println("返回set中的元素数-----------" + size);
		}
		{
			// 返回此set中当前的最后一个元素
			Person last = tr.last();
			System.out.println("返回此set中当前最后一个元素---------" + last.name + "----" + last.age);
		}
		{
			// 返回当前第一个最低的元素
			Person first = tr.first();
			System.out.println("当前的最低(第一个)元素------" + first.name + "-------" + first.age);
		}
		{
			// 返回此set中严格大于给定元素的最小元素;如果不存在这个元素,则返回null
			Person higher = tr.higher(new Person("李一", 1));
			System.out.println("返回set中国严格大于给定元素的最小元素-------" + higher.name + "------" + higher.age);
		}
		{
			// 复制一份此set
			java.util.TreeSet<Person> clone = (java.util.TreeSet<Person>) tr.clone();
			for (Person person : clone) {
				System.out.println("复制后数据--------" + person.name + "------" + person.age);
			}
		}
		{
			// 判断此set元素中是否包含1 比较类型要与add的类型一致
			boolean contains = tr.contains(new Person("李五", 0));
			System.out.println("判断此set元素中是否包含------------" + contains);
		}
		{
			// 返回在此set元素上按降序进行迭代的迭代器
			Iterator<Person> descendingIterator = tr.descendingIterator();
			for (Iterator iterator = tr.iterator(); iterator.hasNext();) {
				Person person = (Person) iterator.next();
				System.out.println("降序后的顺序-------" + person.name + "--------" + person.age);
			}

		}
		{
			// 返回此set中元素上按升序进行迭代的迭代器
			Iterator<Person> iterator = tr.iterator();
			for (Iterator iterator2 = tr.iterator(); iterator2.hasNext();) {
				Person person = (Person) iterator2.next();
				System.out.println("升序后的顺序--------" + person.name + "-------" + person.age);
			}
		}

		{
			// 返回此set中所包含元素的逆序视图
			NavigableSet<Person> descendingSet = tr.descendingSet();
			for (Person person : descendingSet) {
				System.out.println("逆序试图-------" + person.name + "------" + person.age);
			}
		}
		{
			//返回此set部分试图,其元素大于等于fromElement
			SortedSet<Person> tailSet = tr.tailSet(new Person("李一", 0));
			for (Iterator iterator = tailSet.iterator(); iterator.hasNext();) {
				Person person = (Person) iterator.next();
				System.out.println("返回元素大于等于参数-----"+person.name+"------"+person.age);
			}
		}
		{
			//返回此set部分试图其元素大于（或等于，参数为true时）
			NavigableSet<Person> tailSet = tr.tailSet(new Person("李一", 0), true);
			for (Iterator iterator = tailSet.iterator(); iterator.hasNext();) {
				Person person = (Person) iterator.next();
				System.out.println("返回元素大于等于参数,有true-----"+person.name+"------"+person.age);

			}
		}
		
		{
			// 返回set中的元素数
			int size = tr.size();
			System.out.println("元素数" + size);
		}
		{
			// 返回set得部分试图，从参数一到参数二 但是不包括参数二
			SortedSet<Person> subSet = tr.subSet(new Person("李一", 0), new Person("李四", 9));
			for (Iterator iterator = subSet.iterator(); iterator.hasNext();) {
				Person person = (Person) iterator.next();
				System.out.println("返回set的部分试图，从参数一到参数二------" + person.name + "-------" + person.age);
			}

		}
		{
			// 返回set得部分试图，从参数一到参数二 用true或false判断是否包含在内
			NavigableSet<Person> subSet = tr.subSet(new Person("李一", 0), true, new Person("李四", 9), true);
			for (Iterator iterator = subSet.iterator(); iterator.hasNext();) {
				Person person = (Person) iterator.next();
				System.out.println("返回set的部分试图，从参数一到参数二有true----" + person.name + "-------" + person.age);

			}
		}
		
		{
			// 获取并且移除第一个最低的元素
			Person pollFirst = tr.pollFirst();
			System.out.println("获取并且移除第一个最低的元素--------" + pollFirst.name + "--------" + pollFirst.age);

		}
		{
			// 获取并且移除最后一个最高的元素
			Person pollLast = tr.pollLast();
			System.out.println("获取并且移除最后一个最高的元素--------" + pollLast.name + "----" + pollLast.age);
		}
		
		{
			// 移除此set中的所有元素
			tr.clear();
		}

	}
}