泛型、Set、二叉树

泛型：Java中如果在写代码的时候，不知道数据类是什么类型，那么就可以使用泛型。泛型其实就是任意的数据类型。

泛型可以使用在哪些地方？
    泛型类： 在类名后面<T>, 它表示在类中有一个不确定的数据类型。
    泛型方法： 在方法的返回值前面<T>，它表示在方法中有一个不确定的数据类型
    泛型接口：在接口名后面<T>，它表示在接口中有一个不确定的数据类型

泛型的好处：

1.把运行时期的问题转移到编译时期

2.避免了强制类型的转换

泛型类

         在类名后面<T>，它表示类中有一个不确定的数据类型

例：

//定义一个盒子，用来装东西(什么东西，不知道)
public class Box<T>{
    T t; //盒子里面装的是T类型的数据
    

    public void setT(T t){
        this.t=t;
    }
    
    public T getT(){
        return t;
    }
}

创建Box类的对象，创建对象的是同时确定泛型<T>的数据类型

public class Test1{
    public static void main(String[] args){
        //创建Box对象，同时确定泛型<T>为<String>类型
        Box<String> b=new Box<>(); 
        b.setT("黑马程序员");
        String s1=b.getT();
        System.out.println(s1); //黑马程序员
        
        //创建Box对象，同时确定泛型<T>为<Integer>类型
        Box<Integer> b=new Box<>();
        b.setT(100);
        Integer s2=b.getT();
        System.out.println(s2); //100
    }
}

泛型方法

在方法的返回值前面<T>，它表示在方法中有一个不确定的数据类型。当调用方法时确定泛型的数据类型 。

public static void main(String[] args){
    //确定addElement方法的<T>为<String>类型
    ArrayList<String> list1=new ArrayList<>();
    addElement(list1,"a","b","c");
    
    //确定addElement方法的<T>为<Integer>类型
    ArrayList<Integer> list2=new ArrayList<>();
    addElement(list2,1,2,3); 
}

//<T>表示一个在方法中不确定的数据类型
public static <T> void addElement(ArrayList<T> list, T t1, T t2, T t3){
    list.add(t1);
    list.add(t2);
    list.add(t3);
} 

泛型接口

在接口名后面<T>，它表示在接口中有一个不确定的数据类型

public interface Inter<T>{
    public void method(T t);
}

**接口上的泛型<T>可以在实现类中确定其数据类型



public class InterImpl implements Inter<String>{
    public void method(String t){
        System.out.println(t);
    }
}

**把接口上的泛型<T>沿用到实现类上，再创建对象的时候来确定其数据类型

public class InterImpl<T> implements Inter<T>{
    public void method(T t){
        System.out.println(t);
    }
}

public class Test3{
    public static void main(String[] args){
        InterImpl<String> impl=new InterImpl();
        impl.method("黑马程序员");
        
        InterImpl<Integer> impl=new InterImpl();
        impl.method(100);
    }
}

泛型的总结

1、类上的泛型<T>： 创建该类对象时，确定<T>的数据类型。

2.方法上的泛型<T>：调用方法的时候，确定<T>的数据类型。

3.接口上的泛型<T>：
    1)在实现类上确定<T>的数据类型
    2)把泛型<T>沿用到实现类上，在创建实现类对象来确定<T>的数据类型

泛型限定

?: 表示任意的类型
?  extends  Number: Number或者Number的子类
?  super  Number:  Number或者Number的父类

Set集合

Set集合的特点：没有索引，无序、元素不能重复
    --HashSet：元素是没有顺序
    --TreeSet：它可以对集合中的元素进行排序

TreeSet类有

TreeSet集合可以对元素进行排序。有两种排序方式。

自然排序：让元素的类实现Comparable接口，复写compareTo方法

public class Student implements Comparable<Student>{

  private String name;
    private int age;
    private int score;

    //省略构造方法，自己加上即可

    //实现Comparable接口重写方法来告诉TreeSet排序的规则
    @Override
    public int compareTo(Student o) {
        //先按照成绩排序，
        int num=this.score-o.score;
        //如果成绩相同，再按照年龄排序
        if(num==0){
            num=this.age-o.age;
        } 
        return num;
    }
}

• 比较器排序Comparator，让集合具备比较规则。

//创建TreeSet集合，同时指定排序规则 需要一个Comparator对象。
TreeSet<Teacher> ts=new TreeSet<>(new Comparator<Teacher>() {
    @Override
    public int compare(Teacher o1, Teacher o2) {
        //o1和o2 表示集合中已有的两个元素
        //按照年龄升序排列
        int num=o1.getAge()- o2.getAge();
        //如果年龄相同，就按照姓名进行比较
        if(num==0){
            num=o1.getName().compareTo(o2.getName());
            if(num==0){
                //...
            }
        }
        return num; 
    }
}); 
​
ts.add(new Teacher("zhagnasn",20));
ts.add(new Teacher("lisi",21));
ts.add(new Teacher("wangwu",22));
ts.add(new Teacher("aaaa",22));
ts.add(new Teacher("zhaoliu",24));
ts.add(new Teacher("zhaoliu",24));
​
for (Teacher t : ts) {
    System.out.println(t);
}

两种排序规则的对比

第一种(自然排序)：
    自定义的类实现Comparable接口，复写compreTo方法
    
第二种(比较器排序)
    在创建TreeSet集合时，把Comparator对象作为参数传递.
    复写Comparaotr接口的compare方法
    
如何选择呢？
    1.一般先推荐使用自然排序(Comparble接口)
    
    2.当自然排序不满足要求时，然后就可以使用比较器排序
        其实API中有一些类本身就已经实现了Comparble接口，给出了默认排序规则(不满足要求)
        比如:Integer，默认排序规则是(升序排列)
        比如:String，默认排序规则(字典顺序)

二叉树

二叉树： 每一个节点，它最多有两个子节点

二叉查找树(二叉排序树、二叉搜索树)：对于任意的一个节点，左边的子节点都比这个数小，右子节点都比这个数大。

二叉平衡树：每一个节点，左右两个子树的高度差不超过1
    
如果一个二叉树不平衡，如何达到平衡？
    左旋：如果右子树比左子树的高度差大于1，就需要左旋
    右旋：如果左子树比右子树的高度差大于1，就需要右旋
    
破坏平衡二叉树的几种情况，如何再次达到平衡
    左左：在左子树的左边添加元素，直接右旋即可
    左右：在左子树的右边添加元素，先左旋再右旋
    
    右右：在右子树的右边添加元素，直接左旋即可
    右左：在右子树的左边添加元素，先右旋再左旋