【SQL 数据库索引优化之覆盖索引】原理深究剖析，拒绝假大空（VIP专属）-CFANZ编程社区

想要成为一名真正的高手，会写会读代码真的只是起步而已，能明白程序的底层运行逻辑，才是神中神。数据结构正是让我们进入代码逻辑世界的钥匙🔑~Let’s Go!

初始集合框架

集合框架的概念

Java 集合框架 Java Collection Framework，又被称为** 容器 container ** ，是定义在** java.util** 包下的一组接口 interfaces 和其实现类 classes 。

其主要表现为将多个元素 element 置于一个单元中，用于对这些元素进行快速、便捷的存储 store 、检索 retrieve 、管理 manipulate ，即平时我们俗称的增删查改 CRUD 。

例如，一副扑克牌(一组牌的集合)、一个邮箱(一组邮件的集合)、一个通讯录(一组姓名和电话的映射关系)等等。

下面展示的是最常用的接口和类的总览

背后涉及的数据结构以及算法

数据结构(Data Structure)是计算机存储、组织数据的方式，指相互之间存在一种或多种特定关系的数据元素的集合。我们提炼主谓宾（数据结构是方式、集合）

容器背后对应的数据结构

该阶段，我们主要学习以下容器，每个容器其实都是对某种特定数据结构的封装：

Collection：是一个接口，包含了大部分容器常用的一些方法
List：是一个接口，规范了ArrayList 和 LinkedList中要实现的方法
ArrayList：实现了List接口，底层为动态类型顺序表
LinkedList：实现了List接口，底层为双向链表
Stack：底层是栈，栈是一种特殊的顺序表
Queue：底层是队列，队列是一种特殊的顺序表
Deque：是一个接口
Set：集合，是一个接口，里面放置的是K模型
HashSet：底层为哈希桶，查询的时间复杂度为O(1)
TreeSet：底层为红黑树，查询的时间复杂度为O,关于key有序的
Map：映射，里面存储的是K-V模型的键值对
HashMap：底层为哈希桶，查询时间复杂度为O(1)
TreeMap：底层为红黑树，查询的时间复杂度为O ，关于key有序

什么是算法

算法(Algorithm):就是定义良好的计算过程，他取一个或一组的值为输入，并产生出一个或一组值作为输出。简单来说算法就是一系列的计算步骤，用来将输入数据转化成输出结果。

时间和空间复杂度

大家如果在学校里有数值计算或者数值分析这门课程，那对这个名词应当不陌生

如何衡量一个算法的好坏

** 算法效率分析分为两种：第一种是时间效率，第二种是空间效率** 。** 时间效率被称为时间复杂度，而空间效率被称作空间复杂度** 。 ** 时间复杂度主要衡量的是一个算法的运行速度，而空间复杂度主要衡量一个算法所需要的额外空间** ，计算机发展的早期，计算机的存储容量很小。所以对空间复杂度很是在乎。但是经过计算机行业的迅速发展，计算机的存储容量已经达到了很高的程度。_** 所以我们如今已经不需要再特别关注一个算法的空间复杂度。**_

时间复杂度

时间复杂度的定义：在计算机科学中，** 算法的时间复杂度是一个数学函数** ，它定量描述了该算法的运行时间。一个算法执行所耗费的时间，从理论上说，是不能算出来的，只有你把你的程序放在机器上跑起来，才能知道。但是我们需要每个算法都上机测试吗？是可以都上机测试，但是这很麻烦，所以才有了时间复杂度这个分析方式。一个算法所花费的时间与其中语句的执行次数成正比例，** 算法中的基本操作的执行次数，为算法的时间复杂度。**** （废话真多，直接看方法和例子！）**** 👇**** ↓**

大 O 的渐进表示方法

```java // 请计算一下func1基本操作执行了多少次？ void func1(int N){ int count = 0; for (int i = 0; i < N ; i++) { for (int j = 0; j < N ; j++) { count++; } } for (int k = 0; k < 2 * N ; k++) { count++; } int M = 10; while ((M--) > 0) { count++; } System.out.println(count); } ```

实际中我们计算时间复杂度时，我们其实并不一定要计算精确的执行次数，而只需要大概执行次数，那么这里我们使用大O的渐进表示法：

1、用常数1取代运行时间中的所有加法常数。

2、在修改后的运行次数函数中，只保留最高阶项。

3、如果最高阶项存在且不是1，则去除与这个项目相乘的常数。得到的结果就是大O阶。使用大O的渐进表示法以后，上述 Func1的时间复杂度为：

为了更快地熟悉定义，我们多举几个例子看看：

// 计算func2的时间复杂度？
void func2(int N) {
int count = 0;
for (int k = 0; k < 2 * N ; k++) {
    count++;
}
int M = 10;
while ((M--) > 0) {
    count++;
}
System.out.println(count);
}

