Java_二维数组（非常详细）

敲代码的帅哥
431 阅读2分钟

二维数组

1. 基本概念

  • 什么是二维数组：

    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} };
				

1234
  • 关于二维数组的关键概念：
  1. 二维数组的元素个数 = 二维数组中一维数组的个数 = arr.length;
  2. 二维数组的每个元素是一维数组, 所以如果需要得到每个一维数组中的元素，还需要再次遍历；
  3. arr[i][j] =》 二维数组的第 i +1 个一维数组的第 j+1 个元素； eg: arr[0][0] = arr 中的第1个一维数组中的第1个元素。
  • 例子：输出二维数组中的每一个元素
public class TwoDimensionalArray01 { 
	
	public static void main(String[] args) {
		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();//换行 
		} 
	} 
}

1234567891011121314151617

2. 数组初始化

2.1 静态初始化

  • 基本语法：

    • 类型[][] 数组名 = {{值 1,值 2…},{值 1,值 2…},{值 1,值 2…}};
    • 举例：int[][] arr = {{1,1,1}, {8,8,9}, {100}};
    • 注意：二维数组的每个元素必须是一维数组，不允许是其他数据类型；每个一维数组中的元素个数可以相等/不相等。上例中，第一个一维数组有 3 个元素 , 第二个一维数组有 3 个元素, 第三个一维数组只有 1 个元素。

2.2 动态初始化

2.2.1 第一种方式（列数确定）

  • 基本语法：

    • 类型[][] 数组名 = new 类型[大小][大小];
    • 举例: int arr[][] = new int[2][3];
    • 这种初始化方式在声明二维数组的同时开辟了其所需要的堆内存空间；

2.2.2 第二种方式（列数确定）

  • 基本语法：
  1. 先声明：类型[][] 数组名;
  2. 再定义(开辟空间)：数组名 = new 类型[大小][大小];
  3. 然后给一维数组中的元素赋值，若不赋值，则为默认值。

2.2.3 第三种方式（列数不确定）

  • 基本语法：
  1. 先声明：类型[][] 数组名;
  2. 再定义(开辟空间)：数组名 = new 类型[大小][]; 注意：此时一维数组未开辟堆内存空间；
  3. 遍历二维数组，给一维数组开辟堆内存空间，此时开辟的空间可以不相等；也就是列数不确定。
  4. 最后给一维数组中的元素赋值。
  • 代码说明：

	int[][] arr = new int[3][];// 此时一维数组还没有分配内存空间；arr[i]的地址为null；
    for (int i = 0; i < arr.length; i++) {
        arr[i] = new int[i + 1];// 给每个一维数组开辟空间，若没有这一步，一维数组的内存空间就是null；    
    }
    

123456

3. 二维数组的内存存在形式

  • 以动态初始化的第一种方式为例，int arr[][] = new int[2][3];

  • 其内存示意图如下：
    在这里插入图片描述

  • 说明：

    1. 首先在栈内存中声明了一个二维数组类型的变量 arr，在堆内存中为其开辟了一个大小为 2 的地址空间，里面分别存储着一维数组 arr[0]、arr[1] 的地址；
    2. 同时在堆内存中另外开辟了两个新的大小为 3 的内存空间，空间的地址就是 arr[0]、arr[1] 的内存地址，内存里面存储着一维数组中的元素。

  • 注意：如果是以动态初始化（列数不确定）的方式创建二维数组，例如：
    int[][] arr = new int[3][]; 则此时所有的一维数组都没有开辟内存空间，它们的地址都为null；

4. 经典案例：杨辉三角

  • 使用二维数组打印一个 10 行杨辉三角,如下图所示：
    在这里插入图片描述
    规律：

  1. 第一行有 1 个元素, 第 n 行有 n 个元素 ；
  2. 每一行的第一个元素和最后一个元素都是 1 ；
  3. 从第三行开始, 对于非第一个元素和最后一个元素的元素的值 arr[i][j] ，arr[i][j] = arr[i-1][j] + arr[i-1][j-1]。
  • 代码实现：

public class TwoDimentionalArray01 {
    public static void main(String[] args) {
    	int[][] a = new int[10][];
        for (int i = 0; i < a.length; i++) {
            // 给每个一维数组开辟堆内存空间，第n行有n个元素
            a[i] = new int[i + 1];
            // 遍历每一个一维数组，赋值
            for (int j = 0; j < a[i].length; j++) {
                // 每一行的第一个元素和最后一个元素都是1
                if (j == 0 || j == a[i].length - 1) {
                    a[i][j] = 1;
                } else {
                    // 每一行非第一个元素和最后一个元素的值 = 上一行的同一列 + 上一行的上一列
                    a[i][j] = a[i - 1][j] + a[i - 1][j - 1];
                }
            }
        }
        // 输出杨辉三角
        for (int i = 0; i < a.length; i++) {
            for (int k = 0; k < a[i].length; k++) {
                System.out.print(a[i][k] + "\t");
            }
            System.out.println();
        }
    }
}

123456789101112131415161718192021222324252627

5. 二维数组使用细节和注意事项

（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] 是一个含有三个元素的一维数组，因此， map[][] 也称为 “列数不等的二维数组”。

总结

  • 本文是小白博主在学习B站韩顺平老师的Java网课时整理的学习笔记，在这里感谢韩顺平老师的网课，如有有兴趣的小伙伴也可以去看看。
  • 最后，如果本文有什么错漏的地方，欢迎大家批评指正！一起加油！！
avatar
文章
阅读
粉丝