基本概念 

由一维数组组成的数组

二维数组的每个元素都是一个一维数组(第二维度)————绝大部分应用场景里，二位数组的“第二维度”的数组长度是相同的

语法格式

Int[][] 数组名称 = new int[行数][列数]；

Int[][] arr = new int[2][3];

初始化了一个长度为2的一维数组，且元素都是数组；

每个元素数组的长度都是3；

二行三列的数据类型为int的二维数组；

arr.length 代表二位数组的大小/元素个数/一维数组的个数，行数；

arr[0].length 代表二维数组第一个元素/一维数组的大小，列数。

int[][] arr = new int[3][];

由于二维数组的本质仍是一个一维数组，所以初始化时也是在初始化一维数组，那么，当不确定“第二维度”的数组元素数量时，在赋值符号右侧，创建数组对象的第二个中括号中可以留空。但是在使用此二维数组前必须对第二维度的数组（留空的括号）进行初始化。不然会出现空指针异常————NullPointerException

int[][] arr = new int[4][];

arr[0] = new int[3];//初始化“第二维度”的一维数组

arr[0][0] = 1;

arr[0][1] = 2;

arr[0][2] = 3;

arr[1] = new int[2];

相当于：

创建了一个名为arr的一维数组 长度为4

arr的第一个元素为数组，长度为3

这个数组没有名字 只能通过arr[0]来表示

此数组的三个元素分别是1，2，3

arr的第二个元素为数组，长度为2

这个数组没有名字，只能通过arr[1]来表示

此数组的2个元素都为0

arr数组的其他元素的值都为null

初始化

int[][] arr = { { 初始值1，初始值2…}，{初始值1，初始值2…}，{…. }};

包含初始值的大括号数为行

单个大括号内初始值数位列

===============================================

字符串[] arr = new 字符串[]

数组中的每一个元素都可以看成字符串类型的变量，因此使用字符串对象来初始化

new 字符串();

遍历

使用嵌套循环 先遍历“第一维度”，然后在内层循环遍历“第二维度”

内外层循环语法不要求统一

一般内外层循环都使用for循环（循环次数确定）

int[][] arr = new int[2][3];

for(int i = 0 ; i < arr.length ; i++){

    for(int j = 0 ; j < arr[i].length ; j++){

        System.out.println(arr[i][j]);

    }

}

准备

现有一个一维数组：{1,2,3,4,5,6,7,8,9}
转为 3*3 的二维数组：
	{
       1,2,3
       4,5,6
       7,8,9
    }

我们不难看出：

一维数组第1个元素在数组中为 arr[0][0],
一维数组第3个元素在数组中为 arr[0][2],
一维数组第4个元素在数组中为 arr[1][0],
由于第(n+1)个元素下标为n，为此我们可以得出结论:
一维数组的第n个元素，在二维数组中表示为：arr[n / col][n % col]

题目引入

引用LeetCode的第566题，题意如下：

在 MATLAB 中，有一个非常有用的函数 reshape ，它可以将一个 m x n 矩阵重塑为另一个大小不同（r x c）的新矩阵，但保留其原始数据。
给你一个由二维数组 mat 表示的 m x n 矩阵，以及两个正整数 r 和 c ，分别表示想要的重构的矩阵的行数和列数。
重构后的矩阵需要将原始矩阵的所有元素以相同的 行遍历顺序 填充。
如果具有给定参数的 reshape 操作是可行且合理的，则输出新的重塑矩阵；否则，输出原始矩阵。

代码实现：

class Solution {
    public int[][] matrixReshape(int[][] mat, int r, int c) {
         // 安全性校验
        int m = mat.length;
        int n = mat[0].length;
        // row*col不等于传递过来的数，不能组成新的维度数组
        if ((m * n) != (r * c)) {
            return mat;
        }
        // 程序走到这里，表明能组成新的维度数组
        // 创建一个新的二维数组
        int res[][] = new int[r][c];
        // 遍历旧的二维数组
        for (int i = 0; i < m * n; i++) {
            // 由以上公式，我们可以推导出:
            res[i / c][i % c] = mat[i / n][i % n];
        }

        return res;
    }
}

代码实现二：

1、先将旧的二维数组转为一维数组;
2、再将一维数组转为按照规则实现的二维数组

public int[][] matrixReshape(int[][] mat, int r, int c) {
     // 二维数组的行数
     int n = mat.length;
     // 二维数组的列数
     int m = mat[0].length;
     if ((n * m) != (r * c)) {
         return mat;
     }
     int arr[] = new int[n * m];
     int index = 0;
     // 将二维数组转为一维数组
     for (int i = 0; i < n; i++) {
         for (int j = 0; j < m; j++) {
             arr[index++] = mat[i][j];
         }
     }
    // 将一维数组转变为二维数组
     int res[][] = new int[r][c];
     index = 0;
     for (int i = 0; i < r; i++) {
         for (int j = 0; j < c; j++) {
             res[i][j] = arr[index++];
         }
     }
     return res;
 }

二维数组的长度

package ArrayTest;

public class Array3 {
    public static void main(String[] args) {
        //write your code here
        int[][] A = new int[][]{{1, 1, 2}, {4, 5}, {7, 8, 10, 11, 12}, {}, {1}};
        System.out.println("A.length = " + A.length);//5,表示数组的行数
        System.out.println("A[0].length = " + A[0].length);//3,表示对应行的长度
        System.out.println("A[1].length = " + A[1].length);//2
        System.out.println("A[2]A.length = " + A[2].length);//5
        System.out.println("A[3]A.length = " + A[3].length);//0
        System.out.println("A[4]A.length = " + A[4].length);//1
        //System.out.println("A[5]A.length = " + A[5].length);//角标越界
        System.out.println("A[0][0] = " + A[0][0]);

    }
}

定义二维数组，赋值

package ArrayTest;

public class Array3_1 {
    public static void main(String[] args) {
        //定义一个整型数组:3行4列
        int a[][] = new int[3][4];
        //获取行数---3行
        int lenY = a.length;
        System.out.println("lenY = " + lenY);
        //获取列数---4列
        int lenX = a[0].length;
        System.out.println("lenX = " + lenX);

        // 其实很好理解，因为二维数组可以理解为是一维数组，只不过他的各处的元素是特殊元素—–一维数组
        System.out.println("a[0][0] = " + a[0][0]);
        System.out.println("a = " + a);
        a = null;
        System.out.println("a = " + a);
        //System.out.println(a[0][0]);报错
        System.out.println("");


        int[][] arr = new int[3][4];//定义一个二维数组
        int sum = 0;//记录长度
        for (int i = 0; i < arr.length; i++) {//获取行的长度
            for (int j = 0; j < arr[i].length; j++) {//获取列的长度
                arr[i][j] = j;
                System.out.println("arr[" + i + "][" + j + "] = " + arr[i][j]);
                sum++;//长度+1
            }
        }
        System.out.println("sum = " + sum);//输出长度
    }
}