day04-数组

day04-数组

今日学习内容：

JVM的内存模型

数组的定义

数组的静态初始化

数组的动态初始化

数组的基本操作

二维数组的操作

今日学习目标：

了解JVM的内存模型中的栈、堆、方法区

必须掌握数组定义的语法

必须掌握数组的静态初始化

必须掌握数组的动态初始化

必须掌握数组的基本操作-获取长度

必须掌握数组的基本操作-获取元素值

必须掌握数组的基本操作-设置元素值

必须掌握数组的基本操作-遍历元素（for循环和for-each循环）

了解二维数组的定义和初始化操作

5. 数组

5.1 JVM内存模型（掌握）

JVM内存划分，人为的根据不同内存空间的存储特点以及存储的数据。

• 程序计数器：当前线程所执行的字节码的行号指示器。
• 本地方法栈：为虚拟机使用的native方法服务。
• 方法区：线程共享的内存区域，存储已被虚拟机加载的类信息、常量、静态变量即时编译器编译后的代码数据等（这个区域的内存回收目标主要是针对常量池的回收和对类型的卸载）。
• **Java虚拟机栈：**简称栈，每个方法被执行的时候都会同时创建一个栈帧用于存储该方法的局部变量、操作栈、动态链接、方法出口等信息。
• 每当调用一个方法时，创建一个栈帧，存放了当前方法的局部变量，当方法调用完毕，该方法的栈帧就被销毁了。
• Java堆：被所有线程共享的一块内存区域，在虚拟机启动时创建。所有的对象实例以及数组都要在堆上分配。
• 每次使用new关键字，就表示在堆内存中开辟一块新的存储空间。

GC(Garbage Collection)，垃圾回收器。

​ Java的自动垃圾回收机制可以简单理解为，不需要程序员手动的去控制内存的释放。当JVM内存资源不够用的时候，就会自动地去清理堆中无用对象（没有被引用到的对象）所占用的内存空间。

5.2 数组定义（重点）

