ACAC TreeSet（）

package TreeSetTest;

import java.util.TreeMap;
import java.util.TreeSet;

/*
* 1、TreeSet集合底层实际上是一个TreeMap
* 2、TreeMap集合底层是一个二叉树
* 3、放到TreeSet集合中的元素，等同于放到TreeMap集合key部分
* 4、TreeSet集合中的元素：无序不可重复，但是可以按照元素的大小顺序自动排序
*       称为：可排序集合*/
public class Note01 {
    
    
    public static void main(String[] args) {
    
    


        TreeSet<String> ss = new TreeSet<>();
        ss.add("miao");
        ss.add("liu");
        ss.add("lu");
        ss.add("yu");
        ss.add("long");
        ss.add("he");

        //遍历，按照字典顺序进行排序，升序
        for(String data : ss){
    
    
            System.out.println(data + " ");
        }

        TreeSet<Integer>  aa = new TreeSet<>();
        aa.add(122);
        aa.add(23);
        aa.add(45);
        for(Integer i : aa){
    
    
            System.out.print(i + " ");
        }

    }
}

package TreeSetTest;

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

/*
* TreeSet集合存储元素特点：
*       1、无序不可重复，但存储的元素可以自动按照从小到大顺序排序
*
*       2、这里的无序指的是存进去的顺序和取出的顺序不同，并且没有下标
*      (如果有了下标，那一定是有序的，因为你存进去，和取出来的顺序一样）
*
* */
public class Test01 {
    
    
    public static void main(String[] args) {
    
    

        Set<Integer> it = new TreeSet<>();

        it.add(34);
        it.add(34);
        it.add(33);
        it.add(32);
        it.add(31);
        it.add(30);
        it.add(29);
        it.add(30);
        it.add(29);

        for(int data : it){
    
    
            System.out.println(data);
        }

        Set<String> bb = new TreeSet<>();
        bb.add("B");
        bb.add("A");
        bb.add("D");
        bb.add("c");
        bb.add("D");
        bb.add("F");

        for(String data : bb){
    
    
            System.out.println(data);
        }

       /*
       这里c最大
        A
        B
        D
        F
        c
        */



    }
}

package TreeSetTest;

import java.util.TreeSet;

/*
* 对自定义的类型来说，TreeSet可以排序吗？？
*   以下程序中对于Person类来说，无法排序，因为没有指定对象之间的比较规则
*   谁大谁小没有说明
*
*   java.lang.ClassCastException: class TreeSetTest.Person
*   cannot be cast to class java.lang.Comparable
*
*   出现这个异常的原因：
*       Person类没有实现java.lang.Comparable接口
*
*   而上个程序中Integer，String可以进行比较的原因是：时间了Comparable接口
*
*       public final class String
*            implements java.io.Serializable, Comparable<String>, CharSequence,
*            Constable, ConstantDesc {
*
*       public final class Integer extends Number
*                implements Comparable<Integer>, Constable, ConstantDesc {
*
*   实现comparable接口：
*
*    */
public class Test02 {
    public static void main(String[] args) {

        TreeSet<Person> p = new TreeSet<>();

        Person p1 = new Person(12);
        Person p2 = new Person(16);
        Person p3 = new Person(17);

        p.add(p1);
        p.add(p2);
        p.add(p3);
        for(Person data : p){
            System.out.println(data);
        }

    }
}

/**
 * 放在TreeSet集合中的元素需要实现java.util.Comparable接口
 * 并且实现CompareTo方法，equals可以不写
 */
class  Person implements  Comparable<Person>{

    public int age;

    public Person(int age) {
        this.age = age;
    }

    @Override
    public int compareTo(Person o) {

       /* int age01 = this.age;
        int age02 = this.age;
        if(age01 > age02){
            return 1;
        }else if(age01 < age02){
            return -1;
        }else{
            return 0;
        }*/
        //太复杂了，简化点

        return this.age - o.age;
        //大于的话返回整数，等于的话返回0，小于的话返回负数

    }

    @Override
    public String toString() {
        return "age=" + age;
    }
}

package TreeSetTest;

import java.util.TreeSet;

/*
* 年龄相同，按照姓名排序
* */
public class Test03 {
    
    
    public static void main(String[] args) {
    
    

        Vip aa = new Vip(12,"mimm");
        Vip bb = new Vip(13,"afgf");
        Vip cc = new Vip(12,"agsd");
        Vip dd = new Vip(14,"fgs");
        Vip ss = new Vip(13,"rtjy");

        TreeSet<Vip>  v = new TreeSet<>();
        v.add(aa);
        v.add(bb);
        v.add(cc);
        v.add(dd);
        v.add(ss);

        for(Vip d : v){
    
    
            System.out.println(d);
        }
    }
}
class Vip implements Comparable<Vip>{
    
    

