十二、常见算法和Lambda

---

一、常见算法

1.1 查找算法

1. 基本查找 *

​ 也叫做顺序查找

​ 说明：顺序查找适合于存储结构为数组或者链表。

基本思想：顺序查找也称为线形查找，属于无序查找算法。从数据结构线的一端开始，顺序扫描，依次将遍历到的结点与要查找的值相比较，若相等则表示查找成功；若遍历结束仍没有找到相同的，表示查找失败。

 public static void main(String[] args) {
        /*基本查找/顺序查找

       核心：
            从0索引开始挨个往后查找

        * 需求：
        *       定义一个方法利用基本查找，查询某个元素是否存在
        * 数据如下：{131, 127, 147, 81, 103, 23, 7, 79}*/
        int[] arr = {131, 127, 147, 81, 103, 23, 7, 79};
        boolean flag1 = basicSearch(arr, 23);
        System.out.println(flag1);
    }

    private static boolean basicSearch(int[] arr, int num) {
        //利用基本查找来查找num在数组中是否存在
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == num){
                return true;
            }
        }
        return false;
    }

---

课堂练习

public static void main(String[] args) {
        /*课堂练习1：
         * 需求：定义一个方法利用基本查找，查询某个元素在数组中的索引
         * 要求：不需要考虑数组中元素是否重复*/
        int[] arr = {131, 127, 147, 81, 103, 23, 7, 79};
        int i = basicSearchTest1(arr, 79);
        System.out.println(i);

        /*课堂练习2：
         * 需求：定义一个方法利用基本查找，查询某个元素在数组中的索引
         * 要求：需要考虑数组中元素有重复的可能*/
        int[] arr2 = {131, 127, 131, 81, 7, 23, 7, 79};
        ArrayList<Integer> list = basicSearchTest2(arr2, 7);
        System.out.println(list); // [4, 6]

    }

    //课堂练习2：
    private static ArrayList<Integer> basicSearchTest2(int[] arr, int num){
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 0; i < arr.length; i++) {
            if (arr[i]==num){
                list.add(i);
            }
        }
        return list;
    }

    //课堂练习1：
    private static int basicSearchTest1(int[] arr, int num) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == num) {
                return i;
            }
        }
        return -1;
    }

---

2.二分查找/折半查找*

前提条件：数组中的数据必须是有序的，从小到大，或者从大到小都是可以的。
    如果是无序的，也可以先进行排序。但是排序之后，会改变原有数据的顺序，查找出来元素位置跟原来的元素可能是不一样的，所以排序之后再查找只能判断当前数据是否在容器当中，返回的索引无实际的意义。
基本思想：也称为是折半查找，属于有序查找算法。用给定值先与中间结点比较。比较完之后有三种情况：

• 相等

  • 说明找到了

• 要查找的数据比中间节点小

  • 说明要查找的数字在中间节点左边

• 要查找的数据比中间节点大

  • 说明要查找的数字在中间节点右边

public static void main(String[] args) {
        /*二分查找/折半查找
         * 核心：
         * 每次排除一半的查找范围
         *
         * 需求：定义一个方法利用二分查找，查询某个元素在数组中的索引
         * 数据：{7,23,79,81,103,127,131,147}*/
        int[] arr = {7,23,79,81,103,127,131,147};
        int i = binarySearch(arr, 53);
        System.out.println(i);
    }

    private static int binarySearch(int[] arr, int num) {
        //0.定义两个变量记录要查找的范围
        int min = 0;
        int max = arr.length - 1;

        //1.利用循环不断地去找要查找的范围
        while (true) {
            if (min > max) return -1;

            //2.找到min和max的中间位置
            int mid = (min + max) / 2;

            //3.拿着mid指向的元素跟要查找的元素进行比较
            if (num < arr[mid]) {
                //3.1 num在mid的左边
                //min不变，max=mid-1
                max = mid - 1;
            } else if (num > arr[mid]) {
                //3.2 num在mid的右边
                //max不变，min=mid+1
                min = mid + 1;
            }else {
                //3.3num跟mid指向的元素一样
                //找到了
                return mid;
            }
        }
    }

