详析二维数组

二维数组实质是行数个一维数组的拼接

创建二维数组

数据类型[][] 数组名; 
数据类型 数组名[][];

初始化二维数组

//以数据类型为Int型为例
第一种：
int[][] arr = new int[行数][列数];
第二种：
int[][] arr = {{1,2,3},
			   {4,5,6},
			   {7,8,9}};


int[][] arr = new int[3][];//这里数组长度没有,
//null调任何东西都会抛出空指针异常
System.out.println(arr);    //栈内是门牌号，也就是数组名的地址
System.out.println(arr[1][0]);//NullPointerException空指针异常
System.out.println(arr[0]); //null
//动态的为每一个一维数组分配空间
arr[0] = new int[1];
arr[1] = new int[2];
arr[2] = new int[3];

获取二维数组元素值

//二维数组行、列的下标同一维数组一样也是从0开始

//获取单个元素值
arr[0][2];//表示获取二维数组第一行第三列的数据

//遍历打印二维数组
1.第一种方法：使用for i循环，通过拿下标值来遍历数组
for(int i = 0; i < arr.length; i++){//遍历行
	for(int j = 0; j < arr[i].length; j++){//遍历列
		System.out.println(arr[i][j]);
	}
}
2.第二种方法：使用for each循环，遍历数组
   	 *   （1） 外层第一次循环，从数组中获取第0行 赋值给变量
   	 		  内存第一圈循环，从数组中获取第0行所有列的元素值
   	 *   （2） 外层第二次循环，从数组中获取第1行 赋值给变量
   	 		  内存第一圈循环，从数组中获取第1行所有列的元素值
for(int[] row : arr){//拿到每一行
	for(int line : row){//拿到当前行的每一列，其实就是一位数组的遍历
		System.out.println(line);
	}
}

//获取整行元素
int[][] arr = {{1,2,3},
			   {4,5,6},
			   {7,8,9}}
Scanner scanner = new Scanner(System.in);
System.out.println("当前数组只有" + arr.length + "行，请输入你要获取的行号：");
int num = scan.nextInt();//获取从控制台输入的行号
for (int j = 0; j < arr[number - 1].length; j++) {//行号固定，遍历列
	System.out.println("第" + number + "行的第[" + j + "]个元素的值是：" + arr[num - 1][j]);
 }


//获取整列元素
int[][] arr = {{1,2,3},
			   {4,5,6},
			   {7,8,9}}
Scanner scanner = new Scanner(System.in);
System.out.println("当前数组只有" + arr[0].length + "列，请输入你要获取的列号：");
int num = scan.nextInt();//获取从控制台输入的列号
for (int i = 0; i < arr.length; i++) {
    System.out.println("第 "+(i + 1)+"行的第["+ num +"]个元素的值是" + arr[i][num]);
}

求两个矩阵乘积

第一个矩阵的列一定和第二个矩阵的行一样，如一个2x3的矩阵乘以一个3x4的矩阵，会得到一个2x4的矩阵

		int[][] arr1 = {{1,2,3},{4,5,6}};//2*3的矩阵
		int[][] arr2 = {{1,2,3,5},{2,4,6,8},{1,2,3,4}};//3*4的矩阵
		int[][] arr = new int[arr1.length][arr2[0].length];
		//arr1 * arr2 会得到一个 2*4的新矩阵
		for (int i = 0; i < arr1.length; i++) {//arr1的行
			for (int j = 0; j < arr1[i].length; j++) {//arr1的列
				for(int k = 0; k < arr2[i].length; k++) {
					arr[i][k] = arr[i][k] + arr1[i][j] * arr2[j][k];
				}	
			}
		}
		for(int i = 0; i < arr.length; i++){//遍历行
			for(int j = 0; j < arr[i].length; j++){//遍历列
				System.out.println(arr[i][j]);
			}
		}

求矩阵行之和

		int[][] arr = {{1,2,3,5},{2,4,6,8},{1,2,3,4}};//3*4的矩阵
		for(int i = 0; i < arr.length; i++) {
			int sum = 0;
			for(int j = 0; j < arr[i].length; j++) {
				sum = sum + arr[i][j];
			}
			System.out.println("第" + (i + 1) + "行的和为" + sum);
		}

求矩阵列之和（只适合n * n 矩阵）

		int[][] arr = {{1,2,3,4},{2,4,6,8},{1,2,3,4}};//3*4的矩阵
		for(int i = 0; i < arr[0].length; i++) {
			int sum = 0;
			for(int j = 0; j < arr.length; j++) {
				sum = sum + arr[j][i];
			}
			System.out.println("第" + (i + 1) + "列的和为" + sum);
		}

求主对角形之和（只适合n * n 矩阵）

		int[][] arr = {{1,2,3,4},{2,4,6,8},{1,2,3,4},{1,2,3,4}};//3*4的矩阵
		int sum = 0;
		for(int i = 0; i < arr.length; i++) {
		for(int j = 0; j < arr[i].length; j++) {
			if(i == j) {
				sum = sum + arr[i][j];
			}		   
		}
	}
		System.out.println(sum);

