数组

数组

数据类型 数组名[] =new 数据类型[大小]

数组默认情况下是引用传递，赋得值是地址，赋值方式为引用表达

数组使用注意事项

1. 数组是多个相同类型数据的组合，实现对这些数据的统一管理
2. 数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用。
3. 数组创建后，如果没有赋值，有默认值
   int 0，short 0, byte 0, long 0, float 0.0,double 0.0，char \u0000，boolean false，String null
4. 使用数组的步骤 1.声明数组并开辟空间 2.给数组各个元素赋值 3.使用数组
5. 数组的下标是从 0 开始的。

数组应用

创建一个 char 类型的 26 个元素的数组，分别 放置'A'-'Z'。

private static void demo_01() {
    char[] chars = new char[26];
    for (int i = 0; i < chars.length; i++) {
        chars[i] = (char) ('A' + i);
        //'A' + i 是 int , 需要强制转换
    }
    System.out.println("===chars 数组===");

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

求请求出一个数组的和和平均值。

private static void demo02(){
        int[] arr ={8,2,3,5,2};
        int count =0;
        for (int j : arr) {
            count += j;
        }
        System.out.println("====总和为==="+count);
        System.out.println("====平均为==="+count/arr.length);
    }

求出一个数组 int[]的最大值 {4,-1,9, 10,23}，并得到对应的下标

private static void demo03(){
    int[] arr ={1,2,3,4,5,6};
    int max=arr[0];
    int maxIndex=0;
    for (int i = 1; i < arr.length; i++) {
        if (max<arr[i]){
            max=arr[i];
            maxIndex=i;
        }
    }
    System.out.println("最大值为==="+max+";最大值得下标为==="+maxIndex);
}

数组拷贝

将数组拷贝到另一个数组

int[] arr1 = {10, 20, 30};
int[] arr2 = new int[arr1.length];
for (int i = 0; i < arr1.length; i++) {
    //将原数组的值拷贝到新数组
    arr2[i] = arr1[i];
}
arr2[0] = 100;
System.out.println("====arr1 的元素====");
for (int i = 0; i < arr1.length; i++) {
    System.out.println(arr1[i]);
 
}
System.out.println("====arr2 的元素====");
for (int i = 0; i < arr2.length; i++) {
    System.out.println(arr2[i]);
}

数组添加/扩容

   //初始化数组
    int[] arr = {1, 2, 3};
    //新数组
    int[] arrNew = new int[arr.length + 1];
    //便利数组
    for(int i = 0; i < arr.length; i++) {
        arrNew[i] = arr[i];
    }
    //新添加的数
    int tmp = 10;
    arrNew[arrNew.length - 1] = tmp;
    //让新数组指向老数组
    arr = arrNew;

数组排序

冒泡排序

  int[] arr = {24, 69, 80, 57, 13, -1, 30, 200, -110};
    //用于辅助交换的变量
    int temp = 0;
    //外层循环是 arr.length - 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]) {
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }
        System.out.println("\n==第"+(i+1)+"轮==");
        for(int j = 0; j < arr.length; j++) {
            System.out.print(arr[j] + "\t");
        }
    }
}

优化冒泡排序的两种方法

立flag或者打boolean标记，后续会经常用到这个

 /**
     * 优化冒泡排序减少内层或者外层循环次数
     * 思路：控制循环次数，立flag或者设置boolean标记
     */
private static void buddingOptOne() {
        //初始化数组
        int[] arr = {432658, 23, 564, 0, 242, 11};
        int len = arr.length;
        int temp =0;
        //外层控制排序的次数
        for (int i = 0; i < len - 1; i++) {
            //初始化标记  也可以使用boolean
            int flag = 0;
            //boolean flag =true;
            //内层循环数组
            for (int j = 0; j < len - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    //此时发生交换,标记改变
                    flag=1;
                    //flag=false;
                }
                
            }
            //如果boolean值发生改变,则退出当前循环
            //if(!flag){
            //没有发生交换则退出循环；
            //    break;
            //}
            //继续如果没有要改变的,直接返回无需继续内层排序
            if (flag == 0){
                return;
            }
            System.out.println("\n==第" + (i + 1) + "轮==");
            for (int j = 0; j < arr.length; j++) {
                System.out.print(arr[j] + "\t");
            }
        }

    }

多维数组（二维数组）

1. 格式：数据类型 [] [] = new 数据类型 [] []
2. 二维数组实际上是由多个一维数组组成的，它的各个一维数组的长度可以相同，也可以不相同
3. 二维数组使用

打印正方形

//打印正方形
int[][] arr = {
        {0, 0, 0, 0, 0, 0},
        {0, 0, 1, 0, 0, 0},
        {0, 2, 0, 3, 0, 0},
        {0, 0, 0, 0, 0, 0}};
	//遍历二维数组的每个元素
for (int i = 0; i < arr.length; i++) {
    //遍历二维数组的每个元素(数组)
    //1. arr[i] 表示 二维数组的第 i+1 个元素 比如 arr[0]：二维数组的第一个元素
    //2. arr[i].length 得到 对应的 每个一维数组的长度
    for (int j = 0; j < arr[i].length; j++) {
        //输出了一维数组  
        System.out.print(arr[i][j] + " ");
    }
    //换行
    System.out.println();
}

杨辉三角

//杨辉三角
int[][] yangHui = new int[12][];
//遍历 yangHui 的每个元素
for (int i = 0; i < yangHui.length; i++) {
    //给每个一维数组(行) 开空间
    yangHui[i] = new int[i + 1];
    //给每个一维数组(行) 赋值
    for (int j = 0; j < yangHui[i].length; j++) {
        //每一行的第一个元素和最后一个元素都是 1
        if (j == 0 || j == yangHui[i].length - 1) {
            yangHui[i][j] = 1;
        } else {
            //中间的元素规矩
            yangHui[i][j] = yangHui[i - 1][j] + yangHui[i - 1][j - 1];
        }
    }
}
//输出杨辉三角
for (int i = 0; i < yangHui.length; i++) {
    //遍历输出该行
    for (int j = 0; j < yangHui[i].length; j++) {
        System.out.print(yangHui[i][j] + "\t");
    }
    System.out.println();
}