通配符下限 TreeSet泛型类 Comparator接口

通配符下限 函数类型与类型接收类型设置下限 添加元素
TreeSet泛型类
Comparator接口 实现 比较器 传入 TreeSet实例化

animals

package typeWildcardBottom;

/*
what:
    父类 是一个类型！！！
how use:
    设置name 用animals name排序
 */

public class Animals {
    String name;

    @Override
    public String toString() {
        return "Animals{" +
                "name='" + name + '\'' +
                '}';
    }

    public Animals(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

cats

package typeWildcardBottom;

/*
what:
    继承于animals 那么 animals 有的变量 函数 他都有 除了构造函数
    所以他有name  及name get set toString
 */
public class Cats extends Animals {
    int age;

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

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

minCats:

package typeWildcardBottom;



/*
what:
    继承于Cats 那么 Cats 有的变量 函数 他都有 除了构造函数
    所以他有name  及name get set toString、   age  age get set toString
 */
public class minCats extends Cats {
    int level;

    @Override
    public String toString() {
        return "minCats{" +
                "level=" + level +
                '}';
    }

    public minCats(String name, int age, int level) {
        super(name, age);
        this.level = level;
    }

    public int getLevel() {
        return level;
    }

    public void setLevel(int level) {
        this.level = level;
    }
}

package typeWildcardBottom;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.TreeSet;

public class typeWildcardBottomTest {

    public static void main(String[] args) {
//        test1();
        test2();
    }

    /*
    what:
        生成 animals cats mincats列表
        测试showList 在接收ArrayList ArrayList接收类型下限设置为Cats情况 分别接收animals cats mincats列表情况
     */
    public static void test1(){

        ArrayList<Animals> animals = new ArrayList<>();
        ArrayList<Cats> cats = new ArrayList<>();
        ArrayList<minCats> minCats = new ArrayList<>();

        showList(animals);
        showList(cats);

        //设置类型接收下限 所以minCats无法接收
//        showList(minCats);
    }

    /*
    what；
        接收列表   设置列表接收类型下限
     */
    public static void showList(ArrayList<? super Cats> list){
//为 cats mincats 添加构造函数后 必须添加变量  所以屏蔽了
        //        list.add(new Cats());
//        list.add(new minCats());

        for(int i = 0;i<list.size();i++){
            System.out.println(list.get(i));
        }
    }

    /*
    what:
        TreeSet 创建对象 设置比较器  给对象排序
        TreeSet:
            what:
                红黑树 平衡二叉树 logn排序
            how use:
                创建对象 传入类型参数
     */
    public static void test2(){
        /*
        what；
            treeSet 使用 父类比较 因为子类初始化 父类信息一定初始化
         */
        TreeSet<Cats> treeSet = new TreeSet<>(new comparator2());
        treeSet.add(new Cats("jim2",12));
        treeSet.add(new Cats("jim1",15));
        treeSet.add(new Cats("jim",17));


        /*
        what:
            去除treeSet元素
         */
        for(Cats cat:treeSet){
            System.out.println(cat.getName() + " " + cat.getAge());
        }
    }

    /*
    what；
        1.比较器类  只是个实现类  不用当作方法使用
        2.使用compare返回bool 比较
        3.设置比较器比较类型为Animals
     */


    static class comparator1 implements Comparator<Animals>{

        @Override
        public int compare(Animals o1, Animals o2) {
            return o1.getName().compareTo(o2.getName());
        }
    }

    /*
    what；
        比较器实现 comparator接口 设置接口类型  比较Cats类型
     */
   static  class comparator2 implements Comparator<Cats>{

        @Override
        public int compare(Cats o1, Cats o2) {
            return o1.getAge() - o2.getAge();
        }
    }
    /*
    what：
        比较器实现 comparator接口 设置接口类型  比较mincats类型
     */
    static class comparator3 implements Comparator<minCats>{

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