泛型

泛型介绍

JDK5引入的，可以在编译阶段约束操作的数据类型，并进行检查

第一个图不是泛型，第二个图是泛型

泛型的好处

1. 统一数据类型
2. 将运行期的错误，提升到了编译期

细节：如果没有指定泛型，默认的类型就是Object

泛型的常见标识符

E：Element元素

T：Type类型

K：Key键

V：Value值

泛型的学习路径

1. 泛型类

创建对象的时候，确定具体的数据类型

2. 泛型方法

1. 非静态方法中：是根据类的泛型进行匹配的
2. 静态方法中：必须声明出自己独立的泛型，不能沿用类的泛型，

• 在调用方法传入实际参数的时候，确定到具体的数据类型
• 静态方法代码实例：public static <T> void printArray(T[ ] arr)

public class Demo1 {
    public static void main(String[] args) {
        String[] names = {"张三", "李四", "王五"};
        Integer[] nums1 = {11, 22, 33};
        Double[] nums2 = {11.1, 22.2, 33.3};

        printArray(names);
        printArray(nums1);
        printArray(nums2);
    }

    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] + "]");
    }
}

3. 泛型接口

1. 实现类，实现接口的时候指定具体类型
2. 接口的泛型跟着类的泛型去匹配

interface Inter<V> {
    void show(V s);
}

// 实现类，实现接口的时候指定具体类型
class InterAImpl implements Inter<String> {

    @Override
    public void show(String s) {

    }
}

// 接口的泛型跟着类的泛型去匹配
class InterBImpl<V> implements Inter<V> {

    @Override
    public void show(V s) {

    }
}

4. 泛型通配符

？(通配符)：可以接受任意类型

5. 泛型限定

？extends E：可以传入的是E，或者是E的子类

？super E：可以传入的是E，或者是E的父类

public static void method(ArrayList<? extends Person> list) {
    for (Object o : list) {
        Person t = (Person) o;
        t.show();
    }
}

注意事项：泛型中，只能编写引用数据类型

数据结构(树)

数据结构(二叉查找树)

数据结构(二叉查找树)添加节点

数据结构(平衡二叉树)

数据结构(平衡二叉树)旋转机制

数据结构(平衡二叉树)左旋

数据结构(平衡二叉树)右旋

红黑树

• 红黑树是一种自平衡的二叉查找树，是计算机科学中用到的一种数据结构。
• 它是一种特殊的二叉查找树红黑树的每一个节点上都有存储位表示节点的颜色
• 每一个节点 可以 是红或者黑；红黑树 不是高度平衡 的，它的 平衡是 通过 “红黑规则” 进行实现的

红黑规则

• 每一个节点是红色的，或者是黑色的
• 根节点必须是黑色
• 如果一个节点没有子节点或者父节点，则该节点相应的指针属性值为Nil,这些Nil视为叶节点，每个叶节点(Nil)是黑色的
• 如果某一个节点是红色，那么它的子节点必须是黑色（不能出现两个红色节点相连的情况）
• 对每一个节点，从该节点到其所有后代叶节点的简单路径上，均包含相同数目的黑色节点；

红黑树添加节点的规则

TreeSet集合

public class Demo1 {
    public static void main(String[] args) {
        System.out.print("请输入:");
        String infor = new Scanner(System.in).nextLine();
        TreeSet<Character> ts = new TreeSet<>();
        char[] charArray = infor.toCharArray();
        for (char c : charArray) {
            ts.add(c);
        }
        System.out.println(ts);
    }
}
    //产生10个1~100随机数,要求数据不重复
    public class TreeSetDemo2 {
        public static void main(String[] args) {
        Random r = new Random();
        TreeSet<Integer> ts = new TreeSet<>();
        while (ts.size() != 10){
        ts.add(r.nextInt(100 ) + 1);
        }
        System.out.println(ts);
    }
}

Set接口

特点:

• 保证集合的元素唯一，并且可以排序操作

TreeSet排序1：自然排序

重写compareTo方法:

• 返回0 : 数据相同，不存
• 返回正数：右边走
• 返回负数：左边走
• 数据的取出顺序:
• 左—->中—–>右

使用自定义类如何使用TreeSet集合排序?

自定义类必须实现 Comparable<T> 接口，并且重写compareTo方法，才能使用TreeSet集合

public class Student implements Comparable<Student> {
    private String name;
    private int age;
        
    public int compareTo(Student o) {
    //谁调方法this代表谁,o代表的是与之比较的元素
    //this - o   升序
    //o - this   降序
    
    //针对年龄进行主要排序(升序)
    int ageResult = this.age - o.age;
    //针对姓名进行次要排序(升序)
    int nameResult = ageResult == 0 ? this.name.compareTo(o.name) : ageResult;
    //针对同名同年龄保留数据
    int result = nameResult == 0 ? 1 : nameResult;
    //返回值
    return result;
	}
}

排序方式:2 比较器排序

• Java中很多的类，都具备了自然排序（实现了Comparable接口）

• 在源码中，已经指定了排序规则
• 但有时候默认的排序规则，不满足我们的需求

• 如果同时指定了自然排序和比较器排序，会优先按照比较器排序进行操作
• 解决方案：
• 使用比较器排序

• 在TreeSet集合的构造方法中，传入Comparator接口的实现类对象
• 重写compare方法
• 根据方法的返回值，来组织排序规则.

public static void main(String[]args){
    TreeSet<Integer>ts new TreeSet<>((01,02)->02-01);
    ts.add(10);
    ts.add(20);
    ts.add(50);
    ts.add(40);
    ts.add(30);
    System.out.println(ts);
}

TreeSet集合小案例

package com.itheima.study.treeset;

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

public class CharStringSort {
    public static void main(String[] args) {
    TreeSet<String> ts = new TreeSet<>(new Comparator<String>() {
        @Override
        public int compare(String o1, String o2) {
        //比较长度,降序排序
                  int lengthResult = o2.length() - o1.length() ;
        //长度相同时,按照字典比较内容
        int contResult = lengthResult ==0 ? o2.compareTo(o1): lengthResult;
        //内容相同仍然保留
        int result = contResult == 0 ? 1 : contResult;
        return result;
        }
    });
        ts.add("def");
        ts.add("abc");
        ts.add("a");
        ts.add("dddddddddd");
        ts.add("abc");
        System.out.println(ts);
	}
}