---

3.插值查找*

在介绍插值查找之前，先考虑一个问题：

​ 为什么二分查找算法一定要是折半，而不是折四分之一或者折更多呢？

其实就是因为方便，简单，但是如果我能在二分查找的基础上，让中间的mid点，尽可能靠近想要查找的元素，那不就能提高查找的效率了吗？

二分查找中查找点计算如下：

mid=(low+high)/2, 即mid=low+1/2*(high-low);

我们可以将查找的点改进为如下：

mid=low+(key-a[low])/(a[high]-a[low])*(high-low)，

这样，让mid值的变化更靠近关键字key，这样也就间接地减少了比较次数。

基本思想：基于二分查找算法，将查找点的选择改进为自适应选择，可以提高查找效率。当然，差值查找也属于有序查找。

细节： 对于表长较大，而关键字分布又比较均匀的查找表来说，插值查找算法的平均性能比折半查找要好的多。反之，数组中如果分布非常不均匀，那么插值查找未必是很合适的选择。

代码跟二分查找类似，只要修改一下mid的计算方式即可。

---

4.斐波那契查找

在介绍斐波那契查找算法之前，我们先介绍一下很它紧密相连并且大家都熟知的一个概念——黄金分割。

黄金比例又称黄金分割，是指事物各部分间一定的数学比例关系，即将整体一分为二，较大部分与较小部分之比等于整体与较大部分之比，其比值约为1:0.618或1.618:1。

0.618被公认为最具有审美意义的比例数字，这个数值的作用不仅仅体现在诸如绘画、雕塑、音乐、建筑等艺术领域，而且在管理、工程设计等方面也有着不可忽视的作用。因此被称为黄金分割。

在数学中有一个非常有名的数学规律：斐波那契数列：1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89…….

（从第三个数开始，后边每一个数都是前两个数的和）。

然后我们会发现，随着斐波那契数列的递增，前后两个数的比值会越来越接近0.618，利用这个特性，我们就可以将黄金比例运用到查找技术中。

基本思想：也是二分查找的一种提升算法，通过运用黄金比例的概念在数列中选择查找点进行查找，提高查找效率。同样地，斐波那契查找也属于一种有序查找算法。

斐波那契查找也是在二分查找的基础上进行了优化，优化中间点mid的计算方式即可

public class FeiBoSearchDemo {
    public static int maxSize = 20;

    public static void main(String[] args) {
        int[] arr = {1, 8, 10, 89, 1000, 1234};
        System.out.println(search(arr, 1234));
    }

    public static int[] getFeiBo() {
        int[] arr = new int[maxSize];
        arr[0] = 1;
        arr[1] = 1;
        for (int i = 2; i < maxSize; i++) {
            arr[i] = arr[i - 1] + arr[i - 2];
        }
        return arr;
    }

    public static int search(int[] arr, int key) {
        int low = 0;
        int high = arr.length - 1;
        //表示斐波那契数分割数的下标值
        int index = 0;
        int mid = 0;
        //调用斐波那契数列
        int[] f = getFeiBo();
        //获取斐波那契分割数值的下标
        while (high > (f[index] - 1)) {
            index++;
        }
        //因为f[k]值可能大于a的长度，因此需要使用Arrays工具类，构造一个新法数组，并指向temp[],不足的部分会使用0补齐
        int[] temp = Arrays.copyOf(arr, f[index]);
        //实际需要使用arr数组的最后一个数来填充不足的部分
        for (int i = high + 1; i < temp.length; i++) {
            temp[i] = arr[high];
        }
        //使用while循环处理，找到key值
        while (low <= high) {
            mid = low + f[index - 1] - 1;
            if (key < temp[mid]) {//向数组的前面部分进行查找
                high = mid - 1;
                /*
                  对k--进行理解
                  1.全部元素=前面的元素+后面的元素
                  2.f[k]=k[k-1]+f[k-2]
                  因为前面有k-1个元素没所以可以继续分为f[k-1]=f[k-2]+f[k-3]
                  即在f[k-1]的前面继续查找k--
                  即下次循环,mid=f[k-1-1]-1
                 */
                index--;
            } else if (key > temp[mid]) {//向数组的后面的部分进行查找
                low = mid + 1;
                index -= 2;
            } else {//找到了
                //需要确定返回的是哪个下标
                if (mid <= high) {
                    return mid;
                } else {
                    return high;
                }
            }
        }
        return -1;
    }
}

