Java 二维数组创建及使用方式

目录

• 二维数组的创建
• 二维数组基本使用
• 1. 二维数组的使用
• 2. 使用方式 1: 动态初始化
• 3. 使用方式 2: 动态初始化
• 4. 使用方式 3: 动态初始化-列数不确
• 5. 使用方式 4: 静态初始化
• 6. 二维数组的应用案例
• 7. 二维数组使用细节和注意事项
• 8. 二维数组课堂练习

二维数组的创建

二维数组好比一个表格，第一个下标表示行，第二个下标表示列，数组的创建和初始化与一位数组一模一样，及二维数组就是一个把多个一维数组包起来的数组。

数组的创建：

type[][] arrayName;或者 type arrayName[][];

数组的初始化：

给数组分配空间大小，不能被修改，在赋值。

type[][] arrayName=new type[length1][length2]

通过new给数组赋值，不给空间大小。

type[][] arrayName=new type[][]{{值1,值2,值3},{值1,值2,值3}};

直接给数组赋值，空间大小不分配。

type[][] arrayName={{值1,值2,值3},{值1,值2,值3}};

数组的二维长度为空。

type[][] arrayName=new type[length1][];

数组元素的获取：

二维数组要通过两个下标来获取，例如：arrayName[0][0] 获取最前面的元素值，arrayName[arrayName.length-1][arrayName[arrayName.length-1].length-1] 取出数组的最后一个元素。

例1：给定一个3行3列的二维数组，并初始化赋值，每行输出三个就换行。

public class dome2{
     public static void main(String[] args) {
       int[][] a= {{1,6,5},{7,3,0},{1,5,7}};
       
       for(int i=0;i<a.length;i++) {  //二维数组的行循环
           
           for(int j=0;j<a[i].length;j++) {  //二维数组的列循环
               
              System.out.print(a[i][j]+" ");  //输出每个元素
              
               if(a[i][2]==a[i][j]) {  //当每一行输出三列后换行
                   
                   System.out.println();
                   
               }
           }
       }
    }
}

结果
1 6 5
7 3 0
1 5 7

例2： 循环输入3行3列的二维数组，并将它顺时针旋转90°输出三行三列。

import java.util.Scanner;

public class dome2{
     public static void main(String[] args) {
       int[][] a=new int[3][3];
       Scanner sc=new Scanner(System.in);
       //循环输入
       for(int i=0;i<a.length;i++) {
           for(int j=0;j<a[i].length;j++) {
               a[i][j]=sc.nextInt();
           }
       }
       //每行3个换行
      for(int i=0;i<a.length;i++) {
          for(int j=0;j<a[i].length;j++) {
              System.out.print(a[i][j]+" ");
              if(a[i][2]==a[i][j]) {
                  System.out.println();
              }
          }
      }
      //创建新的数组并且旋转赋值
      int[][] b=new int[3][3];
      for(int i=0;i<3;i++) {
          for(int j=0;j<3;j++) {
              b[j][2-i]=a[i][j];
          }
      }
      //循环输出
     for(int i=0;i<b.length;i++) {
          for(int j=0;j<b[i].length;j++) {
              System.out.print(b[i][j]+" ");
              if(b[i][2]==b[i][j]) {
                  System.out.println();
              }
          }
      }
    }
}

结果
1 2 3 4 5 6 7 8 9
1 2 3
4 5 6
7 8 9
旋转后的结果
7 4 1
8 5 2
9 6 3

二维数组基本使用

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

1. 二维数组的使用

• 快速入门案例：TwoDimensionalArray01.java
• 请用二维数组输出如下图形

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} };
	//输出二维图形
	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();//换行
	}

• 举例：访问二位数组中值为 3 的数组坐标

	//关于二维数组的关键概念
	//(1)
	System.out.println("二维数组的元素个数=" + arr.length);
	//(2) 二维数组的每个元素是一维数组, 所以如果需要得到每个一维数组的值
	//    还需要再次遍历
	//(3) 如果我们要访问第 (i+1)个一维数组的第j+1个值 arr[i][j];
	//    举例 访问 3, =》 它是第3个一维数组的第4个值 arr[3-1][4-1] = arr[2][3]
	System.out.println("第3个一维数组的第4个值=" + arr[2][3]); //3

