JAVA_基础Array数组(一维数组、二位数组)介绍与内存解析

Array数组

一、数组的概述

1. 数组的理解：

   ① 数组（Array），是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理。

   ② 数组属于引用数据类型，数组的元素也可以是引用类型。

2. 数组相关的概念：

   • 数组名
   • 元素
   • 角标、下标、索引
   • 数组的长度：元素 的个数

3. 数组的特点：

   ① 数组是有序排列的

   ② 数组属于引用数据类型变量。

   ③ 创建数组对象会在内存中开辟一整快连续的空间

   ④ 数组的长度一旦确定，就不能修改。

   ⑤ 数组的元素：

   • 既可以是基本数据类型 （byte、short、int、long）

   • 也可以是引用类型（String）

4. 数组分类：

   ① 按照维数：一维数组、二维数组、…

   ② 按照数组元素的类型：基本数据类型元素的数组，引用数据类型元素的数组

一维数组的使用

一维数组的声明和初始化

• 静态初始化：数组的初始化和数组元素的赋值操作同时进行

//		声明
 		int num; 
// 		初始化
 		num = new int[]{1001, 1002, 1003, 1004}; 
		/* 或 */
// 		声明 + 初始化
 		int num = new int[]{1001, 1002, 1003, 1004}; 

• 动态初始化：数组的初始化和数组元素的赋值操作分开进行

//		声明
 		String names; 
// 		初始化
 		names = new String[5]; 
		/* 或 */
// 		声明 + 初始化
		String[] names = new String[5];

• 简写：

		// 方式一
		int[] arr6 = { { 1, 2, 3 }, { 4, 5 }, { 6, 7, 8, 9 } };
		// 方式二
		String arr7[] = new String[3];

总结：数组一旦初始化完成，其长度就确认了。

调用指定位置的一维数组元素

通过角标的反方式调用：数组的角标（或索引）从0开始的，到数组的长度-1结束。

names[0] = "王二";
names[1] = "李四";
names[2] = "张三";
names[3] = "王五";
names[4] = "老六";

获取一维数组的长度。

属性：length

System.out.println(names.length);

遍历一维数组

for (int i = 0; i < names.length; i++) {
    System.out.println(names[i]);
}

一维数组元素的默认初始化值

数组元素是整形：0
数组元素是浮点型: 0.0
数组元素是char型：0 或 ‘\u0000’,而非’0’
数组元素是boolean型：false
数组元素是引用类型：null,而非 "null"

//		整形
		int[] arr = new int[4];
		for(int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);	// 00000
		}
		System.out.println("*********************");
		
//		整型
		short[] arr1 = new short[4];
		for(int i = 0; i < arr1.length; i++) {
			System.out.println(arr1[i]); // 00000
		}
		System.out.println("*********************");
		
//		浮点型
		float[] arr2 = new float[4];
		for(int i = 0; i < arr2.length; i++) {
			System.out.println(arr2[i]); //0.0
		}
		System.out.println("*********************");
		
//		字符型
		char[] arr3 = new char[4];
		for(int i = 0; i < arr3.length; i++) {
			System.out.println("----" + arr3[i] + "****"); // ---- ****
		}
		
		if(arr3[0] == 0) {
			System.out.println("您好！"); // 您好！
		}
		System.out.println("*********************");
		
//		布尔型
		boolean[] arr4 = new boolean[5];
		System.out.println("布尔型默认值：" + arr4[0]); // 布尔型默认值：false
		System.out.println("*********************");
		
//		引用类型
		String[] arr5 = new String[5];
		System.out.println(arr5[0]); // null
		if (arr5[0] == null) {
			System.out.println("深圳天气不错！"); // 深圳天气不错！
		}

数组的内存解析

二维数组的使用

二维数组的理解

对于二维数组的理解，我们可以看成是一维数组array1里又作为另一个一维数组array2的元素而存在。数组底层的运行机制来看，其实没有多维数组（都是一维数组，只不过在一维数组的元素中重新指向了一个新的一维数组）。

二维数组的声明和初始化

静态初始化：数组的初始化和数组元素的赋值操作同时进行

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

动态初始化：数组的初始化和数组元素的赋值操作分开进行

// 动态初始化:方式一
String[][] arr1 = new String[3][2];
		
// 动态初始化:方式二
String[][] arr2 = new String[3][];

简写：

// 方式一
int[][] arr6 = { { 1, 2, 3 }, { 4, 5 }, { 6, 7, 8, 9 } };

// 方式二
String[] arr7[] = new String[3][2];

// 方式三
String arr8[][] = new String[3][2];

总结：数组一旦初始化完成，其长度就确认了。

调用指定位置的二维数组元素

通过角标的反方式调用：数组的角标（或索引）从0开始的，到数组的长度-1结束。

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

System.out.println(arr[0][1]);	// 2
System.out.println(arr1[1][1]);	// null

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

获取二维数组的长度。

属性：length

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

System.out.println(arr.length);	// 3
System.out.println(arr[0].length); // 3
System.out.println(arr[1].length); // 2

遍历二维数组

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

for (int i = 0; i < arr.length; i++) {
    for (int j = 0; j < arr[i].length; j++) {
        System.out.print(arr[i][j] + " ");
    }
    System.out.println();
}
/*
1 2 3 
4 5
6 7 8 9
*/

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

针对于初始方式一：int[][] arr = new int[4][3]。

外层元素的初始化值为：地址值（用来指定内层元素的位置）

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

针对于初始方式二：int[][] arr = new int[4][]。

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

内层元素的初始化值为：不能调用，报错空指针异常

int[][] arr = new int[4][3];
		
// 整型
System.out.println(arr[0]);	// 地址值：[I@15db9742
System.out.println(arr[0][0]);	// 0

// 浮动型
float[][] arr1 = new float[4][3];
System.out.println(arr1[0]);	// 地址值：[F@6d06d69c
System.out.println(arr1[0][0]); // 0.0

// 引用型
String[][] arr2 = new String[4][3];
System.out.println(arr2[1]);	// 地址值：[Ljava.lang.String;@7852e922
System.out.println(arr2[1][1]); // null

double[][] arr3 = new double[4][];
System.out.println(arr3[1]);	// null
System.out.println(arr3[1][0]); // 报错：空指针异常

数组的内存解析

数组中常见的异常

数组角标越界的异常

ArrayIndexOutOfBoundsExcetion

int[] arr = new int[]{1,2,3,4,5,6};
for (int i = 0; i <= arr.length; i++) {
    System.out.println(arr[i]);
}
System.out.println(arr[-2]);

空指针异常

NullPointerException

// 情况一:
int[] arr1 = new int[]{1,2,3};
arr1 = null;
System.out.println(arr1[0]);

// 情况二:
int[][] arr2 = new int[4][];
System.out.println(arr2[0][0]);

// 情况三:
String[] arr3 = new String[]{"AA","BB","CC"};
arr3[0] = null;
System.out.println(arr3[0].toString());