java中的TreeSet类的使用

import java.util.*;

public class TreeSetTest 
{

    public static void main(String[] args) 
    {

//一下是test1的测试
        TreeSet nums = new TreeSet();
        nums.add(1333);
        nums.add(3);
        nums.add(6);
        nums.add(34);
        nums.add(99);
        System.out.println(nums.first());
        System.out.println(nums.lower(4));
        System.out.println(nums);               //结果 [3, 6, 34, 99, 1333] TreeSet是按照数据的大小的排序的顺序，而不是按照插入的顺序 LinkedSet是按照插入的顺序排放并输出。。

//以下是test2的测试，用 class a来实现类比较
        TreeSet test = new TreeSet();

        test.add(new a(2));
        test.add(new a(2));             //两次添加相同的元素，因为重写了compare的方法和equals的方法，因此没有报错
        System.out.println(test);
/*
 * 自然排序的情况下，TeeeSet会调用集合元素的compare的比较的方法来比较元素的大小的关系，然后按照升序排序，
 * 因此，要求在添加到TreeSet的对象中必须是实现了Comparable接口中的*compare的方法，如果没有实现此方法，
 * 在对象第一次添加到TreeSet的时候不会给出报错，但是在第二次添加的时候，TreesSet将会试图比较两个对象的大小
 * 并给出排序，此时会产生错误。
 * 同时在添加到TreeSet中的两个对象要求是必须是同类型的，因为不是同类型的将不能进行比较大小，无法排序。
 * 在上面的程序中，由于修改了compare的函数，因此在添加的时候即使两个元素的值是相同也能添加进去。
 * */

//以下是test3的比较用class b来比较
        TreeSet test3 = new TreeSet();
        test3.add(new b(4));
        test3.add(new b(23));
        test3.add(new b(-99));
        System.out.println(test3);              //[count的数值为： -99, count的数值为： 4, count的数值为： 23]

        b first = (b)test3.first();
        first.count = 33;

        //输出的结果显示此时处于了无序的状态
        System.out.println(test3);              //[count的数值为： 33, count的数值为： 4, count的数值为： 23]

        System.out.println(test3.remove(new b(33)));            //false 不能删除修改过的对象
        System.out.println(test3.remove(new b(4)));             //true 但是可以删除未修改过的数据
        System.out.println(test3);                              //[count的数值为： 33, count的数值为： 23]
/*
 * 尽量不要修改HashSet和TreeSet中的数据，在修改之后破坏了数据的原本的排序，
 * 而且对象的处理非常复杂，容易出错，为了让程序更加健壮，不要随意的修改里面的对象
 * 
 */


//以下是test4的比较用class c来比较

//使用lambda表达式实现了Comparator接口中的 int compare()的方法，实现了逆序排序
        TreeSet test4 = new TreeSet( (o1,o2)->{
            c c1 = (c)o1;
            c c2 = (c)o2;
            return c1.count > c2.count ? -1 : c1.count <c2.count ? 1:0;
        });

        test4.add(new c(2));
        test4.add(new c(-1));
        test4.add(new c(13));

        //使用了定制方法，实现了逆序输出
        System.out.println(test4);          //结果 [count的数值为： 13, count的数值为： 2, count的数值为： -1]
/*
 * 如果要实现定制排序需要通过Comparator接口的帮助，通过compare的方法，在此方法中实现排序的逻辑设计
 * 当在添加c对象到集合中的时候，不再要求对象实现Comparable的接口，因此在lambda表达式中实现了对集合元素的排序
 * */   
    }
}


class a implements Comparable{
    int age;
    public a(int a)
    {
        this.age = a;
    }

    //重写了equals的比较的方法，无论传递的参数是多少，返回的都是true
    public boolean equals(Object obj)
    {
        return true;
    }

    //重写了compare的比较的方法，无论传递的参数是多少，返回的都是1
    public int compareTo(Object obj)
    {
        return 1;
    }
}

class b implements Comparable
{
    int count;
    public  b(int count)
    {
        this.count = count;
    }

    public String toString()
    {
        return "count的数值为： " + count;
    }

    //重写了equals的比较的方法，根据count的大小来返回true 或者 false
    public boolean equals(Object obj)
    {
        if (this == obj)
            return true;
        if (obj !=null && b.class == obj.getClass() )
        {
            b tempt = (b) obj;
            return this.count == tempt.count;
        }

        return false;
    }

    //重写了compareTo的比较的方法，根据count的大小来返回1 或者 0 或者-1
    public int compareTo(Object obj)
    {
        b tempt = (b)obj;
        return count > tempt.count ? 1 : count < tempt.count ? -1 : 0; 
    }
}

class c 
{
    int count;
    public  c(int count)
    {
        this.count = count;
    }

    public String toString()
    {
        return "count的数值为： " + count;
    }
}