// 计算func3的时间复杂度？
void func3(int N, int M) {
    int count = 0;
    for (int k = 0; k < M; k++) {
        count++;
    }
    for (int k = 0; k < N ; k++) {
        count++;
    }
    System.out.println(count);
}

// 计算func4的时间复杂度？
void func4(int N) {
int count = 0;
for (int k = 0; k < 100; k++) {
    count++;
}
System.out.println(count);
}

// 计算bubbleSort的时间复杂度？
void bubbleSort(int[] array) {
    for (int end = array.length; end > 0; end--) {
        boolean sorted = true;
        for (int i = 1; i < end; i++) {
            if (array[i - 1] > array[i]) {
                Swap(array, i - 1, i);
                sorted = false;
            }
        }
        if (sorted == true) {
            break;
        }
    }
}

// 计算binarySearch的时间复杂度？
int binarySearch(int[] array, int value) {
    int begin = 0;
    int end = array.length - 1;
    while (begin <= end) {
        int mid = begin + ((end-begin) / 2);
        if (array[mid] < value)
            begin = mid + 1;
        else if (array[mid] > value)
            end = mid - 1;
        else
            return mid;
    }
    return -1;
}

// 计算阶乘递归factorial的时间复杂度？
long factorial(int N) {
return N < 2 ? N : factorial(N-1) * N;
}

// 计算斐波那契递归fibonacci的时间复杂度？
int fibonacci(int N) {
return N < 2 ? N : fibonacci(N-1)+fibonacci(N-2);
}

【实例答案及分析】

实例1基本操作执行了2N+10次，通过推导大O阶方法知道，时间复杂度为 O(N)
实例2基本操作执行了M+N次，有两个未知数M和N，时间复杂度为 O(N+M)
实例3基本操作执行了100次，通过推导大O阶方法，时间复杂度为 O(1)
实例4基本操作执行最好N次，最坏执行了(N*(N-1))/2次，通过推导大O阶方法+时间复杂度一般看最坏，时间复杂度为 O(N^2)
实例5基本操作执行最好1次，最坏次，时间复杂度为 O( ) ps：在算法分析中表示是底数。
为2，对数为N，有些地方会写成lgN。（建议通过折纸查找的方式讲解logN是怎么计算出来的）(因为二分查
找每次排除掉一半的不适合值,一次二分剩下：n/2
两次二分剩下：n/2/2 = n/4)
实例6通过计算分析发现基本操作递归了N次，时间复杂度为O(N)。
实例7通过计算分析发现基本操作递归了次，时间复杂度为O( )。（建议画图递归栈帧的二叉树讲解）

空间复杂度

空间复杂度是对一个算法在运行过程中** 临时占用存储空间大小的量度 ** 。空间复杂度不是程序占用了多bytes的空间，因为这个也没太大意义，所以空间复杂度算的是变量的个数。空间复杂度计算规则基本跟时间复杂度类似，也使用** 大O渐进表示法** ，了解一下即可。

// 计算bubbleSort的空间复杂度？
void bubbleSort(int[] array) {
    for (int end = array.length; end > 0; end--) {
        boolean sorted = true;
        for (int i = 1; i < end; i++) {
            if (array[i - 1] > array[i]) {
                Swap(array, i - 1, i);
                sorted = false;
            }
        }
        if (sorted == true) {
            break;
        }
    }
}

// 计算fibonacci的空间复杂度？
int[] fibonacci(int n) {
long[] fibArray = new long[n + 1];
fibArray[0] = 0;
fibArray[1] = 1;
for (int i = 2; i <= n ; i++) {
    fibArray[i] = fibArray[i - 1] + fibArray [i - 2];
}
return fibArray;
}

// 计算阶乘递归Factorial的空间复杂度？
long factorial(int N) {
return N < 2 ? N : factorial(N-1)*N;
}

实例1使用了常数个额外空间，所以空间复杂度为 O(1)
实例2动态开辟了N个空间，空间复杂度为 O(N)
实例3递归调用了N次，开辟了N个栈帧，每个栈帧使用了常数个空间。空间复杂度为O(N)

初始泛型

包装类

在Java中，由于基本类型不是继承自Object，为了在泛型代码中可以支持基本类型，Java给每个基本类型都对应了一个包装类型。

引入包装类的目的主要是：希望我们的基本数据类型也能面向对象，也就是说类型之间的转换也是可以借助一些库方法来完成的，而要用某一个方法，至少要是一个类，所以有了类的plus版本就是包装类，每一个类型内部都有包含了所对应的方法，就是上表呈现的如此。

拆箱和装箱

有的地方又叫拆包和装包

