多维数组

4.3 多维数组

---

目录

• 4.3 多维数组
  • 4.3.1 二维数组
    • 一、二维数组定义方法
    • 二、二维数组的运行机制
    • 三、二维数组的使用
    • 四、多维数组之间的关系
  • 4.3.2 同时定义多个数组
  • 4.3.3 二维数组应用题
  • 4.3.4 多维数组细节

4.3.1 二维数组

数组不止能存储某具体值，还能用 数组 储存数组。

介绍：

• 我们前面学的数组都是一维数组，数组里存储的是具体的值，就是一位数组。
• 数组不仅可以储存值，还能储存另外一个完整的数组。这种使用 数组储存 数组 的数组我们叫二位数组。
• 具体语法： 类型 数组名[][] = {{1, 3, 5}, {2, 4, 6}, {7, 9, 11}, {8, 10, 12}};

一、二维数组定义方法

二维素组`和`一维数组`一样，一样可以分为`静态初始化` 和 `动态初始化

静态初始化

// 声明要存放的值的类型  数组名   声明这是一个二维数组
int twoDimensionalArray [][] = {
    {1, 2, 3}, 
    {4, 5, 6},
    {7, 8, 9}
};

动态初始化

• 动态初始化与一维数组的动态初始化一样，都是先定义后使用。

// 只定义，不使用
int twoDimensional [][];

二、二维数组的运行机制

前面我们说到了 『数组不仅可以储存值，还能储存另外一个完整的数组』但严格来说这句话不对；

其实二维数组并不是直接开辟一个大空间来将里面的数组一个一个进行存放，而是为里面的每一个一维数组单独开辟空间，然后把这个一维数组空间的内存地址储存到二维数组中，作为二维数组的值。

上面的说法有点绕，你可以把二维数组里面的每一个值理解为一个变量，这个变量指向的是一个一维数组

/*
int a[] = {1, 2, 3};
int b[] = {4, 5, 6};
int c[] = {7, 8, 9};

假设 变量 d 是一个二维数组，
而上面变量 abc 都是二维数组的值（因为abc变量指向的都是它对应的数组的内存地址，我们现在就把变量abc看成是其对定数组的内存地址）
d[] = {a, b, c};
*/

三、二维数组的使用

静态使用

// 定义二维数组
int staticTwoDimensional[][] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
// 取出这个二维数组中第2个数组的最后一个元素
int result = staticTwoDimensional[1][staticTwoDimensional[1].length - 1];
System.out.println(result);

// 循环遍历读取二维数组中每个数组的值,且每个数组单独一行输出
for (int count = 0; count < staticTwoDimensional.length; count++) {  // 获取二维数组的最大索引
    System.out.print("{");
    // 获取二维数组的索引对应的一维数组的最大索引
    for (int index = 0; index < staticTwoDimensional[count].length; index++) {
        System.out.print(staticTwoDimensional[count][index] + ", ");
    }
    System.out.println("}");
}

动态使用

动态初始化有两种使用方式，分别是 静态定义一维数组长度与 动态定义一位数组程度

• 静态定义一维数组长度

// 定义二维数组,但先不使用
int diynamicTwoDimensional[][];
// 新建二维数组对象
// 语句解释: 二维数组名称 = new(新建对象) int(每个一位数组要存放的类型) [3](要存放的一维数组的数量) [5](每个一位数组存放的最大元素数量)
diynamicTwoDimensional = new int[3][5];

int num = 1;
// 循环填充元素
// 外层循环作用: 获取二维数组的最大存储值,并循环最大存储值次
for (int count = 0; count < diynamicTwoDimensional.length; count++) {
    // 内层循环作用: 获取二维数组中一维数组的最大元素储存数量,并循环最大储存次,填充元素
    for (int index = 0; index < diynamicTwoDimensional[count].length; index++) {
        diynamicTwoDimensional[count][index] = num;
        num++;
    }
}

填充完后 diynamicTwoDimensional 数组的状态是:

/*
{
	{1, 2, 3, 4, 5},
	{6, 7, 8, 9, 10},
	{11, 12, 13, 14, 15}
}
*/

• 动态定义一维数组长度

在多维数组使用的时候有时候在内层的数组长度不确定就可以使用动态定义长度的方法。如int arr[][] = {{1}, {1, 2}, {1, 2, 3}}

// 声明一个二维数组
int dynamicDimensional = [][];
// 声明这个二维数组能存放的一维数组的数量，但不声明一维数组的长度
dynamicDimensional = new int[3][];

