Java基础语法十一（多维数组）

多维数组

二维数组：实质上就是存储一维数组

数组定义：数组类型[][]  数组名 = new  数组类型[一维数组的个数][每一个一维数组中元素的个数];

使用一维数组打印一个10行杨辉三角

public class Test6 {

	public static void main(String[] args) {
		// 杨辉三角
		int[][] arr = new int[4][7];

		for (int i = 0; i < arr.length; i++) {
//			int begin = 3 - i;
			for (int k = 0; k < 2 * i + 1; k++) {
				arr[i][3 - i + k] = 1;
			}
		}

		for (int i = 0; i < arr.length; i++) {
			for (int k = 0; k < arr[i].length; k++) {
//				System.out.print(arr[i][k] + "\t");
				if (arr[i][k] == 0) {
					System.out.print(" ");
				} else {
					System.out.print("*");
				}
			}
			System.out.println();
		}
	}

稀疏数组

稀疏数组可以看做是普通数组的压缩，但是这里说的普通数组是指无效数据量远大于有效数据量的数组。

稀疏数组有很多的所有场景，比如五子棋（思路：单数为黑棋，双数为白棋；数字从小到大可记录下棋顺序），棋盘很大，但是一盘下完后，大部分的位置都是没有棋子的。这是可以使用稀疏数组存储，使用时也可以还原成初始的二维数组

实现思路

        1、记录数组一共有几行几列，有多少个不同的值

        2、把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序规模

编码实现

创建一个二维数组11*11，值0表示没有棋子，1表示黑棋，2表示白棋

int[][] arr = new int[18][18];

		arr[3][3] = 1;
		arr[4][4] = 2;
		arr[3][4] = 1;
		arr[3][5] = 2;

		int[][] res = xiShu(arr);
		for (int i = 0; i < res.length; i++) {
			for (int k = 0; k < res[i].length; k++) {
				System.out.print(res[i][k] + " ");
			}
			System.out.println();
		}

转化为稀疏数组，首先获取有效值的个数，再遍历二维数组，将非0的值存放到稀疏数组

// 将原始数组转换为稀疏数组
	public static int[][] xiShu(int[][] source) {
		int sum = 0;
		for (int i = 0; i < source.length; i++) {
			for (int k = 0; k < source[i].length; k++) {
				if (source[i][k] != 0) {
					sum++;
				}
			}
		}
		int[][] res = new int[sum + 1][3];
		res[0][0] = 18;// 行数
		res[0][1] = 18;// 列数
		res[0][2] = sum;// 数据

		int count = 0;
		for (int i = 0; i < source.length; i++) {
			for (int k = 0; k < source[i].length; k++) {
				if (source[i][k] != 0) {
					count++;
					res[count][0] = i;
					res[count][1] = k;
					res[count][2] = source[i][k];
				}
			}
		}
		return res;
	}

读取稀疏数组还原数组的值

        arr = huan(res);
		for (int i = 0; i < arr.length; i++) {
			for (int k = 0; k < arr[i].length; k++) {
				System.out.print(arr[i][k] + " ");
			}
			System.out.println();
		}
// 读取稀疏数组还原数组的值
	public static int[][] huan(int[][] xi) {
		int[][] res = new int[xi[0][0]][xi[0][1]];
		for (int i = 1; i < xi.length; i++) {
			res[xi[i][0]][xi[i][1]] = xi[i][2];
		}
		return res;
	}

练习题：

猜数字游戏。存取5个随机的1-20之间的数据

import java.util.Arrays;
import java.util.Scanner;

public class Test1 {

	public static void main(String[] args) {
		// 1、猜数字游戏。存取5个随机的1~20之间的数据
		int[] arr = new int[5];
		for (int i = 0; i < arr.length; i++) {
			int tmp = (int) (Math.random() * 21);
			if (exists(arr, tmp)) {
				i--;
			} else {
				arr[i] = tmp;
			}
		}
//		Arrays.sort(arr);
		System.out.println(Arrays.toString(arr));

		int target = -1;
		Scanner sc = new Scanner(System.in);
		while (true) {
			System.out.println("请输入猜的值：");
			target = sc.nextInt();
			boolean bb = exists(arr, target);
			if (bb) {
				System.out.println("猜对了！");
				break;
			} else {
				System.out.println("请继续努力！");
			}
		}
		sc.close();
	}