阶段总结

5.分块查找*

当数据表中的数据元素很多时，可以采用分块查找。

汲取了顺序查找和折半查找各自的优点，既有动态结构，又适于快速查找

分块查找适用于数据较多，但是数据不会发生变化的情况，如果需要一边添加一边查找，建议使用哈希查找

分块查找的过程：

• 1. 需要把数据分成N多小块，块与块之间不能有数据重复的交集。
• 2. 给每一块创建对象单独存储到数组当中
• 3. 查找数据的时候，先在数组查，当前数据属于哪一块
• 4. 再到这一块中顺序查找

package Search;

public class A03_BlockSearchDemo1 {
    public static void main(String[] args) {
        /*分块查找
         * 核心思想：
         *   块内无序，块间有序
         * 实现步骤：
         *   0.创建数组blockArr存放每一个块对象的信息
         *   1.先查找blockArr确定要查找的数据属于哪一块
         *   2.再单独遍历这一块数据即可*/
        int[] arr = {16, 5, 9, 12, 21, 18,
                32, 23, 37, 26, 45, 34,
                50, 48, 61, 52, 73, 66};

        //创建三个块的对象
        Block b1 = new Block(21, 0, 5);
        Block b2 = new Block(45, 6, 11);
        Block b3 = new Block(73, 12, 17);

        //定义数组用来管理三个块的对象（索引表）
        Block[] blockArr = {b1, b2, b3};

        //定义一个变量用来记录要查找的元素
        int num = 37;

        //调用方法，传递索引表，数组，要查找的元素
        int index = getIndex(blockArr,arr,num);

        System.out.println(index);

    }

    //利用分块查找的原理，查询num的索引
    private static int getIndex(Block[] blockArr, int[] arr, int num) {
        //0.确定num是在哪一块当中
        int indexBlock = findIndexBlock(blockArr, num);

        if (indexBlock==-1){
            //表示num不在数组当中
            return -1;
        }

        //获取这一块的起始索引和结束索引
        int startIndex = blockArr[indexBlock].getStartIndex();
        int endIndex = blockArr[indexBlock].getEndIndex();

        //遍历
        for (int i = startIndex; i <= endIndex; i++) {
            if (arr[i]==num){
                return i;
            }
        }
        return -1;
    }

    //定义一个方法，用来确定num在哪一块当中
    private static int findIndexBlock(Block[] blockArr,int num){
        //从0索引开始遍历blockArr，如果num小于max,那么就表示num是在这一块当中的
        for (int i = 0; i < blockArr.length; i++) {
            if (num<=blockArr[i].getMax()){
                return i;
            }
        }
        return -1;
    }

}

class Block {
    private int max;//最大值
    private int startIndex;//起始索引
    private int endIndex;//结束索引


    public Block() {
    }

    public Block(int max, int startIndex, int endIndex) {
        this.max = max;
        this.startIndex = startIndex;
        this.endIndex = endIndex;
    }

    /**
     * 获取
     *
     * @return max
     */
    public int getMax() {
        return max;
    }

    /**
     * 设置
     *
     * @param max
     */
    public void setMax(int max) {
        this.max = max;
    }

    /**
     * 获取
     *
     * @return startIndex
     */
    public int getStartIndex() {
        return startIndex;
    }

    /**
     * 设置
     *
     * @param startIndex
     */
    public void setStartIndex(int startIndex) {
        this.startIndex = startIndex;
    }

