关于二维数组

二维数组

• 二维数组：本质上就是元素为一维数组的一个数组。

• 二维数组的标记：[][]

int[][] arr; //arr是一个二维数组，可以看成元素是int[]一维数组类型的一个数组

二维数组也可以看成一个二维表，行*列组成的二维表，只不过这个二维表，每一行的列数还可能不同。但是每一个单元格中的元素的数据类型是一致的，例如：都是int，都是String等

二维数组的声明与初始化

语法格式：

//推荐
元素的数据类型[][] 二维数组的名称;

//不推荐
元素的数据类型  二维数组名[][];
//不推荐
元素的数据类型[]  二维数组名[];

int[x][y];
//x是一维数组，y是二维数组

静态初始化

元素的数据类型[][] 二维数组名 = new 元素的数据类型[][]{
			{元素1，元素2，元素3 。。。}, 
			{第二行的值列表},
			...
			{第n行的值列表}
		};

元素的数据类型[][] 二维数组名;
二维数组名 = new 元素的数据类型[][]{
			{元素1，元素2，元素3 。。。}, 
			{第二行的值列表},
			...
			{第n行的值列表}
		};
		
//以下格式要求声明与静态初始化必须一起完成
元素的数据类型[][] 二维数组的名称 = {
			{元素1，元素2，元素3 。。。}, 
			{第二行的值列表},
			...
			{第n行的值列表}
		};
举例：
    
class	Hello{
	public static void main(String[]args){
		int[][] nums = new int[][]{
			{1,2,3},
			{4,5,6},
			{7,8,9}
		};
		int [][] numx;
		numx = new int[][]{
			{1,2,3},
			{3,4,5},
			{6,7,8}
		};
		
		int  [][]numz = {{1,2,3},{4,5,6},{7,8,9}};
		//不规则的二维数组
		int[][] arrs = new int[3][];
		arrs[0] = new int[1];//一个单元
		arrs[1] = new int[2];//两个单元
		arrs[2] = new int[3];//三个单元
	}
}

如果是静态初始化，右边new 数据类型[][]中不能写数字，因为行数和列数，由{}的元素个数决定

举例：

	int[][] arr;
	arr = new int[][]{{1,2,3},{4,5,6},{7,8,9}};
	arr = new int[3][3]{{1,2,3},{4,5,6},{7,8,9}};//错误，静态初始化右边new 数据类型[]中不能写数字

	int[][] arr = new int[][]{{1,2,3},{4,5,6},{7,8,9}};

	int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};//声明与初始化必须在一句完成

public class Array2Demo1 {
	public static void main(String[] args) {
		//定义数组
		int[][] arr = {{1,2,3},{4,5},{6}};
		
		System.out.println(arr);
		System.out.println(arr[0]);
		System.out.println(arr[1]);
		System.out.println(arr[2]);
		
		System.out.println(arr[0][0]); //1
		System.out.println(arr[1][0]); //4
		System.out.println(arr[2][0]); //6
		
		System.out.println(arr[0][1]); //2
		System.out.println(arr[1][1]); //5
		//越界
		System.out.println(arr[2][1]); //错误
	}
}

动态初始化（规则二维表：每一行的列数是相同的）

//（1）确定行数和列数
元素的数据类型[][] 二维数组名 = new 元素的数据类型[m][n];
	m:表示这个二维数组有多少个一维数组。或者说一共二维表有几行
	n:表示每一个一维数组的元素有多少个。或者说每一行共有一个单元格

//此时创建完数组，行数、列数确定，而且元素也都有默认值

//（2）再为元素赋新值
二维数组名[行下标][列下标] = 值;

public static void main(String[] args) {
    //定义一个二维数组
    int[][] arr = new int[3][2];
    
    //定义了一个二维数组arr
    //这个二维数组有3个一维数组的元素
    //每一个一维数组有2个元素
    //输出二维数组名称
    System.out.println(arr); //地址值	[[I@175078b
    
    //输出二维数组的第一个元素一维数组的名称
    System.out.println(arr[0]); //地址值	[I@42552c
    System.out.println(arr[1]); //地址值	[I@e5bbd6
    System.out.println(arr[2]); //地址值	[I@8ee016
    
    //输出二维数组的元素
    System.out.println(arr[0][0]); //0
    System.out.println(arr[0][1]); //0
    
    //...
}	 

动态初始化（不规则：每一行的列数可能不一样）

