柚子班第四期学习总结

spring、spring boot、spring cloud

spring

spring 是一个针对 java 语言的基础架构支持的框架
常见的模块有：Spring JDBC、Spring MVC、Spring Security、Spring AOP、Spring ORM、Spring Test
通过 spring 的组件我们可以通过配置的方式快速的支持业务
Spring 通过 IOC 和 AOP 提供了低耦合、轻量级、高扩展、复用性强等能力
IOC
- 控制反转是依赖倒置原则的一种代码设计思路，就是把原先在代码里面需要实现的对象创建、对象之间的依赖，反转给容器来帮忙实现。
Spring IOC 容器通过 xml，注解等其他方式配置类与类之间的依赖关系，完成了对象的创建和依赖的管理注入，IOC 的主要设计模式是工厂模式
使用 IOC 可以实现累的快速配置以及便捷管理，降低了类与类之间的耦合度
AOP
AOP 的主要设计模式是动态代理，是面向切面编程的一种模式，切面实现了横切关注点的模块化，即将应用对象之间的横切点抽象为单独的模块
- AOP 中的五种通知类型如下所示
通过 XML 配置文件声明切面

spring boot

spring boot 是 spring 框架的扩展，去除了 spring 应用程序所需的 xml 配置
框架相关优点
内嵌 Tomcat、Jetty、UnderTow，而且不需要部署
提供了 stater 包简化了 maven 配置
尽可能全面的自动配置了相关 spring 配置

spring cloud

spring cloud 是微服务架构的一种解决方案。集合了多个 spring 的优秀框架，提供了全套的分布式解决方案。
在这里插入图片描述

mybatis-plus

mybatis-plus 在 mybatis 的基础上进行了强化。
优点：
支持主键自动生成
内置分页插件
内置全局拦截组件

几种常见的排序算法

手写排序算法写到爆炸，三道只写对了一道，几年没打过比赛了，常用算法的基本功还是有些问题的

冒泡排序
是排序算法中相对简单的算法、它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。
这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。
稳定性
冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。所以，如果两个元素相等，是不会再交换的；如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。
时间复杂度
冒泡排序总的平均时间复杂度为O(n^2)
空间复杂度
冒泡排序的空间复杂度为T(n)
代码实现

public class MaoSort {

    public static void sort(int arr[]) {
        for (int i = 0; i < arr.length - 1; i++) {
            boolean flag = false;
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    flag = true;
                }
            }
            if (flag == false) {
                break;
            }
        }
    }

    public static void main(String[] args) {
        int[] test = {237,24,256,248,-1,0};
        sort(test);
        for (int i : test) {
            System.out.println(i);
        }
    }
}

插入排序
插入排序是一种简单的排序算法，它的思想是将一个记录插入到已经排好序的有序表中，从而形成一个新的有序表，其实现过程中使用双层循环，外层循环对除了第一个元素之外的所有元素进行遍历，内层循环对当前元素前面的有序表进行插入位置寻找，并进行移动操作
时间复杂度
插入排序的平均时间复杂度是 O(n^2)
空间复杂度
插入排序的空间复杂度是T(n)
代码实现

public class InsertSort {

    public static void doInsertSort(int[] array) {
        for (int index = 1; index < array.length; index++) {//外层向右的index，即作为比较对象的数据的index
            int temp = array[index];//用作比较的数据
            int leftindex = index - 1;
            while (leftindex >= 0 && array[leftindex] > temp) {//当比到最左边或者遇到比temp小的数据时，结束循环
                array[leftindex + 1] = array[leftindex];
                leftindex--;
            }
            array[leftindex + 1] = temp;//把temp放到空位上
        }
    }

    public static void main(String[] args) {
        int[] array = {38,65,97,76,13,27,49};
        doInsertSort(array);
        for (int i : array) {
            System.out.println(i);
        }
    }
}

快速排序
快速排序使用分治策略将一个数组分为两个子数组进行处理。
排序步骤拆解
从数列中挑取一个元素作为基准值
对数列进行重新排序，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆放在基准的后面，处理完之后该基准就处于数列的中间位置
递归地将小于基准值元素的子数列和大于基准值元素的子数列排序
时间复杂度
O(nlogn)
空间复杂度
T(n)

代码实现

public class QuickSort {

    public static void sort(int[] a, int low, int height) {
        int i = low;
        int j = height;
        if (i > j) {//放在k之前，防止下标越界
            return;
        }
        int k = a[i];

        while (i < j) {
            while (i < j && a[j] > k) { //找出小的数
                j--;
            }
            while (i < j && a[i] <= k) { //找出大的数
                i++;
            }
            if (i < j) {//交换
                int swap = a[i];
                a[i] = a[j];
                a[j] = swap;
            }

        }
        //交换K
        k = a[i];
        a[i] = a[low];
        a[low] = k;

        //对左边进行排序,递归算法
        sort(a, low, i - 1);
        //对右边进行排序
        sort(a, i + 1, height);
    }


    public static void main(String[] args) {
        int[] arr = {5, 9, 7, 4, 5, 7, 6, 1, 9, 9, 7, 4};
        sort(arr, 0, arr.length - 1);
        System.out.println(Arrays.toString(arr));
    }

}