5.2.1 什么是数组(了解）

​ 在之前我们可以通过一个变量表示一个学生的年龄，如果现在需要表示全班100个人的年龄岂不是需要定义100个变量来分别表示。这样的操作太麻烦了，为了解决这种问题，Java就提供了数组。

​ 所谓数组，把具有相同类型的多个常量值有序组织起来的一种数据形式。这些按一定顺序排列的多个数据称为数组。而数组中的每一个常量值称之为数组元素，数组中使用索引来表示元素存放的位置，索引从0开始，步长是1，有点像Excel表格的行号。

5.2.2 定义语法（重点）

回忆定义变量的语法：

数据类型 变量; 如 int age;

数组的定义语法：

数组元素类型[]  数组名;  如	int[] ages;	

另一种方式：int ages[]; 不推荐

理解：

1. 可以把int[]看成是一种数据类型——int类型的数组类型。
2. int[] 数组可以看出，该数组中的元素类型是int类型的。
3. String[] 数组可以看出，该数组中的元素是String类型的。

5.3 数组的初始化（重点）

数组在定义后，必须初始化才能使用。所谓初始化，就是在堆内存中给数组分配存储空间，并为每一个元素赋上初始值，有两种方式：

• 静态初始化；
• 动态初始化；

数组的长度是固定的，无论以哪种，一旦初始化完成，数组的长度（元素的个数）就固定了，不能改变，除非重新对该初始化。

如果我们事先知道元素是多少，选用静态初始化，事先不知道元素是多少，选用动态初始化。

5.3.1 静态初始化（重点）

程序员直接为每一个数组元素设置初始化值，而数组的长度由系统(JVM)决定。

语法：数组元素类型[] 数组名 = new 数组元素类型[]{元素1,元素2,元素3,…};

int[] nums = new  int[]{1,3,5,7,9};
简单写法:
int[] nums = {1,3,5,7,9};//简单写法,定义和初始化必须同时写出来

简单写法:

int[] nums = {1,3,5,7,9};//简单写法,定义和初始化必须同时写出来

5.3.2 静态初始化内存分析（重点）

public class ArrayDemo1{
	public static void main(String[] args) {
		//定义并初始化数组
		int[] nums = new int[] { 1, 3, 5, 7 };
		System.out.println("数组长度=" + nums.length);
		//重新初始化数组
		nums = new int[] { 2, 4, 8 };
		System.out.println("数组长度=" + nums.length);
	}
}

对上述代码做内存分析

int[] nums = new int[] { 1, 3, 5, 7 };

这一行代码可以分成三步：

• 在堆内存中开辟一块空间，用来存储数组数据:new int[] { 1, 3, 5, 7 }

• 在栈中开辟一块空间nums

• 把堆空间表示数组的内存地址赋给nums

这种把内存地址赋给一个变量，也被称之为引用关系（为了更清晰有人习惯画一根箭头来表示这种关系），也就是说nums变量引用了堆中某一块内存地址，当操作nums变量的时候，其实底层操作的是nums所引用内存地址里面的数据。

所以此时，通过nums.length代码来查看nums数组中有几个元素，结果很明显是4。

nums = new int[] { 2, 4, 8 };

• 因为存在new，说明又会在堆空间开辟一块新的空间，赋初始值。

• 并把内存地址重新赋给nums变量，nums原来所引用的地址将被覆盖掉。

所以此时，通过nums.length代码来查看nums数组中有几个元素，结果很明显是3。

注意：此时地址为0x1234的内存空间没有被任何变量所引用，所以该空间就变成了无用的垃圾，就等着垃圾回收器回收该空间。

如果存在一行代码，如下：

nums = null;

null表示不再引用堆中的内存空间，那么此时nums就好比是没有初始化的，不能使用。

5.3.3 动态初始化（重点）

程序员只设置数组元素个数，而数组的元素的初始值由系统(JVM)决定。

语法：数组元素类型[] 数组名 = new 数组元素类型[length];

int[] nums = new int[5];

不能同时指定元素值和数组长度，反例如下:

int[] nums = new int[5]{1,3,5,7,9};

不同数据类型的初始值：

int[] arr1 = new int[3]; int类型数组，每一个元素的初始值为0

double[] arr2 = new double[5]; double类型数组，每一个元素初始值为0.0

String[] arr3 = new String[2]; String类型数组，每一个元素的初始值为null

5.3.4 动态初始化内存分析（重点）

public class ArrayDemo2 {
	public static void main(String[] args) {
		//定义并初始化数组
		int[] nums = new int[4];
		System.out.println("数组长度=" + nums.length);
		//重新初始化数组
		nums = new int[3];
		System.out.println("数组长度=" + nums.length);
	}
}

这一行代码，确实可以分成三步：int[] nums = new int[4];

• 在堆内存中开辟一块空间，用来存储数组数据

• 在栈中开辟一块空间nums

• 把堆空间表示数组的内存地址赋给nums

所以此时，通过nums.length代码来查看nums数组中有几个元素，结果很明显是4。

nums = new int[3] ;

• 因为存在new，说明又会在堆空间开辟一块新的空间，赋初始值。

• 并把内存地址重新赋给nums变量，nums原来所引用的地址将被覆盖掉。

所以此时，通过nums.length代码来查看nums数组中有几个元素，结果很明显是3。

如果清楚数组中的元素,那么使用静态初始化

如果不清楚数组中的元素, 但是清楚数组的元素个数(长度),那么使用动态初始化

5.4 数组操作（重点）

5.4.1 基本操作（重点）

int[] nums = new int[]{1,3,5,7};

• 获取数组长度，语法：int size = 数组名.length;

  int size = nums.length; -> 输出结果4

• 获取元素值，语法：元素类型 变量名 = 数组名[index]；

• 数组的索引从0开始，最大索引值是数组长度-1，那么索引范围是 [ 0，数组名.length - 1 ]。

  获取第一个元素：int ele1 = nums[0]; 输出1

  获取第二个元素：int ele2 = nums[1]; 输出3

  获取第四个元素：int ele4 = nums[3]; 输出7

• 设置元素值，语法：数组名[index] = 值；

  设置第二个元素值为30 nums[1] = 30;

  获取第二个元素： int ele2 = nums[1]; 输出30

• 常见的异常

1. NullPointerException：空指针异常（空引用异常）

   操作了一个尚未初始化或者没有分配内存空间的数组

2. ArrayIndexOutOfBoundsException：数组的索引越界异常

   操作的数组的索引不在[0，数组名.length-1]范围内

• 迭代数组，也叫遍历数组（获取出数组中每一个元素）

  获取第一个元素：int ele1 = nums[0]; 输出1

  获取第二个元素：int ele2 = nums[1]; 输出30

  获取第三个元素：int ele3 = nums[2]; 输出5

  获取第四个元素：int ele4 = nums[3]; 输出7

  发现，循环遍历的次数是数组元素的个数，每一次获取元素只有索引在变化，范围是[0 , 数组名.length - 1]。

int[] nums = new int[] { 1, 3, 5, 7 };

for (int index = 0; index < nums.length; index++) {
	int ele = nums[index];//index依次是	0、1、2、3
	System.out.println(ele);
}

• 使用for-each（增强for循环）操作数组

for(数组元素类型 变量： 数组){
	//TODO
}

使用for-each操作数组更简单，因为可以不关心索引，其底层原理依然是上述的for循环操作数组。

int[] nums = new int[] { 1, 3, 5, 7 };

for (int ele : nums) {
	System.out.println(ele);
}

5.4.2.使用循环操作数组（重点）

int[] nums = new int[]{11,22,33,44,22,55};

需求1：找出数组中元素22第一次出现的索引位置

public class ArrayDemo3 {
	public static void main(String[] args) {
		int key = 22;//被搜索的元素值

		int[] nums = new int[] { 11, 22, 33, 44, 22, 55 };
		for (int index = 0; index < nums.length; index++) {
            // 如果从数组中取出的这个元素就是我们要找的，那么就输出到控制台，否则继续找
			if (nums[index] == key) {
				System.out.println(index);
				break;//找到，目的达到，结束循环
			}
		}
	}
}

需求2：求出int类型数组中最大元素值

思路：

1. 暂定第一个元素为最大，用变量max存起来
2. 用max和后面的元素比较，如果元素比max大，则把这个元素赋值给max
3. 遍历完成后，max存的数值就是最大值

public class ArrayDemo4 {
	public static void main(String[] args) {
		int[] nums = new int[] { 11, 22, 33, 44, 22, 55 };
		int max = nums[0];//max用来记作最大元素值，假设第一个元素是最大的
		for (int index = 0; index < nums.length; index++) {
			//如果后续某个元素比max大,就存储到max变量上
			if (nums[index] > max) {
				max = nums[index];
			}
		}
		System.out.println("max=" + max);
	}
}

需求3：按照某种格式打印数组元素，数组元素放在方括号[]中,相邻元素使用逗号分隔开。如上述数组打印出来，效果如：[11, 22, 33, 44, 22, 55]

思路：

1. 定义一个String类型的变量，准备用来拼接指定格式的字符串
2. 将 [ 拼接到字符串中
3. 通过循环遍历的方式，将每个元素拼接到字符串中，每个元素后面拼接一个逗号，
4. 如果是最后一个元素，不是拼接逗号，而是拼接一个 ]

public class ArrayDemo5 {
	public static void main(String[] args) {
		int[] nums = new int[] { 11, 22, 33, 44, 22, 55 };
		String str = "[";//str表示结果字符串,先拼一个[符号
		for (int index = 0; index < nums.length; index++) {
			//把每一个元素拼接在str后面
			str = str + nums[index];
			//如果是最后一个元素,则不拼接,而是]
			if(index == nums.length-1) {
				str = str + "]";
			}else {
				//如果不是最后一个元素拼接,
				str = str + ", ";
			}
		}
		System.out.println(str);
	}
}

5.5.二维数组（了解）

在之前，数组的每一个元素就是一个个的值，这种数组我们称之为一维数组。如：

int[] nums = {1,2,3,4,5};

这个数组中存储的是int类型的元素，该数组就是一个一维数组。

二维数组，就是数组中的每一个元素是另一个一维数组。

三维数组，数组的每一个元素就是一个二维数组。

其实发现，这种多维数组都可以简单称之为，数组中的数组，在实际开发中使用并不多。

5.5.1 二维数组的定义和初始化

定义和静态初始化一维数组的语法：

数组元素类型[] 数组名 = new 数组元素类型[]{值1，值2，值3，…}；如：

int[] nums = new int[]{1,3,5,7};

定义和静态初始化二维数组的语法：

数组元素类型[][] 数组名 = new 数组元素类型[][]{数组1，数组2，数组3，...};

注意，二维数组中的元素类型是一维数组，把数组元素类型[]看成一个整体，表示数据类型。

public class ArrayInArrayDemo1 {
	public static void main(String[] args) {
		//定义三个一维数组
		int[] arr1 = { 1, 2, 3 };
		int[] arr2 = { 4, 5 };
		int[] arr3 = { 6 };
		//把三个一维数组存储到另一个数组中,那么该数组就是二维数组
		int[][] arr = new int[][] { arr1, arr2, arr3 };
	}
}

定义和动态初始化二维数组的语法：

数组元素类型[][] 数组名 = new 数组元素类型[x][y]；

x表示二维数组中有几个一维数组

y表示每一个一维数组中有几个元素。

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

System.out.println(arr.length); //输出3

5.5.2 获取二维数组的元素

因为二维数组表示数组的中的数组，如果要获取数组的每一个元素值，则需要两个循环嵌套。

//二维数组
int[][] arr = new int[][] { 
	{ 1, 2, 3 }, 
	{ 4, 5 }, 
	{ 6 } 
};

使用for循环：

for (int index = 0; index < arr.length; index++) {
	//取出每一个一维数组
	int[] arr2= arr[index];
	//迭代一维数组
	for (int j = 0; j < arr2.length; j++) {
		int ele = arr2[j];
		System.out.println(ele);
	}
	System.out.println("-----");
}

使用for-each：

for (int[] arr2 : arr) {
    //arr2为每次遍历出来的一维数组
	for (int ele : arr2) {
        //ele为从arr2一维数组中遍历出来的元素
		System.out.println(ele);
	}
	System.out.println("-----");
}

学习优势：

1.包含java前后端从 0 ->1 全过程教学, 内容全面, 知识点不遗漏, 学完即可参加实际工作.
2.课程为目前项目开发常用的技术知识，向用人单位对标，学以致用。那些脱离实际，废弃不用的，太前沿的框架技术前期不建议学。
3.一起学习,打卡,一起交流,希望能营造一个和线下一样的学习环境。

需要进微信学习交流群, 或者想领取代码,文档,全套视频的同学请+v：lmm99964