【JavaSE】- 二维数组

1.1🍥二维数组介绍

多维数组我们只介绍二维数组。
二维数组的应用场景
比如我们开发一个五子棋游戏，棋盘就是需要二维数组来表示。如图：

1.2🛬二维数组使用

code

package two.dimensional.array;

public class TwoDimensionalArray01 {
    public static void main(String[] args) {
//        请用二维数组输出如下图形
//        0 0 0 0 0 0
//        0 0 1 0 0 0
//        0 2 0 3 0 0
//        0 0 0 0 0 0

        //什么是二维数组：
        //1. 从定义形式上看 int[][]
        //2. 可以这样理解，原来的一维数组的每个元素是一维数组, 就构成二维数组
        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}};
        //关于二维数组的关键概念
        //(1)
        System.out.println("二维数组的元素个数=" + arr.length);
        //(2) 二维数组的每个元素是一维数组, 所以如果需要得到每个一维数组的值
        // 还需要再次遍历
        //(3) 如果我们要访问第 (i+1)个一维数组的第 j+1 个值 arr[i][j];
        // 举例 访问 3, => 他是第 3 个一维数组的第 4 个值 arr[2][3]
        System.out.println("第 3 个一维数组的第 4 个值=" + arr[2][3]); //3
        //输出二维图形
        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();//换行
        }
    }
}

run

1.3🥩二维数组的初始化

1. 方式1： 类型[][] 数组名=new 类型[大小][大小]
2. 比如: int arr[][]=new int[2][3]
3. 使用演示
4. 二维数组在内存的存在形式(!!画图)
5. 方式 2: 动态初始化 先声明：类型 数组名[][]; 再定义(开辟空间) 数组名 = new 类型[大小][大小] 赋值(有默认值，比如 int 类型的就是 0)

代码

        //int arr[][] = new int[2][3];
        int arr[][]; //声明二维数组
        arr = new int[2][3];//再开空间
        arr[1][1] = 8;
        //遍历 arr 数组
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {//对每个一维数组遍历
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();//换行
        }

run

内存分析图

使用方式 3: 动态初始化-列数不确定

看一个需求：动态创建下面二维数组，并输出
i = 0: 1
i = 1: 2 2
i = 2: 3 3 3
一个有三个一维数组, 每个一维数组的元素是不一样的

code

        //int arr[][] = {{1}, {2, 2}, {3, 3,3}};
        int arr[][] = new int[3][];         // 有3个一维数组，但是每个一维数组还没有开数据空间
        for (int i = 0; i < arr.length; i++) {  // 0 1 2
            arr[i] = new int[i+1]; //给每个一维数组开空间，如果没有给一维数组 new ,那么 arr[i]就是 null
            for (int j = 0; j < arr[i].length; j++) {
                arr[i][j] = i+1;
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }

run

内存分析

使用方式 4: 静态初始化
定义 类型 数组名[][] = {{值 1,值 2..},{值 1,值 2..},{值 1,值 2..}}
使用即可 [ 固定方式访问 ]
比如:
int[][] arr = {{1,1,1}, {8,8,9}, {100}};

这样写不行

int arr[][] = {{1,1,1}, {8,8,9}, 100}; // err 

2.1🍕二维数组练习

遍历该二维数组，并得到和

code

package two.dimensional.array;

public class TwoDimensionalArray04 {
    public static void main(String[] args) {
        int s = 0;
        int arr[][] = {{4, 6}, {1, 4, 5, 7}, {-2}}; // 遍历该二维数组，并得到和
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                s += arr[i][j];
            }
        }
        System.out.println("s = " + s);
    }
}

s=25

使用二维数组打印一个 10 行杨辉三角
1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1
规律
1.第一行有 1 个元素, 第 n 行有 n 个元素
2. 每一行的第一个元素和最后一个元素都是 1
3. 从第三行开始, 对于非第一个元素和最后一个元素的元素的值. arr[i][j]
arr[i][j] = arr[i-1][j] + arr[i-1][j-1]; //必须找到这个规律

code

package two.dimensional.array;