    /**
     * 获取
     *
     * @return endIndex
     */
    public int getEndIndex() {
        return endIndex;
    }

    /**
     * 设置
     *
     * @param endIndex
     */
    public void setEndIndex(int endIndex) {
        this.endIndex = endIndex;
    }

    public String toString() {
        return "Block{max = " + max + ", startIndex = " + startIndex + ", endIndex = " + endIndex + "}";
    }
}

---

package Search;

public class A03_BlockSearchDemo2 {
    public static void main(String[] args) {
        /*扩展的分块查找（无规律的数据)*/
        int[] arr = {27, 22, 30, 40, 36,
                13, 19, 16, 20, 7, 10,
                43, 50, 48};

        Block2 b1 = new Block2(22, 40, 0, 4);
        Block2 b2 = new Block2(7, 20, 5, 10);
        Block2 b3 = new Block2(43, 50, 11, 13);
        Block2[] blockArr = {b1, b2, b3};

        int num = 43;//需要查找的数

        int index = getIndex(blockArr, arr, num);

        System.out.println(index);
    }

    private static int getIndex(Block2[] blockArr, int[] arr, int num) {
        //0.获取需要查找的元素在哪个块中
        int indexBlock = getIndexBlock(blockArr, num);
        if (indexBlock == -1) {
            return -1;
        }

        //获取这一块的开始索引和结束索引
        int startIndex = blockArr[indexBlock].getStartIndex();
        int endIndex = blockArr[indexBlock].getEndIndex();

        //遍历
        for (int i = startIndex; i <= endIndex; i++) {
            if (num == arr[i]){
                return i;
            }
        }
        return -1;
    }

    private static int getIndexBlock(Block2[] blockArr, int num) {
        for (int i = 0; i < blockArr.length; i++) {
            if (num >= blockArr[i].getMin() && num <= blockArr[i].getMax()) {
                return i;
            }
        }
        return -1;
    }


}

class Block2 {
    private int min;
    private int max;
    private int startIndex;
    private int endIndex;


    public Block2() {
    }

    public Block2(int min, int max, int startIndex, int endIndex) {
        this.min = min;
        this.max = max;
        this.startIndex = startIndex;
        this.endIndex = endIndex;
    }

    /**
     * 获取
     *
     * @return min
     */
    public int getMin() {
        return min;
    }

    /**
     * 设置
     *
     * @param min
     */
    public void setMin(int min) {
        this.min = min;
    }

    /**
     * 获取
     *
     * @return max
     */
    public int getMax() {
        return max;
    }

    /**
     * 设置
     *
     * @param max
     */
    public void setMax(int max) {
        this.max = max;
    }

    /**
     * 获取
     *
     * @return startIndex
     */
    public int getStartIndex() {
        return startIndex;
    }

    /**
     * 设置
     *
     * @param startIndex
     */
    public void setStartIndex(int startIndex) {
        this.startIndex = startIndex;
    }

    /**
     * 获取
     *
     * @return endIndex
     */
    public int getEndIndex() {
        return endIndex;
    }

    /**
     * 设置
     *
     * @param endIndex
     */
    public void setEndIndex(int endIndex) {
        this.endIndex = endIndex;
    }

    public String toString() {
        return "Block2{min = " + min + ", max = " + max + ", startIndex = " + startIndex + ", endIndex = " + endIndex + "}";
    }
}

---

6.哈希查找

哈希查找是分块查找的进阶版，适用于数据一边添加一边查找的情况。

一般是数组 + 链表的结合体或者是数组+链表 + 红黑树的结合体

规定：

• 数组的0索引处存储1~100
• 数组的1索引处存储101~200
• 数组的2索引处存储201~300
• 以此类推

但是实际上，我们一般不会采取这种方式，因为这种方式容易导致一块区域添加的元素过多，导致效率偏低。

