Java基础之：二维数组

声明方式：

int[][] x = {{1},{1,2},{1,2,3}};
int[] x[] = new int[5][]; //通过类似这样的方式声明(new int[5][])，得到一个可动态生成的二维数组
int x[][] = new int[5][5];
//等号后面的方式可以与的等号前面的方式任意组合使用
//但这种方式是不正确的：x[1] = {1};

说明：

二维数组就是，在一个一维数组里面保存的每个元素都是一个一维数组。

二维数组中保存的是一维数组在栈空间的地址，这些一维数组又指向堆空间中的地址。

简单声明案例：

import java.util.Scanner;
public class MultiArray
{
public static void main(String[] args) {
/*
0 0 0 0 0 0
0 0 1 0 0 0
0 2 0 3 0 0
0 0 0 0 0 0
*/

//创建二维数组
int[][] arr = new int[4][6];//默认元素0

/*
int[][] arr;
arr = new int[4][6];
*/

//重新指定值
arr[1][2] = 1;
arr[2][1] = 2;
arr[2][3] = 3;

//遍历二维数组
//说明
//1. arr.length 二维数组中，含有多少个一维数组
for( int i = 0; i < arr.length; i++) {
//2. arr[i].length 返回 arr[i] 一维数组有多少个元素
for( int j = 0; j < arr[i].length; j++) {
//3. arr[i][j] 表示返回 第i个一维数组的第j个元素值
System.out.print(arr[i][j] + "\t");
}
System.out.println();
}
}
}


简单动态生成案例：

import java.util.Scanner;
public class MultiArray2
{
public static void main(String[] args) {


/*生成类似这样的二维数组：

1
2 2
3 3 3
//分析
//1. 二维数组的有 3 个一维数组
//2. 但是每个一维数组的元素个数不同
*/

int[][] arr = new int[10][];
for( int i = 0; i < arr.length; i++) {
//分配空间，一定要注意这里需要i+1！！！
arr[i] = new int[i+1];
//遍历赋值
for( int j = 0; j < arr[i].length; j++) {
arr[i][j] = i+1;
}
}

//输出遍历
for( int i = 0; i < arr.length; i++) {
//2. arr[i].length 返回 arr[i] 一维数组有多少个元素
for( int j = 0; j < arr[i].length; j++) {
//3. arr[i][j] 表示返回 第i个一维数组的第j个元素值
System.out.print(arr[i][j] + "\t");
}
System.out.println();
}
}
}

简单应用案例：

打印杨辉三角

/**

杨辉三角： 打印十行

1

1 1

1 2 1

1 3 3 1

1 4 6 4 1

1 5 10 10 5 1

1. 第一行有 1 个元素, 第 n 行有 n 个元素

2. 每一行的第一个元素和最后一个元素都是 1

3. 中间元素是(上面元素+上面元素的前面元素)，例 3 = 1+2，10 = 4+6，5 = 4+1

思路：

1.每行的元素个数 = 行数 ，由此动态定义二维数组

2.分析中间元素下标 3 = 1 + 2 3的下标为arr[3][1],1的下标为arr[2][0],2的下标为arr[2][1]

3.可以看出 中间元素 arr[i][j] = arr[i-1][j-1] + arr[i-1][j](从第三行开始！)

4.将二维数组依次规律动态赋值即可

*/
import java.util.Scanner;
public class YangHui
{
public static void main(String[] args){
Scanner input = new Scanner(System.in);
System.out.println("请输入要打印的杨辉三角层数：");
int layer = input.nextInt();
int[][] yh = new int[layer][];
System.out.println();

//仔细思考二维数组的动态生成过程，这里不需要担心出现空指针的情况
//首先初始化第一行和第二行 避免下面出现空指针异常
// yh[0] = new int[]{1}; //yh[0] = {1}; 是错误的！！
// yh[1] = new int[]{1,1};

//动态生成二维数组,并赋值
for(int i = 0;i< layer;i++){ //层数，从第三层开始
yh[i] = new int[i+1]; //生成此层的数组
for (int j = 0;j < yh[i].length;j++ ) // 第n层有n个元素
{
if(j == 0 || j == yh[i].length-1){ //第一个和最后一元素
yh[i][j] = 1;
}else{
yh[i][j] = yh[i-1][j-1] + yh[i-1][j];
}
}
}

//遍历二维数组进行打印输出
for(int i = 0;i< layer;i++){
for (int j = 0;j < yh[i].length;j++)
{
System.out.print(yh[i][j]+"\t");
}
System.out.println();
}
}
}

思考题

关于运算顺序的思考题：

import java.util.Scanner;
public class Think
{
public static void main(String[] args){
int i = 3;
do{
if(i--%2 == 0){ //清楚这里的运算顺序
System.out.println(i);
break;
}
System.out.println(i);
}while(i>0);
}
}

//答案 ： 2 1