    public int age;
    public String name;

    public Vip(int age, String name) {
    
    
        this.age = age;
        this.name = name;
    }

    @Override
    public String toString() {
    
    
        return "Vip:" +
                "age=" + age +
                ", name : " + name;
    }


    /*
    * compareto方法的返回值很重要：
    *   返回0表示相同，value会覆盖
    *   >0，会继续在右子树上找    10 - 9 = 1 >0 说明左边这个值较大，会往右子树上找
    *   <0,        左
    *   do {
    *           parent = t;
    *           cmp = k.compareTo(t.key);
    *           if (cmp < 0)
    *               t = t.left;
    *           else if (cmp > 0)
    *               t = t.right;
    *           else
    *               return t.value;
    *        } while (t != null);
    * */
    @Override
    public int compareTo(Vip o) {
    
    
       if(this.age == o.age){
    
    
           return this.name.compareTo(o.name);
       }else{
    
    
           return this.age - o.age;
       }
    }
}

package TreeSetTest;

import java.util.Comparator;
import java.util.TreeSet;
/**
*
* TreeSet集合中元素可排序的第二种方式，使用比较器
*       其实就是实现Comparator接口中的compare方法
*      （第一种是实现Comparable接口中的compareTo方法）
*
* 总结：放到TreeSet集合或者TreeMap集合key部分的元素要想做到排序，包括两种方式：
 *      1、放在集合中的元素实现java.lang.Comparable接口（实现里面的compareTo方法）
 *      2、在构造TreeSet或TreeMap集合的时候给他一个比较器对象。
 *
 * 怎样选择呢？
 *      当比较规则不会发生改变的时候，或者说当比较规则只有1个的时候，建议使用Comparable接口
 *
 *      当比较规则有多个，并且需要多个比较规则之间频繁切换，建议使用Comparator接口
 *      （有多个，当要用哪个的时候，直接切换接口就行了，这里没有内部类的事情）
 *
 *      Comparator接口的设计符合OCP原则
*
*/
public class Test04 {

    public static void main(String[] args) {


        //TreeSet<WangZhe> yingXiong = new TreeSet<>();不行，没有通过构造方法传递一个比较器进去

        /**注意：这里要new一个比较器对象，给构造方法传递一个比较器
         *
         * TreeMap源码里的有参构造方法
         * public TreeSet(Comparator<? super E> comparator) {
         *         this(new TreeMap<>(comparator));
         *     }
         */

        //TreeSet<WangZhe> yingXiong = new TreeSet<>(new WangZheComparator());

        //也可以不用写类，直接new一个接口，加一个内部类，直接生成后，修改写里面的规则也可以
        //匿名内部类用在这里还是比较方便的，不用再写一个类

        TreeSet<WangZhe> yingXiong = new TreeSet<>(new Comparator<WangZhe>() {
            @Override
            public int compare(WangZhe o1, WangZhe o2) {
                return o1.prize - o2.prize;
            }
        });


        //没必要这样写
        WangZhe houZi = new WangZhe(18888);
        yingXiong.add(houZi);

        yingXiong.add(new WangZhe(3000));
        yingXiong.add(new WangZhe(13888));
        yingXiong.add(new WangZhe(8888));

        for(WangZhe data: yingXiong ){
            System.out.println(data);
        }



    }
}
class WangZhe{

    public int prize;

    public WangZhe(int prize) {
        this.prize = prize;
    }

    public WangZhe() {
    }

    @Override
    public String toString() {
        return "英雄价格 ：" + prize;
    }

}
/**
 * 单独写一个比较器
 * 比较器实现的是java.util.Comparator接口（Comparable是java.lang包下的，Comparator是java.util包下的）
 * 执行的是TreeMap的put方法里的if（Test03里的是执行的else里的Comparable）
 *    Comparator<? super K> cpr = comparator;
 *         if (cpr != null) {
 *             do {
 *                 parent = t;
 *                 cmp = cpr.compare(key, t.key);
 *                 if (cmp < 0)
 *                     t = t.left;
 *                 else if (cmp > 0)
 *                     t = t.right;
 *                 else
 *                     return t.value;
 *             } while (t != null);
 *         }
 */
/*

class WangZheComparator implements Comparator<WangZhe>{

    @Override
    public int compare(WangZhe o1, WangZhe o2) {
        //指定比较规则
        //按照价格排序
        return o1.prize - o2.prize;
    }
}
*/