	public static boolean exists(int[] arr, int target) {
		if (target < 1 || target > 20) {
			return false;
		}
		boolean res = false;
		for (int tmp : arr) {
			if (tmp == target) {
				res = true;
				break;
			}
		}
		return res;
	}
}

有一个整数数组，其中存放这序列1、3、5、7、11、13、15、17、19，请将该序列倒序存放并输出

public class Test2 {

	public static void main(String[] args) {
		// 2、有一个整数数组，其中存放着序列1、3、5、7、11、13、15、17、19，请将该序列倒序存放并输出
		int[] arr = new int[] { 1, 3, 5, 7, 11, 13, 15, 17, 19 };
		arr = reverse(arr);
		for (int tmp : arr) {
			System.out.print(tmp + "\t");
		}
//		System.out.println(Arrays.toString(arr));
	}

	public static int[] reverse(int[] arr) {
		for (int i = 0; i < arr.length / 2; i++) {
			int tmp = arr[i];
			arr[i] = arr[arr.length - 1 - i];
			arr[arr.length - 1 - i] = tmp;
		}
		return arr;
	}

//	public static void reverse(int[] arr) {
//		for (int i = 0; i < arr.length / 2; i++) {
//			int tmp = arr[i];
//			arr[i] = arr[arr.length - 1 - i];
//			arr[arr.length - 1 - i] = tmp;
//		}
//	}
}

编写一个程序，提示用户输入学生数量后，再依次输入姓名和成绩，按照成绩的降序来打印学生的姓名

import java.util.Scanner;

public class Test3 {

	public static void main(String[] args) {
		// 3、编写一个程序，提示用户输入学生数量后，再依次输入姓名和成绩，按照成绩的降序来打印学生的姓名 姓名要求5个字符串以上 成绩0到100
		// nextLine()读一行内容，碰到回车结束
		System.out.println("输入学生数量：");
		Scanner sc = new Scanner(System.in);
		int len = sc.nextInt();
		String[] names = new String[len];
		int[] scores = new int[len];
		for (int i = 0; i < names.length; i++) {
			names[i] = inputName(sc);
			scores[i] = inputScore(sc);
		}
		sort(names, scores);
		for (int i = 0; i < names.length; i++) {
			System.out.println("第 " + (i + 1) + " 名学生 " + names[i] + " ,成绩为 " + scores[i]);
		}
	}

	public static String inputName(Scanner sc) {
		System.out.println("姓名：");
		String tmp = "";
		while (true) {
			tmp = sc.next();
			if (tmp.length() > 20 || tmp.length() < 4) {
				System.out.println("输入的数据不合法！请重新输入");
			} else {
				break;
			}
		}
		return tmp;
	}

	public static int inputScore(Scanner sc) {
		System.out.println("成绩：");
		int tmp = 0;
		while (true) {
			tmp = sc.nextInt();
			if (tmp > 100 || tmp < 0) {
				System.out.println("输入的数据不合法！请重新输入");
			} else {
				break;
			}
		}
		return tmp;
	}

	public static void sort(String[] names, int[] scores) {
		for (int k = 1; k < names.length; k++) {
			for (int i = 0; i < names.length - k; i++) {
				if (scores[i] < scores[i + 1]) {
					int tmp = scores[i];
					scores[i] = scores[i + 1];
					scores[i + 1] = tmp;

					String stmp = names[i];
					names[i] = names[i + 1];
					names[i + 1] = stmp;
				}
			}
		}
	}

}

编写一个程序，能够读入10个整数，并且存储其中互不相同的数，最后将这10个数输出

import java.util.Arrays;
import java.util.Scanner;

public class Test4 {
	public static void main(String[] args) {
		// 4、编写一个程序，能够读入10个整数，并且存储其中互不相同的数，最后将这10个数输出
		Scanner sc = new Scanner(System.in);
		int[] arr = new int[10];
		String ss = "";
		for (int i = 0; i < arr.length; i++) {
			arr[i] = sc.nextInt();
		}
		for (int tmp : arr) {
			if (ss.indexOf("" + tmp) < 0) {
				ss += tmp + ",";
			}
		}
		System.out.println(Arrays.toString(arr));
		ss = ss.substring(0, ss.length() - 1);
		System.out.println(ss);
		sc.close();
	}
}