数组

数组

数组的概念

数组的作用：用来保存、管理一组相同数据类型的数据

把一组具有相同数据类型的变量使用同一个名字来进行管理，并且这些元素按照一定的顺序进行排列。这同一个名字我们称为【数组名】，每一个元素通过编号进行区别，这个编号我们称为【下标】或索引。元素的总个数就是【数组的长度】。

数组如何声明和初始化

数组的声明：

数组类型 数组名；

数组的元素的类型【】 数组名；（推荐使用方式）

数组的元素的类型  数组名【】；

初始化：

动态初始化

格式：数组名 = new  元素的类型[数组的长度];

静态初始化

格式：数组名 = new  元素的类型[]{元素列表};

      元素列表的每一个元素使用,分割

      元素列表的个数就是数组的长度

简化写法：元素的类型[]  数组名  =  {元素列表};

      只有声明和静态初始化在一行，才可以这么简写

数组的元素

表示形式

数组名[下标]   下标的范围：

[0，数组的长度 - 1]   （[0,数组名.length-1]）

赋值

数组名[下标] = 值；

数组的遍历

for循环

for(int i=0; i<数组名.length; i++){
}

foreach循环

for(数组的元素的类型   元素的临时名 : 数组名){
}

*数组的算法(很重要)

在数组中找到最大值/最小值

    //找最大值
    public static int max(int[] arr){
        //第一步：假设第一个元素最大
        int max = arr[0];
        
        //遍历后面的元素和max比较
        for (int i = 1; i < arr.length; i++) {
            //当有比max的值，就把max修改为它的值
            if(max < arr[i]){
                max = arr[i];
            }
        }
        
        return max;
    }

在数组中查找最大值/最小值的下标

    //找最大值的下标
    public static int maxIndex(int[] arr){
        //第一步：假设第一个元素最大
        int index = 0;
        
        //arr[index] 和 后续的元素一一比较
        for (int i = 1; i < arr.length; i++) {
            //当有比max的值，就把max修改为它的值
            if(arr[index] < arr[i]){
                index = i;
            }
        }
        return index;
    }

数组元素的累加和，平均值

//求数组元素的总和
    public static long sum(int[] arr){
        long sum = 0;
        
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        
        return sum;
    }
    public static double avg(int[] arr){
        double sum = sum(arr);
        return sum/arr.length;
    }

反转

//反转
    public static void reverse(int[] arr){
        //如果有5个元素，应该交换2次或3次      arr.length/2
         //如果有6个元素，应该交换3次                 arr.length/2
        //数组的收尾对应位置交换
        
        //次数
        for(int i=0; i<arr.length/2; i++){
            //首尾交换
            int temp = arr[i];
            arr[i] = arr[arr.length-1-i];
            arr[arr.length-1-i] = temp;
        }
    }
    
    //反转部分
    public static void reverse(int[] arr, int start ,int end){
        //次数     
        //假设start = 1, end = 5     次数2次    (end + 1 - start)/2  (5+1-1)/2  2
        //假设start = 1, end = 6  次数3次      (end + 2 - start)/2  (6+1-1)/2  3
        
        for(int i=0; i< (end + 1 - start)/2; i++){
            //首尾交换
            //arr[start],arr[start+1]...
            //arr[end],arr[end-1]...
            int temp = arr[start + i];
            arr[start + i] = arr[end -i];
            arr[end-i] = temp;
        }
    }

复制

    //复制一个数组，从原数组的[0]元素开始复制，新数组的长度由使用者决定
    public static int[] copy(int[] src, int newLength){
        //1、创建新数组的对象
        int[] newArray = new int[newLength];
        
        //2、把原数组的元素复制到新数组中
        for(int i=0; i<newArray.length && i<src.length; i++){
            newArray[i] = src[i];
        }
        
        return newArray;
    }
    
    //复制一个数组，从原数组的[start]元素开始复制，新数组的长度由使用者决定
    public static int[] copy(int[] src, int start, int newLength){
        //1、创建新数组
        int[] newArray = new int[newLength];
        
        //2、把原数组的元素从[start]复制到新数组的[0]...
        for(int i=0; i<newArray.length && start+i<src.length; i++){
            newArray[i] = src[start+i];
        }
        
        return newArray;
    }

排序

