Java基础——集合（泛型、数据结构（树）、TreeSet 集合）

一、泛型
        1.泛型介绍
                JDK5引入的, 可以在编译阶段约束操作的数据类型, 并进行检查
        2.泛型的好处 
                统一数据类型，将运行期的错误提升到编译期

        注：泛型中只能编写引用数据类型，泛型默认的类型是Object
        3.学习路线：
                 泛型类
                        在不清楚接收类型时进行定义泛型，让传入放自己确定类型
                        常见的泛型标识符 : E V K T
                                E : Element
                                T : Type
                                K : Key(键)
                                V : Value(值)
                        清楚不同的泛型, 在什么时机能确定到具体的类型
                        创建对象的时候实现

                       
                        class Student<E> {
                                private E e;
                                public E getE() {
                                        return e;
                                }
                                public void setE(E e) {
                                        this.e = e;
                                }
                        }
                 泛型方法
                        1. 非静态的方法 : 内部的泛型, 会根据类的泛型去匹配
                        2. 静态的方法 : 静态方法中如果加入了泛型, 必须声明出自己独立的泛型
                                                 在调用方法, 传入实际参数的时候, 确定到具体的类型
                        //静态遍历数组的方法
                        public static <T> void printArray(T[] arr) {
                                System.out.print("[");
                                        for (int i = 0; i < arr.length - 1; i++) {
                                                System.out.print(arr[i] + ", ");
                                        }
                                System.out.println(arr[arr.length - 1] + "]");
                        }
                        //主方法的调用
                        public static void main(String[] args) {
                                String[] arr1 = {"张三", "李四", "王五"};
                                Integer[] arr2 = {1, 2, 3};
                                Double[] arr3 = {1.1, 2.2, 3.3};
                                printArray(arr1);
                                printArray(arr2);
                                printArray(arr3);
                        }

                 泛型接口
                        类实现接口的时候，如果接口带有泛型，有两种操作方式：
                        interface Inter<E> {
                                void show(E e);
                        }
                        1.类实现接口的时候，直接确定类型
                        class InterAImpl implements Inter<String> {
                                @Override
                                public void show(String s) {}
                        }
                        2.延续接口的泛型，等创建对象的时候再确定
                        class InterBImpl<E> implements Inter<E>{
                                @Override
                                public void show(E e) {}
                        }
                 泛型通配符(泛型的限定)
                        ? : 任意类型
                        ? extends E : 可以传入的是E, 或者是E的子类
                                public static void method(ArrayList<? extends Employee> list){}
                        ? super E : 可以传入的是E, 或者是E的父类
                                public static void method(ArrayList<? super Employee> list){}
二、数据结构（树）
        1.平衡二叉树
                ① 规则：任意节点左右子树高度差不超过1
                ② 旋转机制：
                     左旋
                        
                        1.确定支点：从添加的节点开始，不断的往父节点找不平衡的节点
                        2.以不平衡的点作为支点
                        3.把支点左旋降级，变成左子节点
                        4.晋升原来的右子节点
                        
                        1.确定支点：从添加的节点开始，不断的往父节点找不平衡的节点
                        2.以不平衡的点作为支点
                        3.将根节点的右侧往左拉
                        4.原先的右子节点变成新的父节点，并把多余的左子节点出让，给已经降级的根节
                           点当右子节点 
                     右旋
                      右旋与左旋是类似的，只是旋转的方向相反
                 ③ 需要旋转的四种情况：
                        左左
                        当根节点左子树的左子树有节点插入，导致二叉树不平衡
                        需要进行一次右旋
                        左右
                        当根节点左子树的右子树有节点插入，导致二叉树不平衡
                        先局部左旋，再整体右旋
                        右右
                        当根节点右子树的右子树有节点插入，导致二叉树不平衡
                ​​​​​​​        ​​​​​​​​​​​​​​需要进行一次左旋​​​​​​​
​​​​​​​                        右左
                        当根节点右子树的左子树有节点插入，导致二叉树不平衡
                        先局部右旋，再整体左旋
        ​​​​​​​        ​​​​​​​   ④ 触发时机：当添加一个节点之后，该树不再是一颗平衡二叉树
        ​​​​​​​2.红黑树
                ① 红黑树是一种自平衡的二叉查找树，是计算机科学中用到的一种数据结构。
                ② 1972年出现，当时被称之为平衡二叉B树。后来，1978年被修改为如今的"红黑树"。
                ③ 它是一种特殊的二叉查找树，红黑树的每一个节点上都有存储位表示节点的颜色
                ④ 每一个节点可以是红或者黑；红黑树不是高度平衡的，它的平衡是通过"红黑规则"进
                    行实现的
        ​​​​​​​        ​​​​​​​红黑规则​​​​​​​：
                ① 每一个节点是红色的，或者是黑色的
        ​​​​​​​        ​​​​​​​② 根节点必须是黑色
        ​​​​​​​        ​​​​​​​③ 如果一个节点没有子节点或者父节点，则该节点相应的指针属性值为Nil，这些Nil视为
                     叶节点，每个叶节点(Nil)是黑色的
        ​​​​​​​        ​​​​​​​④ 如果某一个节点是红色，那么它的子节点必须是黑色(不能出现两个红色节点相连的情
                     况)​​​​​​​
        ​​​​​​​        ​​​​​​​⑤ 对每一个节点，从该节点到其所有后代叶节点的简单路径上，均包含相同数目的黑色
                     节点；
        ​​​​​​​

三、TreeSet 集合

 对集合中的元素进行排序操作  (底层红黑树实现)
一、自然排序
        Java已经写好类, 大多数都具有自然排序的规则, 这些规则放在源代码中, 我们无法修改     
​​​​​​​        (String, Integer, Double...)     
                String : 默认是字典顺序排序     
                Integer : 默认是升序排序     
                Double : 默认是升序排序     
        1）类实现 Comparable 接口
        2）重写 compareTo 方法
        3）根据方法的返回值, 来组织排序规则    
                负数 : 左边走    正数 : 右边走    0  : 不存（表示比较的结果是相同）
        例：（类中省略了构造器等方法）

                public class Student implements Comparable<Student>{
                        // this.xxx - o.xxx 正序
                        // o.xxx - this.xxx 降序
                        @Override
                        public int compareTo(Student o) {
                                // 根据年龄做主要排序条件
                                int ageResult = o.age - this.age;
                                // 根据姓名做次要排序条件
                                int nameResult = ageResult == 0 ? o.name.compareTo(this.name) :
                                ageResult;
                                // 判断姓名是否相同
                                int result = nameResult == 0 ? 1 : nameResult;
                                return result;
                        }
                        private String name;
                        private int age;
                }
二、比较器排序
TreeSet<Student> ts = new TreeSet<>(new Comparator<Student>() {
        @Override
        public int compare(Student o1, Student o2) {
                // o1.getAge() - o2.getAge() 正序
                //o2.getAge() - o1.getAge()降序
                int ageResult = o1.getAge() - o2.getAge();
                return ageResult == 0 ? o1.getName().compareTo(o2.getName()) : ageResult;
        }
});
 如果同具备自然排序, 和比较器排序, 会优先按照比较器进行排序操作
如果我们要实现的需求, 排序规则, 跟已经具备的自然排序, 不一样.     这时候就要使用比较器排序.