更多的是先计算出当前数据的哈希值，用哈希值跟数组的长度进行计算，计算出应存入的位置，再挂在数组的后面形成链表，如果挂的元素太多而且数组长度过长，我们也会把链表转化为红黑树，进一步提高效率。

7. 树表查找

本知识点涉及到数据结构：树。

基本思想：二叉查找树是先对待查找的数据进行生成树，确保树的左分支的值小于右分支的值，然后在就行和每个节点的父节点比较大小，查找最适合的范围。 这个算法的查找效率很高，但是如果使用这种查找方法要首先创建树。

二叉查找树（BinarySearch Tree，也叫二叉搜索树，或称二叉排序树Binary Sort Tree），具有下列性质的二叉树：

1）若任意节点左子树上所有的数据，均小于本身；

2）若任意节点右子树上所有的数据，均大于本身；

二叉查找树性质：对二叉查找树进行中序遍历，即可得到有序的数列。

​ 不同形态的二叉查找树如下图所示：

基于二叉查找树进行优化，进而可以得到其他的树表查找算法，如平衡树、红黑树等高效算法。

不管是二叉查找树，还是平衡二叉树，还是红黑树，查找的性能都比较高

1.2 排序算法

1.冒泡排序

冒泡排序（Bubble Sort）也是一种简单直观的排序算法。

它重复的遍历过要排序的数列，一次比较相邻的两个元素，如果他们的顺序错误就把他们交换过来。

这个算法的名字由来是因为越大的元素会经由交换慢慢"浮"到最后面。

当然，大家可以按照从大到小的方式进行排列。


算法步骤

1. 相邻的元素两两比较，大的放右边，小的放左边
2. 第一轮比较完毕之后，最大值就已经确定，第二轮可以少循环一次，后面以此类推
3. 如果数组中有n个数据，总共我们只要执行n-1轮的代码就可以