冒泡排序（必须会，要能手写出来）

    //假设数组5个元素
    public static void pubSort3(int[] arr){
        //方式二：把大的往右沉
        //每一轮从左边开始比较
        //比较的轮数依然是n-1轮
        for(int i=1; i<arr.length; i++){
            //每一轮从左边开始比较
            /*
             * 第一轮：i=1， 比较4次，j=0,1,2,3   ,j<arr.length-i  j<5-1 j<4 
             * 第二轮：i=2，比较3次，j=0,1,2      ,j<arr.length-i  j<5-2 j<3
             * ...
             */
            for(int j=0; j<arr.length-i; j++){
                //如果左边的元比右边的元素大，交换
                if(arr[j] > arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }
    
    //假设数组5个元素
    public static void pubSort2(int[] arr){
        //排序规则：每一轮通过相邻元素的比较，把小的往左边冒（或把大的往右边沉），每一轮都是把本轮的最小值冒出来（最大值沉下去）
        //经过n-1轮完成最终的排序
        //(1)方式一：把小的往左边冒，注意，每一轮都是从最右边往左边比较
        //i=0,i=1,i=2,i=3  i<5-1 -->  i<4 -->  i<=3
        for(int i=0; i<arr.length-1; i++){//一共n-1轮
            //每一轮都要从最右边往左边比较
            /*
             * 第一轮：比较n-1次，比较4次， i=0, j=4,3,2,1 ,j>i
             * 第二轮：比较3次，i=1, j=4,3,2 ,j>i
             * ....
             */
            for(int j=arr.length-1; j>i; j--){
                //相邻的元素比较，而且如果右边的比左边的小，需要交换
                if(arr[j] < arr[j-1]){
                    int temp = arr[j];
                    arr[j] = arr[j-1];
                    arr[j-1] = temp;
                }
            }
        }
    }
    
    //冒泡排序：从小到大
    //如果数组是5个元素
    public static void pubSort(int[] arr){
        //排序规则：每一轮通过相邻元素的比较，把小的往左边冒（或把大的往右边沉），每一轮都是把本轮的最小值冒出来（最大值沉下去）
        //经过n-1轮完成最终的排序
        //(1)方式一：把小的往左边冒，注意，每一轮都是从最右边往左边比较
        for(int i=1; i<arr.length; i++){//一共n-1轮
            //每一轮都要从最右边往左边比较
            /*
             * 第一轮：比较n-1次，比较4次， i=1, j=4,3,2,1 ,j>=i
             * 第二轮：比较3次，i=2, j=4,3,2 ,j>=i
             * ....
             */
            for(int j=arr.length-1; j>=i; j--){
                //相邻的元素比较，而且如果右边的比左边的小，需要交换
                if(arr[j] < arr[j-1]){
                    int temp = arr[j];
                    arr[j] = arr[j-1];
                    arr[j-1] = temp;
                }
            }
        }
    }

直接选择排序

    //直接选择排序
    //基本原理：将待排序的元素分为已排序（初始为空）和未排序两组，依次将未排序的元素中值最小的元素放入已排序的组中。
    //[3,2,1,5,4]  从小到大排序
    /*
     * 第一次：所有元素都属于未排序   把未排序的元素中的最小值找出来    arr[2] = 1 ，放入已排序组中     和第一个元素交换
     *         [1,2,3,5,4]
     * 第二次：已排序的是[1]，未排序的是[2,3,5,4]，把未排序元素中的最小值找出  arr[1]=2，放入已排序组中  
     *         【1,2】，【3,5,4】
     * ...
     * 
     */
    //假设5个元素
    public static void selectSort(int[] arr){
        //次数
        for(int i=0; i<arr.length-1; i++){
            //第一次，找最小值
            //假设每一轮的未排序元素的第一个最小
            int index = i;
            
            //找出本轮最小值
            /*
             * int i=0 ,从哪些元素中找最小值  [0]~[4]   j=1,2,3,4
             * int i=1，从哪些元素中找最小值[1]~[4]    j=2,3,4
             * ...
             */
            for(int j=i+1; j<arr.length; j++){
                if(arr[index] > arr[j]){
                    index = j;
                }
            }
            
            //找出arr[index]值最小，下标是index
            //arr[i] 和 arr[index]交换
            if(i!=index){
                int temp = arr[i];
                arr[i] = arr[index];
                arr[index] = temp;
            }
            
        }
    }

数组的扩容

    private void kuorong(){
        //先扩容
        int[] newArray = new int[arr.length*2];
        //通过循环把原数组中的内容复制到新数组中
        for(int i=0; i<arr.length; i++){
            newArray[i] = arr[i];
        }
        //把新家的地址记录下来，下次存、取元素都从新家操作，旧家不要了
        arr = newArray;
    }

数组的元素插入

public class MyArrayList {
    private int[] arr = new int[5];//装数据
    private int total;//记录实际存储的元素的个数
    
    
    //在index插入数据data
    public void insert(int index, int data){
        //如果当前数组已满，需要先扩容
        if(total >= arr.length){
            //(1)先创建一个新的更大的数组
            int[] newArray = new int[arr.length*2];
            //(2)把原来数组中的数据复制到新数组中
            for(int i=0; i<arr.length; i++){
                newArray[i] = arr[i];
            }
            //(3)使得arr指向新数组
            arr = newArray;
        }
        
        //1、先把index右边的元素右移
        /*
         * 假设total=3,index=1
         * 现在有值arr[0],arr[1],arr[2]，需要移动的是arr[2],arr[1]
         * 假设total=5,index=1
         * 现在有值arr[0],arr[1],arr[2],arr[3],arr[4]，需要移动的是,arr[4],arr[3],arr[2],arr[1]
         */
        for(int i = total-1; i>=index; i--){
            //右边的元素=左边的元素
            arr[i+1] = arr[i];
        }
        
        //在index位置插入data
        arr[index]= data;
        
        //元素个数加1
        total++;
    }
}

数组的元素删除

删除指定位置的元素

public class MyArrayList {
    private int[] arr = new int[5];//装数据
    private int total;//记录实际存储的元素的个数
    
    //删除指定位置的元素
    public void delete(int index){
        //(1)把index右边的元素左移
        /*
         * 假设现在total=3,index =1
         * 有值的是arr[0],arr[1],arr[2]，需要移动的是arr[2]
         * 假设现在total=5,index =1
         * 现在有值arr[0],arr[1],arr[2],arr[3],arr[4]，需要移动的似乎arr[2],arr[3],arr[4]
         */
        for(int i = index+1; i<total; i++){
            //左边的元素=右边的元素
            arr[i-1] = arr[i];
        }
        
        //(2)把最后一个元素的位置置为“空”（还原到默认值）
        arr[total-1] = 0;
        
        //(3)元素个数减一
        total--;
    }
}

删除指定的元素值

public class MyArrayList {
    private int[] arr = new int[5];//装数据
    private int total;//记录实际存储的元素的个数
    
    //删除指定位置的元素
    public void delete(int index){
        //(1)把index右边的元素左移
        /*
         * 假设现在total=3,index =1
         * 有值的是arr[0],arr[1],arr[2]，需要移动的是arr[2]
         * 假设现在total=5,index =1
         * 现在有值arr[0],arr[1],arr[2],arr[3],arr[4]，需要移动的似乎arr[2],arr[3],arr[4]
         */
        for(int i = index+1; i<total; i++){
            //左边的元素=右边的元素
            arr[i-1] = arr[i];
        }
        
        //(2)把最后一个元素的位置置为“空”（还原到默认值）
        arr[total-1] = 0;
        
        //(3)元素个数减一
        total--;
    }
    
    public int findValue(int value){
        //挨个遍历，一共有total，遍历total个
        for (int i = 0; i < total; i++) {
            if(arr[i] == value){
                return i;
            }
        }
        return -1;
    }
    
    public void deleteValue(int value){
        //1、先找到value在数组中的index，这里以第一次找到为准
        int index = findValue(value);
        
        //2、删除index位置的元素
        if(index!=-1){
            delete(index);
        }
    }
}

在数组中查找某个值的下标

public class MyArrayList {
    private int[] arr = new int[5];//装数据
    private int total;//记录实际存储的元素的个数
    
    //删除指定位置的元素
    public void delete(int index){
        //(1)把index右边的元素左移
        /*
         * 假设现在total=3,index =1
         * 有值的是arr[0],arr[1],arr[2]，需要移动的是arr[2]
         * 假设现在total=5,index =1
         * 现在有值arr[0],arr[1],arr[2],arr[3],arr[4]，需要移动的似乎arr[2],arr[3],arr[4]
         */
        for(int i = index+1; i<total; i++){
            //左边的元素=右边的元素
            arr[i-1] = arr[i];
        }
        
        //(2)把最后一个元素的位置置为“空”（还原到默认值）
        arr[total-1] = 0;
        
        //(3)元素个数减一
        total--;
    }
    
    public int findValue(int value){
        //挨个遍历，一共有total，遍历total个
        for (int i = 0; i < total; i++) {
            if(arr[i] == value){
                return i;
            }
        }
        return -1;
    }
    
    public void deleteValue(int value){
        //1、先找到value在数组中的index，这里以第一次找到为准
        int index = findValue(value);
        
        //2、删除index位置的元素
        if(index!=-1){
            delete(index);
        }
    }
}