数组的总结

1.static关键字：
    *static关键字修饰的东西优先于类而存在 随着类的加载而加载
    *static关键字可以修饰变量、成员（方法、属性）、方法等
    *static修饰的变量在常量池里，只有一份，被所有类的对象共享
    *static修饰的成员方法和成员属性 直接通过类名就能调用
    *static修饰的方法 只能调用静态的变量 不能调用非静态的变量
    *普通的方法能调用非静态的 也能调用静态的
    *static主要应用在工具类当中
    *静态方法中不可以定义this、super关键字（矛盾）
    *private和static不能共存（原因是static修饰的优先于类而存在 而private修饰的属性为私有的）
2.代码块：
    *静态代码块：由static关键字修饰 范围 ： 类的里面，成员方法的外面
        类：

            static{
                   语句
                }
        方法：

    *构造代码块：写在类的里面 成员方法的外面
        类：

                    {
                   语句
                }
        方法：

    *局部代码块：写在成员方法的里面
        类：
        方法：

                   {
                   语句
                }
    *执行的优先顺序：
    静态>构造
    构造代码块>构造器

3.Arrays类的一些方法：
    *数组的迭代（遍历）：Arrays.toString(数组名) 返回的是一个String类型
            生成为[*，*，*]的数组

    *数组的扩容（缩放）：Arrays.copyOf(数组名，选取的长度)

    *数组的排序：Arrays.sort(数组名)
             顺序：从小到大
    
4.数组的排序：
    *冒泡排序：核心：每一行进行比较 最后会把最大的数确定下来 在前面

     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;
                                }
                        }
                }
    
    *插入排序：核心：默认i往后的数为正序 拿i前一个数和后面的每一个数比较

     for(int i = 1;i<arr.length;i++){  //默认i从数组的第二个元素开始
                    int index = arr[i];  //把取的数保存
                    int j;
                    for(j = i - 1;j>=0 && index<arr[j];j--){ //取j为i-1的元素 j在i的后面 如果取的数比后面的数小
                    arr[j+1] = arr[j];                  //就让前后的数都为大的数
                    }

                    arr[j+1] = index;   //再把小的数给后面的数

                }

    *选择排序：核心：始终拿最小的比较 每次比较完以后会生成一个最小的在后面

    //方法一 拿下标交换

            for(int i = 0;i<arr.length;i++){
                int index = i; //保存拿的那个数的下标
                    for(int j = i+1;j<arr.length;j++){ //让j移动
                    if(arr[index]>arr[j]){ //出现比你拿的那个数小的数
                        index = j; //保存比 拿的数 小 的数 的下标
                    }
                }
                int temp = arr[i]; //交换拿的数和刚才保存的下标
                arr[i] = arr[index];
                arr[index] = temp;
            }

    //方法二 用i 和 j去交换

            int[] arr2 = new int[]{56,84,2,14,96,32,7,10};

            for(int i = 0;i<arr2.length;i++){
                for(int j = i+1;j<arr2.length;j++){
                    if(arr2[i]>arr2[j]){
                        int temp = arr2[i];
                        arr2[i] = arr2[j];
                        arr2[j] = temp;
                        }
                    }
            }