//（1）先确定总行数
元素的数据类型[][] 二维数组名 = new 元素的数据类型[总行数][];

//此时只是确定了总行数，每一行里面现在是null

//（2）再确定每一行的列数，创建每一行的一维数组
二维数组名[行下标] = new 元素的数据类型[该行的总列数];

//此时已经new完的行的元素就有默认值了，没有new的行还是null

//(3)再为元素赋值
二维数组名[行下标][列下标] = 值;

	public static void main(String[] args) {
		//定义数组
		int[][] arr = new int[3][];
        
        System.out.println(arr);	//[[I@175078b
        
        System.out.println(arr[1][0]);//NullPointerException
		System.out.println(arr[0]); //null
		System.out.println(arr[1]); //null
		System.out.println(arr[2]); //null
		
		//动态的为每一个一维数组分配空间
		arr[0] = new int[2];//arr[0]有两个索引
		arr[1] = new int[3];//arr[1]有三个索引
		arr[2] = new int[1];//arr[2]有一个索引
		
        //打印出为地址
		System.out.println(arr[0]); //[I@42552c
		System.out.println(arr[1]); //[I@e5bbd6
		System.out.println(arr[2]); //[I@8ee016
		
		System.out.println(arr[0][0]); //0
		System.out.println(arr[0][1]); //0
		//ArrayIndexOutOfBoundsException
		//System.out.println(arr[0][2]); //错误
		
		arr[1][0] = 100;
		arr[1][2] = 200;
	}

二维数组理解如：

public class Demo09 { 
    public static void main(String[] args) {
        /**
         * 二维数组：定义一个数组，数组中的每个元素均为一个数组  
         * 以arr数组为例：  此处定义了一个二维数组arr[4]，其中有四个元素，即有四个数组arr[0]arr[1]arr[2]arr[3]
         * 理解：此时arr[0]arr[1]arr[2]arr[3]各自为一个数组，但对于arr来说，都属于arr数组当中的元素
         * 此处我们将称为arr[0]arr[1]arr[2]arr[3]二维组,每个二维组当中有两个元素。
         * 而多维数组的含义即可解释为：
         * inr[][][]  arrs = new int
         * 当我们需要索引每个二维组当中的元素时，分别表示为（此处以arr[0]示例）：
         * arr[0][0] = 1;    arr[0][1] = 2;
         * [4][2]
         * 1,2   arr[0]
         * 2,3   arr[1]
         * 3,4   arr[2]
         * 4,5   arr[3]
         * arr.length =  4  ，即arr[]数组中包含了四个元素，每个元素均为一个数组
         */
        //定义一个3*4的数组
       int[][] arrs = new int[3][4];//此时定义动态初始化二维数组
        arrs[0][0] = 99;
        arrs[0][1] = 98;
        arrs[0][2] = 97;
        arrs[0][3] = 96;
        /**
         *  定义三个二维组，每个数组四个元素即三行四列
         *  行的个数即为二维组个数，列的个数即为每个二维组中元素的个数
         *  每个二维组四个元素
         *  即arrs[0]arrs[1]arrs[2]三个数组
         *  数组元素为arrs[0][0]arrs[0][1]arrs[0][2]arrs[0][3]
         */
        arrs[1][0] = 1;
        int[][] arr = {{1,2},{2,3},{3,4},{4,5}};//此时定义静态初始化二维数组
        System.out.println(arr[0]);//打印arr[0]的地址名  arr[0][0]即是索引arr[0]数组中的第一个元素
        printarr(arr);
    }
    public static int[][] printarr(int[][] arrays){
        for (int i = 0; i < arrays.length; i++) {//打印四个二维组
            for (int j = 0; j < arrays[i].length; j++) {//打印各个二维组当中的元素
                System.out.print(arrays[i][j]);
            }
            System.out.print("  ");
        }
        return arrays;
    }
}

二维数组的相关名称及其表示方式

（1）二维数组的长度/行数：

二维数组名.length

（2）二维数组的某一行：

二维数组名[行下标]

行下标的范围：[0, 二维数组名.length-1]

（3）某一行的列数：

二维数组名[行下标].length

   因为二维数组的每一行是一个一维数组

（4）某一个元素

二维数组名\[行下标\]\[列下标\]

二维数组的遍历

for(int i=0; i<二维数组名.length; i++){
    for(int j=0; j<二维数组名[i].length; j++){
        System.out.print(二维数组名[i][j]);
    }
    System.out.println();
}