• 3的值在二维数组里对应的第3行第4列的值，3对应的坐标本来是 arr[3][4]，但数组是从0开始的，所以减1，就是arr[2][3]，所以 3 对应的实际坐标就是arr[2][3]

2. 使用方式 1: 动态初始化

TwoDimensionalArray02.java

1.语法: 类型[][] 数组名=new 类型[大小][大小]

2.比如: int a[][]=new int[2][3]，表示这个二位数组里面有两个一维数组，而每个一维数组里有三个元素

3.使用演示

• 没有赋值，默认值为 0

	int arr[][] = new int[2][3];
	//遍历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();//换行
	}

• 把上面的数组进行初始化赋值，arr[1][1] = 8 表示 在第二个一维数组的第二个元素的值为 8

	int 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();//换行
	}

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

3. 使用方式 2: 动态初始化

TwoDimensionalArray02.java

• 先声明：类型 数组名[][];
• 再定义(开辟空间) 数组名 = new 类型[大小][大小];
• 赋值(有默认值，比如 int 类型的就是 0)
• 使用演示

int arr[][]; //声明二维数组
arr = new int[2][3]; //再开空间

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

TwoDimensionalArray03

代码实现：

	/*
	看一个需求：动态创建下面二维数组，并输出

	i = 0:	1
	i = 1:	2	2
	i = 2:	3	3	3

	一个有三个一维数组, 每个一维数组的元素是不一样的
	*/

	//创建 二维数组，一个有3个一维数组，但是每个一维数组还没有开数据空间
	int[][] arr = new int[3][];

	for(int i = 0; i < arr.length; i++) {//遍历arr每个一维数组
	    //给每个一维数组开空间 new
	    //如果没有给一维数组 new ,那么 arr[i]就是null
	    arr[i] = new int[i + 1];

	    //遍历一维数组，并给一维数组的每个元素赋值
	    for(int j = 0;  j < arr[i].length; j++) {
	        arr[i][j] = i + 1;//赋值
	    }

	}

	System.out.println("=====arr元素=====");
	//遍历arr输出
	for(int i = 0; i < arr.length; i++) {
	    //输出arr的每个一维数组
	    for(int j = 0; j < arr[i].length; j++) {
	        System.out.print(arr[i][j] + " ");
	    }
	    System.out.println();//换行
	}

5. 使用方式 4: 静态初始化

TwoDimensionalArray04.java

• 定义 类型 数组名[][] = {{值 1,值 2..},{值 1,值 2..},{值 1,值 2..}}
• 使用即可 [ 固定方式访问 ]
• 比如:

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

• 解读

1.定义了一个二维数组 arr

2.arr 有三个元素(每个元素都是一维数组)

3.第一个一维数组有 3 个元素 , 第二个一维数组有 3 个元素, 第三个一维数组有 1 个元素

• 案例：

TwoDimensionalArray05.java

int arr[][]={{4,6},{1,4,5,7},{-2}}; 遍历该二维数组，并得到和

	/*
	思路
	1. 遍历二维数组，并将各个值累计到 int sum
	*/
	int arr[][]= {{4,6},{1,4,5,7},{-2}};
	int sum = 0;
	for(int i = 0; i < arr.length; i++) {
	    //遍历每个一维数组
	    for(int j = 0; j < arr[i].length; j++) {
	        sum += arr[i][j];
	    }
	}
	System.out.println("sum=" + sum);

6. 二维数组的应用案例

使用二维数组打印一个 10 行杨辉三角 YangHui.java

	int[][] yangHui = new int[12][];
	for(int i = 0; i < yangHui.length; i++) {//遍历yangHui的每个元素

		//给每个一维数组(行) 开空间
		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();//换行.
	}

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

一维数组的声明方式有:

int[] x 或者 int x[]

二维数组的声明方式有:

int[][] y 或者 int[] y[] 或者 int y[][]

二维数组实际上是由多个一维数组组成的，它的各个一维数组的长度可以相同，也可以不相同。比如： map[][] 是一个二维数组

int map [][] = {{1,2},{3,4,5}}

由 map[0] 是一个含有两个元素的一维数组 ，map[1] 是一个含有三个元素的一维数组构成，我们也称为列数不等的二维数组

8. 二维数组课堂练习

以上为个人经验，希望能给大家一个参考，也希望大家多多支持我们。