求副对角形之和（只适合n * n 矩阵）

		int[][] arr = {{1,2,3,4},{2,4,6,8},{1,2,3,4},{1,2,3,4}};//3*4的矩阵
		int sum = 0;
		for(int i = 0; i < arr.length; i++) {
		for(int j = 0; j < arr[i].length; j++) {
			if(i + j == arr.length) {
				sum = sum + arr[i][j];
			}		   
		}
	}
		System.out.println(sum);

二维数组实现开关游戏

从控制台输入一个位置，那么这个位置及其上下左右位置都变成它相反的数字(0或者1)

package demo;

import java.util.Scanner;

/**
 * 开关游戏
 *  两个想法： 
 *  1.不创建新数组，但需要限制执行条件，最后打印原数组
 *  2.创建一个比旧数组大一周的新数组，不需要限制执行条件，但是需要调整控制台输入的行列号，最后截取打印新数组
 * @author Amid
 *
 */
public class Test_06 {
	static Scanner scanner = new Scanner(System.in);

	public static void main(String[] args) {
		int[][] arr = new int[5][5];
		int[][] arrNew = new int[arr.length + 2][arr[0].length + 2];
		while (true) {
			System.out.println("请输入行");
			int num1 = scanner.nextInt();
			System.out.println("请输入列");
			int num2 = scanner.nextInt();
			if ((!(num1 >= 0 && num1 < arr.length)) || (!(num2 >= 0 && num1 < arr[0].length))) {
				System.out.println("你输入的位置不正确，请重新输入");
				continue;
			}
			//openAndClose1(arr, num1, num2);
			openAndClose2(arrNew, num1, num2);
		}

	}

	/*
	 * 1. 不创建新数组，但需要限制进入条件，最后打印原数组
	 */
	static void openAndClose1(int[][] arr, int num1, int num2) {
		// 当前位置,所有都能进
		if (arr[num1][num2] == 0) {
			arr[num1][num2] = 1;
		} else {
			arr[num1][num2] = 0;
		}

		// 上 ,最上一排不能进
		if (!(num1 == 0)) {
			if (arr[num1 - 1][num2] == 0) {
				arr[num1 - 1][num2] = 1;
			} else {
				arr[num1 - 1][num2] = 0;
			}
		}

		// 下 ,最下一排不能进
		if (!(num1 == arr.length - 1)) {
			if (arr[num1 + 1][num2] == 0) {
				arr[num1 + 1][num2] = 1;
			} else {
				arr[num1 + 1][num2] = 0;
			}
		}

		// 左 ,最左一列不能进
		if (!(num2 == 0)) {
			if (arr[num1][num2 - 1] == 0) {
				arr[num1][num2 - 1] = 1;
			} else {
				arr[num1][num2 - 1] = 0;
			}
		}

		// 右 ,最右一列不能进
		if (!(num2 == arr[0].length - 1)) {
			if (arr[num1][num2 + 1] == 0) {
				arr[num1][num2 + 1] = 1;
			} else {
				arr[num1][num2 + 1] = 0;
			}
		}

		// 遍历打印二维数组
		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();
		}

	}

	/*
	 * 2. 创建一个比旧数组大一周的新数组，不需要限制进入条件，但是需要调整控制台输入的行列号，最后截取打印新数组
	 */
	static void openAndClose2(int[][] arrNew, int num1, int num2) {
	
		// 原数组的当前位置
		if (arrNew[num1 + 1][num2 + 1] == 0) {
			arrNew[num1 + 1][num2 + 1] = 1;
		} else {
			arrNew[num1 + 1][num2 + 1] = 0;
		}

		// 上

		if (arrNew[num1 + 1 - 1][num2 + 1] == 0) {
			arrNew[num1 + 1 - 1][num2 + 1] = 1;
		} else {
			arrNew[num1 + 1 - 1][num2 + 1] = 0;
		}

		// 下

		if (arrNew[num1 + 1 + 1][num2 + 1] == 0) {
			arrNew[num1 + 1 + 1][num2 + 1] = 1;
		} else {
			arrNew[num1 + 1 + 1][num2 + 1] = 0;
		}

		// 左

		if (arrNew[num1 + 1][num2 + 1 - 1] == 0) {
			arrNew[num1 + 1][num2 + 1 - 1] = 1;
		} else {
			arrNew[num1 + 1][num2 + 1 - 1] = 0;
		}

		// 右

		if (arrNew[num1 + 1][num2 + 1 + 1] == 0) {
			arrNew[num1 + 1][num2 + 1 + 1] = 1;
		} else {
			arrNew[num1 + 1][num2 + 1 + 1] = 0;
		}

		// 遍历打印二维数组
		for (int i = 1; i < arrNew.length - 1; i++) {
			for (int j = 1; j < arrNew[i].length - 1; j++) {
				System.out.print(arrNew[i][j] + " ");
			}
			System.out.println();
		}
	}

}