public static void main(String[] args) {
        //0.定义数组
        int[] arr = {2, 4, 5, 3, 1};

        //1.利用冒泡排序将数组中的数据按从小到大的顺序进行排序
        for (int i = 0; i < arr.length - 1; i++) {
            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;
                }
            }

        }

        //2.打印数组
        printArr(arr);
    }

    private static void printArr(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

---

2.选择排序

算法步骤：

1. 从0索引开始，跟后面的元素一一比较
2. 小的放前面，大的放后面
3. 第一次循环结束后，最小的数据已经确定
4. 第二次循环从1索引开始以此类推
5. 第三轮循环从2索引开始以此类推
6. 第四轮循环从3索引开始以此类推。
   

public static void main(String[] args) {
        /*
            选择排序：
                1，从0索引开始，跟后面的元素一一比较。
                2，小的放前面，大的放后面。
                3，第一次循环结束后，最小的数据已经确定。
                4，第二次循环从1索引开始以此类推。

         */

        //1.定义数组
        int[] arr = {2, 4, 5, 3, 1};

        //2.利用选择排序让数组变成 1 2 3 4 5
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[i] > arr[j]) {
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }

        printArr(arr);
    }

    private static void printArr(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

---

3.插入排序

插入排序的代码实现虽然没有冒泡排序和选择排序那么简单粗暴，但它的原理应该是最容易理解的了，因为只要打过扑克牌的人都应该能够秒懂。插入排序是一种最简单直观的排序算法，它的工作原理是通过创建有序序列和无序序列，然后再遍历无序序列得到里面每一个数字，把每一个数字插入到有序序列中正确的位置。

插入排序在插入的时候，有优化算法，在遍历有序序列找正确位置时，可以采取二分查找

算法步骤

将0索引的元素到N索引的元素看做是有序的，把N+1索引的元素到最后一个当成是无序的。

遍历无序的数据，将遍历到的元素插入有序序列中适当的位置，如遇到相同数据，插在后面。

N的范围：0~最大索引

public static void main(String[] args) {
        int[] arr = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};

        printArr(arr);
        //0.找到无序的那一组数组是从哪个索引开始的
        int startIndex = -1;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > arr[i + 1]) {
                startIndex = i + 1;
                break;
            }
        }

        //1.遍历从startIndex开始到最后一个元素，依次得到无序的那一组数据中的每一个元素
        for (int i = startIndex; i < arr.length; i++) {
            //问题：如何把遍历到的数据，插入到前面有序的这一组当中

            //记录当前要插入数据的索引
            int j = i;

            //交换位置
            while (j > 0 && arr[j] < arr[j - 1]) {
                int temp = arr[j];
                arr[j] = arr[j - 1];
                arr[j - 1] = temp;
                j--;
            }
        }
        printArr(arr);

    }

    private static void printArr(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

---

4.快速排序前置知识——递归算法

递归指的是方法中调用方法本身的现象

递归的注意点：递归一定要有出口，否则就会出现内存溢出

把一个复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解。
递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算

public static void main(String[] args) {
        //需求：利用递归求1~100的和

        /*大问题拆解成小问题：
         * 1~100之间的和 = 100 + （1~99 之间的和）
         * 1~99 之间的和 = 99 + （1~98 之间的和）
         * 1~98 之间的和 = 98 + （1~97 之间的和）
         * ……
         * 1~2 之间的和 = 2 + （1~1 之间的和）
         * 1~1 之间的和 = 1 （递归的出口）
         */
        int sum = getSum(100);
        System.out.println(sum);
    }

    private static int getSum(int num) {
        if (num == 1) {
            return 1;
        }

        return num + getSum(num - 1);
    }

---

public static void main(String[] args) {
        /*需求：
        * 用递归求5的阶乘，并把结果在控制台输出*/

        //方法内部再次调用方法的时候，参数必须要更加的靠近出口
        int factorial = getFactorial(5);
        System.out.println(factorial);

    }

    private static int getFactorial(int num) {
        if (num == 1){
            return 1;
        }

        return num * getFactorial(num-1);
    }

---

---

4.快速排序

快速排序是由东尼·霍尔所发展的一种排序算法。

快速排序又是一种分而治之思想在排序算法上的典型应用。

快速排序的名字起的是简单粗暴，因为一听到这个名字你就知道它存在的意义，就是快，而且效率高！

它是处理大数据最快的排序算法之一了。

算法步骤:

1. 从数列中挑出一个元素，一般都是左边第一个数字，称为 “基准数”;
2. 创建两个指针，一个从前往后走，一个从后往前走。
3. 先执行后面的指针，找出第一个比基准数小的数字
4. 再执行前面的指针，找出第一个比基准数大的数字
5. 交换两个指针指向的数字
6. 直到两个指针相遇
7. 将基准数跟指针指向位置的数字交换位置，称之为：基准数归位。
8. 第一轮结束之后，基准数左边的数字都是比基准数小的，基准数右边的数字都是比基准数大的。
9. 把基准数左边看做一个序列，把基准数右边看做一个序列，按照刚刚的规则递归排序
   
   

public static void main(String[] args) {
//        int[] arr = {6, 1, 2, 7, 9, 3, 4, 5, 10, 8};

        int[] arr = new int[1000000];
        Random r = new Random();
        for (int i = 0; i < arr.length; i++) {
            arr[i] = r.nextInt();
        }

        long startTime = System.currentTimeMillis();
        quickSort(arr, 0, arr.length - 1);
        long endTime = System.currentTimeMillis();
//        printArr(arr);
        System.out.println(endTime - startTime + "毫秒");
    }


    private static void quickSort(int[] arr, int i, int j) {
        //定义两个变量记录要查找的范围
        int start = i;
        int end = j;

        //递归的出口
        if (start > end){
            return;
        }

            //记录基准数
            int baseNumber = arr[i];

        //利用循环找到要交换的数字
        while (start != end) {
            //利用end，从后往前找，找比基准数小的数字
            while (true) {
                if (end <= start || arr[end] < baseNumber) {
                    break;
                }
                end--;
            }

            //利用start，从前往后找，找比基准数大的数字
            while (true) {
                if (end <= start || arr[start] > baseNumber) {
                    break;
                }
                start++;
            }

            //利用end和start指向的元素进行交换
            int temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
        }
        //当start和end指向了同一个元素的时候，那么上面的循环就会结束
        //表示已经找到了基准数在数组中应存入的位置
        //基准数归位
        int temp = arr[i];
        arr[i] = arr[start];
        arr[start] = temp;

        //确定基准数左边的范围，重复刚刚做的事
        quickSort(arr, i, start - 1);
        //确定基准数右边的范围，重复刚刚做的事
        quickSort(arr, start + 1, j);
    }

    private static void printArr(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

---

总结

1.3 常见算法的API——Arrays

此类包含用来操作数组（比如排序和搜索）的各种方法。
此类还包含一个允许将数组作为列表来查看的静态工厂。

除非特别注明，否则如果指定数组引用为 null，则此类中的方法都会抛出 NullPointerException。

此类中所含方法的文档都包括对实现 的简短描述。应该将这些描述视为实现注意事项，而不应将它们视为规范 的一部分。实现者应该可以随意替代其他算法，只要遵循规范本身即可。（例如，sort(Object[]) 使用的算法不必是一个合并排序算法，但它必须是稳定的。）

此类是 Java Collections Framework 的成员。

public static void main(String[] args) {
        //toSting 将数组变成字符串
        System.out.println("--------toSting--------");
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        System.out.println(Arrays.toString(arr)); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

        /*binarySearch:二分查找法查找元素
         * 细节1：二分查找的前提：数组中的元素必须是有序，数组中的元素必须是升序的
         * 细节2：如果要查找的元素是存在的，那么返回的是真实的索引
         * 但是，如果要查找的元素是不存在的，返回的是  -插入点 - 1
         * 为什么要减1？
         * 如果要查找数字0，此时0是不存在的，但是按照上面的规则-插入点，应该就是0
         * 为了避免这样的情况，Java在这个基础上又减一*/
        System.out.println("--------binarySearch--------");
        System.out.println(Arrays.binarySearch(arr, 10)); //9
        System.out.println(Arrays.binarySearch(arr, 2)); //1
        System.out.println(Arrays.binarySearch(arr, 20)); //-11

        //copyOf：拷贝数组
        /*方法的底层会根据第二个参数来创建新的数组
         * 如果新数组的长度是小于老数组的长度,会部分拷贝
         * 如果新数组的长度是等于老数组的长度，会完全拷贝
         * 如果新数组的长度是大于老数组的长度，会不上默认初始值*/
        System.out.println("--------copyOf--------");
        int[] newArr = Arrays.copyOf(arr, 15);
        System.out.println(Arrays.toString(newArr)); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0, 0, 0, 0, 0]

        //copyOfRange：拷贝数组（指定范围）
        //包头不包尾，包左不包右
        System.out.println("--------copyOfRange--------");
        int[] newArr2 = Arrays.copyOfRange(arr, 2, 8);
        System.out.println(Arrays.toString(newArr2)); // [3, 4, 5, 6, 7, 8]

        //fill：填充数组
        System.out.println("--------fill--------");
        Arrays.fill(arr, 100);
        System.out.println(Arrays.toString(arr));

        //sort：排序。默认情况下，给基本数据类型进行升序排列,底层使用的是快速排序
        System.out.println("--------sort--------");
        int[] arr2 = {10, 2, 3, 5, 6, 7, 4, 8, 9, 1};
        Arrays.sort(arr2);
        System.out.println(Arrays.toString(arr2)); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    }

---

public static void main(String[] args) {
        Integer[] arr = {2, 3, 5, 6, 7, 8, 9, 4, 1};
        /*细节：
            只能给引用数据类型的数组进行排序
        *   如果数组是基本数据类型的，需要变成其对应的包装类*/

        /*第二个参数是一个接口，所以在调用方法的时候，需要传递这个接口的实现类对象，作为排序的规则
         * 但是这个实现类，只要用一次，所以就没有必要单独的去写一个类，直接采取匿名内部类的方法就可以了*/

        /*
        * 底层原理:
            利用插入排序 + 二分查找的方式进行排序的。
            * 默认把0索引的数据当做是有序的序列，1索引到最后认为是无序的序列。
            * 遍历无序的序列得到里面的每一个元素，假设当前遍历得到的元素是A元素
            * 把A往有序序列中进行插入，在插入的时候，是利用二分查找确定A元素的插入点。
            * 拿着A元素，跟插入点的元素进行比较，比较的规则就是compare方法的方法体
            * 如果方法的返回值是负数，拿着A继续跟前面的数据进行比较
            * 如果方法的返回值是正数，拿着A继续跟后面的数据进行比较
            * 如果方法的返回值是0，也拿着A跟后面的数据进行比较
            * 直到能确定A的最终位置为止。*/

        /*compare方法的形式参数:
        参数一 o1:表示在无序序列中，遍历得到的每一个元素
        参数二 o2:有序序列中的元素

        返回值:
            负数:表示当前要插入的元素是小的，放在前面
            正数:表示当前要插入的元素是大的，放在后面
            0:表示当前要插入的元素跟现在的元素比是一样的们也会放在后面
        */

        /*简单理解
            * o1 - o2 : 升序排列
            * o2 - o1 : 降序排列 */
        Arrays.sort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println("----------------");
                System.out.println("o1:" + o1);
                System.out.println("o2:" + o2);
                return o1 - o2;
            }

            @Override
            public boolean equals(Object obj) {
                return false;
            }
        });

        System.out.println(Arrays.toString(arr));
    }

