数组的学习

数组

• 定义：数组在内存中是一块连续的空间，可以保存`相同类型多个数据的容器
• 特点：相同数据类型；数组长度定长

数组的定义

动态初始化

• 数据类型[] 数组名=new 数据类型[]; (常用此种类型进行初始化)
• 数据类型 数组名[] = new 数据类型[];
• 示例:int[] arr = new int[5];

静态初始化

• 数据类型[] 数组名=new 数据类型[]{数据1,数据2,…};
• 数据类型[] 数组名={数据1,数据2,…};(常用此种类型进行初始化)
• 数据类型 数组名[] = {数据1,数据2,…};
• 示例:int[] arr={1,2,3,4};

数组的细节

• 数组中的数据称为数组元素
• 数组的每一个都对应一个下标，下标是从0开始的，范围是0-到数组长度-1
• 数组通过数组名.length获取数组长度
• 数据长度超过边界，会报数组越界的异常（ArrayIndexOutOfBoundsException）

数组遍历

int[] arr={1,2,3,4,5};
for(int i=0;i<arr.length;i++){
	System.out.println(arr[i]);		
}

数组的默认值

• 整数型数组默认值：0
• 浮点型数组默认值：0.0
• 布尔类型数组默认值：false
• 字符型数组默认值：0 或者’ '或者 ‘\u0000’
• 引用类型数组默认值：null
• null是一种特殊的值，表示当前对象在内存中没有指向任何地址。
• ""表示空字符串，在内存中有对应的内存地址

数组的扩容和缩容

• 定义一个新数组，然后新数组的长度比原数组增加或者是减小
• 将原来数组的元素拷贝到新数组中
• 将原数组的变量指向新数组

//数组的扩容和缩容
        //定义一个数组
        int[] arr5={1,2,3,4,5};
        //定义一个新数组，并增加数组长度
        int[] arr6=new int[arr5.length+2];
        //循环将原数组的元素赋值给新数组
        for (int i = 0; i < arr5.length; i++) {
            arr6[i]=arr5[i];
        }
        //将原数组的地址指向新数组
        arr5=arr6;
        System.out.println(Arrays.toString(arr5));

数组的拷贝

• System.arraycopy方法拷贝

//数组拷贝 System.arraycopy
        /*
        *System.arraycopy(Object src,  int  srcPos,
                                        Object dest, int destPos,
                                        int length);
        * Object src,   原数组
        * int  srcPos,  原数组的下标
        * Object dest,  新数组
        * int destPos,  新数组拷贝的下标
        * int length    拷贝的长度
        *
        * */
        int[] arr={1,2,3,4,5};
        int[] arr1=new int[arr.length+5];
        System.arraycopy(arr,0,arr1,0,arr.length);
        System.out.println(Arrays.toString(arr1));

• Arrays.copyOf方法拷贝
• 返回一个新数组

		//Arrays.copyOf
        /*
        Arrays.copyOf(int[] original, int newLength)
        * int[] original,  原数组
        *  int newLength   新数组的长度
        * 返回值为一个数组
        * */
        arr = Arrays.copyOf(arr, arr.length + 5);
        System.out.println(Arrays.toString(arr));

数组排序

• 冒泡排序
  将相邻的两个元素进行比较，如果前面一个元素比后面的大，就交换位置(一轮比较)
  将上面的操作循环（比较n-1轮）

public static void sort2(int[] arr){
        for (int i = 0; i < arr.length-1; i++) {
            boolean flag=true;
            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=false;
                }

            }
            System.out.println("第"+(i+1)+"轮：");
            for (int j = 0; j < arr.length; j++) {
                System.out.print(arr[j]+"\t");
            }
            System.out.println();
            if (flag){
                break;
            }
        }
    }

• 选择排序
  将当前这个数，与他后面每一个数字比较，选择最小的那个数，交换到当前位置
  循环选择当前位置上的数

public static void sort3(int[] arr){
        //比较轮次
        for (int i = 0; i < arr.length-1; i++) {
            int min=i;
            //从i+1进行比较
            for (int j = i+1; j < arr.length; j++) {
                if (arr[min]>arr[j]){
                    //找到比arr[min]更小的值，然后交换下标
                    min=j;
                }
            }
            //全部选择排序完成进行数值交换
            int temp=arr[min];
            arr[min]=arr[i];
            arr[i]=temp;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+"\t");
        }
    }

• 二分查找法
  前提：数组中的元素是有序的
  首先找到数组中的中间的元素，与要查找元素进行比较，如果相等，那么就直接找到了
  如果比中间的元素大，那么表示查找元素在中间值的右边。所以最小值的下标等于中间值的下标+1
  如果比中间的元素小，那么表示查找元素在中间值的左边。所以最大值的下标等于中间值的下标-1

//二分查找法
    //保证数组是升序的
    public static int getIndex(int[] arr, int num){
        //先将数据进行排序
        Arrays.sort(arr);
        //最大值下标
        int min=0;
        //最大值下标
        int max=arr.length-1;
        while(min<=max){
            //中间值下标
            int middle=(min+max)/2;
            if (num>arr[middle]){
                //如果num比中间值都大,中间值下标向右移动
                min=middle+1;
            }else if (arr[middle]>num){
                //如果num比中间值都小,中间值下标向左移动
                max=middle-1;
            }else {
                return middle;
            }
        }
        return -1;
    }

Arrays工具类进行排序的方法:Arrays.sort(arr);
升序排列

二维数组

• 定义
  静态初始化:
  int[][] arr={{1,2,3},{,3,4},{,1,2,3,4,5}};

//二维数组
        int[][] arr={{1,2,3},{4,5,6},{7,8,9}};
        //二维数组的访问
        //二维数组中第一个一维数组的第一个元素
        System.out.println(arr[0][0]);
        //二维数组中第二个一维数组的第二个元素
        System.out.println(arr[1][1]);
        //二维数组中第三个一维数组的第三个元素
        System.out.println(arr[2][2]);

        //赋值
        arr[0][0]=10;
        //遍历
        for (int i = 0; i < arr.length; i++) {//控制二位数组中一维数组的个数
            for (int j = 0; j < arr[i].length; j++) {//控制二位数组中一维数组中的元素个数
                System.out.print(arr[i][j]+"\t");
            }
        }

动态初始化：

//动态初始化
        //第一种方式
        int[][] arr1=new int[3][2];

        arr1[0][0]=1;
        arr1[0][1]=2;
        arr1[1][0]=3;
        arr1[1][1]=4;
        arr1[2][0]=5;
        arr1[2][1]=6;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j]+"\t");
            }
        }

        //第二种方式
        int[][] arr2=new int[2][];
        //必须要初始化
        arr2[0]=new int[1];
        arr2[1]=new int[1];

        arr2[0][0]=1;
        arr2[1][0]=1;

        System.out.println(Arrays.toString(arr2[0]));

二维数组的应用(杨辉三角)

/*
        *  杨辉三角(二维数组解决)，每行的数为，二维数组中的一维数组
        *        1
        *      1    1
        *     1  2   1   2元素的下标(2,1)  arr[i][j]=arr[i-1][j-1]+arr[i-1][j]
        *    1  3  3   1  3,1
        *   1  4  6  4   1
        *     .........
        *先计算外层的,:二维数组中的一维数组，j==0，右边的一层1，i==j
        *内层数据计算:2元素的下标(2,1)  规律:arr[i][j]=arr[i-1][j-1]+arr[i-1][j]
        * */
        int[][] yhArr=new int[10][];
        for (int i = 0; i < yhArr.length; i++) {
            //二维数组中一维数组元素的个数
            yhArr[i]=new int[i+1];
            //进行赋值
            for (int j = 0; j < yhArr[i].length; j++) {
                if (j==0||i==j){
                    yhArr[i][j]=1;
                }else {
                    yhArr[i][j]=yhArr[i-1][j-1]+yhArr[i-1][j];
                }
            }

        }

        for (int i = 0; i < yhArr.length; i++) {
            for (int j = 0; j < yhArr.length-i; j++) {
                System.out.print("  ");
            }
            for (int j = 0; j < yhArr[i].length; j++) {
                System.out.print(yhArr[i][j]+"  ");
            }
            System.out.println();
        }

可变参数

• 语法： 数据类型… 参数名
  特点：
• 1、带有可变参数方法的调用的时候，实参个数,可以是0个或者是多个
• 2、可变参数只能放在参数列表的最后(一个方法只能有一个可变参数)
• 3、可变参数可以当做数组来使用，也可以将数组作为参数
  场景：不确定参数个数的时候

public class Demo01 {
    public static void main(String[] args) {
        method("zs","ls","ww");
    }

    //可变参数
    /*
    * 可变参数，个数不固定（0或多个）
    * 只能放在最后，后边不能再有参数
    * 不确定参数的时候使用
    * 使用方法和数组类似
    * 参数也可以传入数组
    * */
    public static void method(String... str){
        for (int i = 0; i < str.length; i++) {
            System.out.println(str[i]);
        }
    }

}