public class YangHui {
    public static void main(String[] args) {

        int arr[][] = new int[10][];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = new int[i + 1];
            for (int j = 0; j < arr[i].length; j++) {
                // 如果是每个一维数组中第一个和最后一个元素，就是一
                if (j == 0 || j == arr[i].length - 1) {
                    arr[i][j] = 1;
                } else {
                    arr[i][j] = arr[i - 1][j] + arr[i - 1][j - 1];
                }
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }
}

run

2.2🧁二维数组使用细节和注意事项

1. 一维数组的声明方式有:
   int[] x 或者 int x[]
2. 二维数组的声明方式有:
   int[][] y 或者 int[] y[] 或者 int y[][]
3. 二维数组实际上是由多个一维数组组成的，它的各个一维数组的长度可以相同，也可以不相同。比如 map[][] 是一个二维数组
   int map [][] = {{1,2},{3,4,5}}
   由 map[0] 是一个含有两个元素的一维数组 ，map[1] 是一个含有三个元素的一维数组构成，我们也称为列数不等的二维数组

2.3🍄本章练习

数组初始化回顾

// 数组的3种初始化方式
int test[] = {1,2,1,2,1};        // 静态赋值

int test2[];                    // 动态赋值
test2 = new int[5];

int test3[] = new int[5];       // 动态赋值

匿名数组

int arr[] = {1,2,3,4,5};
arr = new int[]{6,7,8,9,10};

//   匿名数组
// 这会分配一个新数组，这个新数组的值为{6,7,8,9,10}
// 它会统计初始值个数，并设置数组大小，
// 这种语法可以重新初始化
// 一个数组而无须创建新变量
for (int i = 0 ; i<arr.length ; i++){
   System.out.print(arr[i]+" ");
}

// str数组先指向123，后指向abc
String str[] = {"1","2","3"}; 
str = new String[]{"a","b","c"};
// str2数组先指向NULL，后指向abc
String str2[];
str2 = new String[]{"a","b","c"};

run

3. 输出 -> 1 3 5 7

code

        // [10,12,45,90] -> [10,12,23,45,90] 插入元素后结果依旧为升序

        // 方法1.
        int arr[] = {10, 12, 45, 90};
        int insertNum = 23;
        int index = -1;
        int arrNew[] = new int[arr.length + 1];

        // 查找insertNum所插入的位置(索引)
        for (int i = 0; i < arr.length; i++) {
            if (insertNum <= arr[i]) {
                index = i;
                break;      // 找到索引后直接退出
            }
        }

        // 如果遍历了原数组都不符合条件，那么插入的数就是新数组的末尾
        if (index == -1) {
            index = arrNew.length - 1; // arr.length
        }

        // i为遍历新数组的每个元素，j为原数组的元素的下标
        //[10,12,45,90]

        for (int i = 0, j = 0; i < arrNew.length; i++) {
            if (i != index) {
                arrNew[i] = arr[j];
                j++;
            } else {
                arrNew[i] = insertNum;
            }
        }
        arr = arrNew;
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }

run

code

        // 随机生成10个整数(1-100),并倒序打印以及求平均值，
        // 求最大值及其下标，并查找其中是否有8

        int arr[] = new int[10];
        for (int i = 0; i < 10; i++) {
            int r = (int) ((Math.random() * 10) + 1);
            arr[i] = r;
            System.out.print(arr[i] + " ");
        }
        double s = 0.0d;
        int max = arr[0];
        int index = -1;
        int maxIndex = 0;
        System.out.println("\n===逆序后===");
        for (int i = arr.length - 1; i >= 0; i--) {
            s += arr[i];
            if (max < arr[i]) {
                max = arr[i];
                maxIndex = i;
            }
            if (8==arr[i]){
                index = i;
            }
            System.out.print(arr[i] + " ");
        }
        System.out.println("\n平均值是"+s/ arr.length);
        System.out.println("最大值是"+max+"下标为"+maxIndex);
        if (-1 != index) {
            System.out.println("8的下标是" + index);
        }
        else {
            System.out.println("没有找到8");
        }

run