---

---

二、lambda 表达式

2.1 lambda表达式

public static void main(String[] args) {
        //初识lambda表达式
        Integer[] arr = {2, 3, 1, 5, 6, 7, 8, 4, 9};

        /*Arrays.sort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        });*/

        Arrays.sort(arr, (Integer o1, Integer o2) -> {
                return o1 - o2;
            }
        );

        System.out.println(Arrays.toString(arr));
    }

package Lambda;

public class lambdaDemo2 {
    public static void main(String[] args) {
        method(new Swim() {
            @Override
            public void swimming() {
                System.out.println("正在游泳~~");
            }
        });

        //lambda
        method(
                ()->{
                    System.out.println("正在游泳~~");
                }
        );
    }

    private static void method(Swim s){
        s.swimming();
    }
}

interface Swim{
    public abstract void swimming();
}

---

2.2 Lambda表达式的省略写法

省略核心: 可推导，可省略

public static void main(String[] args) {
        //初识lambda表达式
        Integer[] arr = {2, 3, 1, 5, 6, 7, 8, 4, 9};

        Arrays.sort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1 - o2;
            }
        });

        //lambda完整格式
        Arrays.sort(arr, (Integer o1, Integer o2) -> {
                    return o1 - o2;
                }
        );

        //lambda省略格式
        Arrays.sort(arr, (o1, o2) -> {
                    return o1 - o2;
                }
        );

        Arrays.sort(arr, (o1, o2) -> o1 - o2);

        System.out.println(Arrays.toString(arr));
    }

2.3 练习

public static void main(String[] args) {
        /*Lambda表达式简化Comparator接口的匿名形式
         * 定义数组并存储一些字符串，利用Arrays中的sort方法进行排序
         * 要求:
         * 按照字符串的长度进行排序，短的在前面，长的在后面。
         * (暂时不比较字符串里面的内容)*/
        String[] arr = {"a", "aaaa", "aaa", "aa"};

        //如果以后要把数组中的数据按照指定的方式进行排列，就需要用到sort方法，而且要制定排序的规则
        /*Arrays.sort(arr, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.length() - o2.length();
            }
        });*/

        Arrays.sort(arr, (o1, o2) -> o1.length() - o2.length());

        System.out.println(Arrays.toString(arr));
    }

---