要点:

1. 多维数组第一个不同索引指定的是不同维度的数组，如 二维数组 第一个[] 指定的这个数组能存放的一维数组的数量，第二个[]指定的就是二维数组第几个值里存放的一维数组的索引
2. 与一维数组相似，不过二维数组储存的是一维数组的内存地址。
3. 要操作具体的数组，需要指定这个数组存在的维度的索引，不限于二维数组，包括三维四维......等 维度从高往低依次递减，其结构呈现为树状图。

四、多维数组之间的关系

我们创建一个三位数组，假设三维数组是中国，而三维数组中的每一个值代表一个省份 如索引 0 代表广东，索引 1 代表湖南，2 代表四川...... 然后用一维数组储存这个省份的城市

String array[][][] = {  // 这是三维数组
    {  // 这三维数组的第一个元素, 代表 广东省
        {"深圳", "广州", "佛山", "东莞"}  // 这是一维数组,广东省的城市
    },

    {  // 这三维数组的第二个元素, 代表 湖南省
        {"长沙", "岳阳", "常德", "衡阳"}  // 这是一维数组,湖南省的城市
    },

    {  // 这三维数组的第三个元素, 代表 四川省
        {"成都", "绵阳", "宜宾", "德阳"}  // 这是一维数组,四川省的城市
    }
};

以上数组如果我们要找到德阳市我们就需要先找到德阳市对应的省份 四川省 要找到四川省就得先找到 中国

1. 我们使用了 三维数组的第一个元素代表中国即：array[0]
2. 使用的三维数组的元素的元素表示省份，0广东、1湖南、2四川 即：array[0][2]
3. 使用一维数组储存城市即：array[0][2][3]

这样就找到了德阳。

---

4.3.2 同时定义多个数组

声明二维数组的语句除了前面两种，还可以 int[] 数组名[]

// 同时定义两个一维数组
int[] x, y;
int x[], y[];  // 这两者写法等价 都是定义两个一维数组

// 同定义两个二维数组
// 以下三种写法等价
int[][] x, y;
int x[][], y[][];
int[] x[], y[];

// 同时定义一维数组和二维数组
// 下列写法都是等价的
int[] x[], y;  // x是二维数组，y是一维数组
int[] y，x[];  // 与上面的写法一样
int x[][], y[];

---

4.3.3 二维数组应用题

杨辉三角

// 定义要计算的行数
int line = 5;
// 创建二维数组,并指定二维数组的长度,但不定义一维数组的长度
int yangHuiTriangle[][] = new int[line][];
// 循环单独处理每一行
for (int count = 0; count < line; count++) {
    // 开辟一维数组空间, 每行的长度是count + 1
    yangHuiTriangle[count] = new int[count + 1];
    // 处理一维数组, 也就是每一行需要填充什么值
    for (int index = 0; index < count + 1; index++) {
        // 判断 如果不是行首和行尾 执行计算,否则填充 1
        if (index != 0 && index != count) {
            yangHuiTriangle[count][index] = yangHuiTriangle[count - 1][index] + yangHuiTriangle[count - 1][index - 1];
        } else {
            yangHuiTriangle[count][index] = 1;
        }
    }
}

for (int count = 0; count < yangHuiTriangle.length; count++) {

    // 打印行首的空格
    for (int space = 1; space <= line - (count + 1); space++) {
        System.out.print("  ");
    }


    for (int index = 0; index < yangHuiTriangle[count].length; index++) {
        int result = yangHuiTriangle[count][index];
        // 处理数字后面的空格,
        // ! 但这不是优雅的解决方案, 如果数字多了排版还是会乱,等日后再回来解决吧
        if (result	< 10) {
            System.out.print(result + "   ");
        } else if (result < 100) {
            System.out.print(result + "  ");
        }else{
            System.out.print(result + " ");
        }
    }
    System.out.println();
}

结果：

        1   
      1   1   
    1   2   1   
  1   3   3   1   
1   4   6   4   1   

---

4.3.4 多维数组细节

1. 一维数组的声明方式有两种:
   1. int[] 数组名
   2. int 数组名[]
2. 二维数组的声明方式有三种:
   1. int[][] 数组名
   2. int 数组名[][]
   3. int[] 数组名[]
3. 二维数组实际上是由多个一维数组构成的，它的各个一维数组长度可以相同也可以不同。