3_数组_二维数组

1.如何理解二维数组？

数组属于引用数据类型
数组的元素也可以是引用数据类型
一个一维数组A的元素如果还是一个一维数组类型的，则，此数组A称为二维数组。

2.二维数组的声明与初始化

正确的方式：

	int[] arr = new int[]{1,2,3};//一维数组
		//静态初始化
		int[][] arr1 = new int[][]{{1,2,3},{4,5},{6,7,8}};
		//动态初始化1
		String[][] arr2 = new String[3][2];
		//动态初始化2
		String[][] arr3 = new String[3][];
	//也是正确的写法：
		int[] arr4[] = new int[][]{{1,2,3},{4,5,9,10},{6,7,8}};
		int[] arr5[] = {{1,2,3},{4,5},{6,7,8}};//类型推断

3.如何调用二维数组元素:

System.out.println(arr1[0][1]);//2
		System.out.println(arr2[1][1]);//null
		
		arr3[1] = new String[4];
		System.out.println(arr3[1][0]);
	System.out.println(arr3[0]);//

4.二维数组的属性：

	System.out.println(arr4.length);//3
		System.out.println(arr4[0].length);//3
		System.out.println(arr4[1].length);//4

5.遍历二维数组元素

	for(int i = 0;i < arr4.length;i++){
			
			for(int j = 0;j < arr4[i].length;j++){
				System.out.print(arr4[i][j] + "  ");
			}
			System.out.println();
	}

6.二维数组元素的默认初始化值

• 规定：二维数组分为外层数组的元素，内层数组的元素

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

•  外层元素：arr[0],arr[1]等
  

•  内层元素：arr[0][0],arr[1][2]等
  

• ⑤ 数组元素的默认初始化值
• 针对于初始化方式一：比如：int[][] arr = new int[4][3];

•  外层元素的初始化值为：地址值
  

•  内层元素的初始化值为：与一维数组初始化情况相同
  

• 针对于初始化方式二：比如：int[][] arr = new int[4][];

•  外层元素的初始化值为：null
  

•  内层元素的初始化值为：不能调用，否则报错。
  

7.二维数组的内存结构

第一行代码：通过地址值0x1234，arr1就可以指向堆空间造好的数组，就可以找过去。没有赋过值，数组中为4个null.
第二行代码：把0x7788赋给arr[1],通过0x7788就可以指向新造的数组，数组类型为int,并由3个0分别赋值为1,2,3.
…
当main方法结束之后,arr1就出栈，指针丢失，地址值0x1234所代表的数组就被回收，那么指向0x7788，0x6677的指针也丢失，那么0x7788，0x6677所代表的数组就被回收。

代码示例

/*
 * 二维数组的使用
 *
 * 1.理解：
 * 对于二维数组的理解，我们可以看成是一维数组array1又作为另一个一维数组array2的元素而存在。
 * 其实，从数组底层的运行机制来看，其实没有多维数组。
 *
 * 2. 二维数组的使用:
 *   ① 二维数组的声明和初始化
 *   ② 如何调用数组的指定位置的元素
 *   ③ 如何获取数组的长度
 *   ④ 如何遍历数组
 *   ⑤ 数组元素的默认初始化值 :见 ArrayTest3.java
 *   ⑥ 数组的内存解析 :见 ArrayTest3.java
 */
public class ArrayTest2 {
    public static void main(String[] args) {
        //1.二维数组的声明和初始化
        int[] arr = new int[]{1,2,3};//一维数组
        //静态初始化
        int[][] arr1 = new int[][]{{1,2},{1,2,3},{5,6}};
        //动态初始化1
        int[][] arr2 = new int[3][2];
        //动态初始化2
        int[][] arr3 = new int[3][];

        //2..如何调用数组的指定位置的元素
        System.out.println(arr1[1][1]);//2
        System.out.println(arr2[1][1]);//0

        //3.获取数组的长度
        System.out.println(arr1.length);//3
        System.out.println(arr1[1].length);//3


        //4.如何遍历二维数组
        for (int i = 0;i < arr1.length;i++){
            for (int j = 0;j < arr1[i].length;j++){
                System.out.print(arr1[i][j]+" ");//1 2 1 2 3 5 6
            }
        }

    }

}

/*
 * 二维数组的使用：
 * 	规定：二维数组分为外层数组的元素，内层数组的元素
 * 		int[][] arr = new int[4][3];
 * 		外层元素：arr[0],arr[1]等
 * 		内层元素：arr[0][0],arr[1][2]等
 *
 *   ⑤ 数组元素的默认初始化值
 *   针对于初始化方式一：比如：int[][] arr = new int[4][3];
 *      外层元素的初始化值为：地址值
 *      内层元素的初始化值为：与一维数组初始化情况相同
 *
 *   针对于初始化方式二：比如：int[][] arr = new int[4][];
 *   	外层元素的初始化值为：null
 *      内层元素的初始化值为：不能调用，否则报错。
 *
 *   ⑥ 数组的内存解析
 *
 */
public class ArrayTest3 {
    public static void main(String[] args) {

        int[][] arr = new int[4][3];
        System.out.println(arr[0]);//[I@15db9742
        System.out.println(arr[0][0]);//0

//		System.out.println(arr);//[[I@6d06d69c

        System.out.println("*****************");
        float[][] arr1 = new float[4][3];
        System.out.println(arr1[0]);//地址值
        System.out.println(arr1[0][0]);//0.0

        System.out.println("*****************");

        String[][] arr2 = new String[4][2];
        System.out.println(arr2[1]);//地址值
        System.out.println(arr2[1][1]);//null

        System.out.println("*****************");
        double[][] arr3 = new double[4][];
        System.out.println(arr3[1]);//null
//		System.out.println(arr3[1][0]);//报错

    }
}




/*
 * 使用二维数组打印一个 10 行杨辉三角。

【提示】
 1. 第一行有 1 个元素, 第 n 行有 n 个元素
 2. 每一行的第一个元素和最后一个元素都是 1
 3. 从第三行开始, 对于非第一个元素和最后一个元素的元素。即：
yangHui[i][j] = yangHui[i-1][j-1] + yangHui[i-1][j];
 *
 */
public class YangHuiTest {
    //这是一个main方法，程序的入口
    public static void main(String[] args) {
        //1 声明并初始化二维数组
        int[][] yangHui = new int[10][];
        //2 给数组元素赋值
        for (int i = 0;i < yangHui.length;i++){
            yangHui[i] = new int[i+1];
            //2.1 给首末元素赋值
            yangHui[i][0] = yangHui[i][i] = 1;
            //2.2 给每行的非首末元素赋值 每行的第二个元素到倒数第二个元素
            if (i > 1){
                for (int j = 1;j < yangHui[i].length-1;j++){
                    yangHui[i][j] = yangHui[i-1][j-1] + yangHui[i-1][j];
                }
            }
        }
        //3 遍历二维数组
        for (int i = 0;i < yangHui.length;i++){
            for (int j = 0;j < yangHui[i].length;j++){
                System.out.print(yangHui[i][j]+" ");
            }
            System.out.println();
        }


    }
}