int i = 10;
// 装箱操作，新建一个 Integer 类型对象，将 i 的值放入对象的某个属性中
Integer ii = Integer.valueOf(i);
Integer ij = new Integer(i);
// 拆箱操作，将 Integer 对象中的值取出，放到一个基本数据类型中
int j = ii.intValue();

int i = 10;
Integer ii = i; // 自动装箱
Integer ij = (Integer)i; // 自动装箱
int j = ii; // 自动拆箱
int k = (int)ii; // 自动拆箱

泛型的概念

通俗讲，泛型：** 就是适用于许多许多类型** 。从代码上讲，就是对类型实现了参数化。

思考一下：实现一个类，类中包含一个数组成员，使得数组中可以存放任何类型的数据，也可以根据成员方法返回数组中某个下标的值？

思路：

我们以前学过的数组，只能存放指定类型的元素，例如：int[] array = new int[10]; String[] strs = new String[10];
所有类的父类，默认为Object类。数组是否可以创建为Object?

class MyArray {
    public Object[] array = new Object[10];
    public Object getPos(int pos) {
        return this.array[pos];
    }
    public void setVal(int pos,Object val) {
        this.array[pos] = val;
    }
}
public class TestDemo {
    public static void main(String[] args) {
        MyArray myArray = new MyArray();
        myArray.setVal(0,10);
        myArray.setVal(1,"hello");//字符串也可以存放
        String ret = myArray.getPos(1);//编译报错
        System.out.println(ret);
    }
}

尝试过后我们发现：

任何类型数据都可以存放
1号下标本身就是字符串，但是确编译报错。必须进行强制类型转换——即将第 165 行代码修改为：

String ret = (String)myArrat.getPos(1);

虽然在这种情况下，当前数组任何数据都可以存放，但是，更多情况下，我们还是希望他只能够持有一种数据类型。而不是同时持有这么多类型。所以，泛型的主要目的：就是指定当前的容器，要持有什么类型的对象。让编译器去做检查。此时，就需要把类型，作为参数传递。需要什么类型，就传入什么类型。

泛型语法

```java class 泛型类名称<类型形参列表> { // 这里可以使用类型参数 } class ClassName

我们通过语法格式将上面的代码修改为：

class MyArray<T> {
    public T[] array = (T[])new Object[10];//1
    public T getPos(int pos) {
        return this.array[pos];
    }
    public void setVal(int pos,T val) {
        this.array[pos] = val;
    }
}
public class TestDemo {
    public static void main(String[] args) {
        MyArray<Integer> myArray = new MyArray<>();//2
        myArray.setVal(0,10);
        myArray.setVal(1,12);
        int ret = myArray.getPos(1);//3
        System.out.println(ret);
        myArray.setVal(2,"bit");//4
    }
}

类名后的代表占位符，表示当前类是一个泛型类了

注释1处，不能new泛型类型的数组

注释2处，类型后加入指定当前类型
注释3处，不需要进行强制类型转换
注释4处，代码编译报错，此时因为在注释2处指定类当前的类型，此时在注释4处，编译器会在存放元素的时候帮助我们进行类型检查。

泛型类的使用

泛型类 < 类型实参 > 变量名 ; // 定义一个泛型类引用

new 泛型类<类型实参>(构造方法实参); // 实例化一个泛型类对象

MyArray<Integer> list = new MyArray<Integer>();

注意：泛型只能接受类，所有的基本数据类型必须使用包装类！

泛型上界

```java class 泛型类名称<类型形参 extends 类型边界> { ... } ```

public class MyArray<E extends Number> {
...
}

MyArray<Integer> l1; // 正常，因为 Integer 是 Number 的子类型
MyArray<String> l2; // 编译错误，因为 String 不是 Number 的子类型

因为：只接受 Number 的子类型作为 E 的类型实参，自己创建的类与父类也遵循这个原则。

这里我们写一个实例：一个泛型类，求一个数组中的最大值:

class Alg<T>
public TfindMaxValue(T[] array){
    T max = array[0];
    for(int i=1;i<array.length;i++){
        if(max < array[i]){
            max = array[il;
            return max;
        }

这里第五行是会出错的，因为我们的 T 一定是引用数据类型，通过编译器的擦除机制变成了 Object 类型，而 Object 类型是没有办法比较大小的，所以我们对代码进行如下修改：

class Alg<T extends Comparable<T>>{

public TfindMaxValue(T[] array){
    T max = array[0];
    for(int i=1;i<array.length;i++){
        if(max.CompareTo(array[i] < 0){
            max = array[il;
            return max;
        }
    }

让我们的 T 继承 Comparable 这个类，在用其中的 CompareTo 方法进行我们的比较。

泛型方法

```java public class Util { //静态的泛型方法需要在static后用<>声明泛型类型参数 public static void swap(E[] array, int i, int j) { E t = array[i]; array[i] = array[j]; array[j] = t; } } ```