数组

数组的概述
1、数组：就是用于存储相同数据类型的数据的容器
2、使用数组的原因：
没有数组：存在多个变量，需要声明多个变量的名称，这些名称之间没有什么关系和规律。想访问所有的变量，就比较困难。
有了数组：只需要有一个数组容器的名称，容器里面有通过数字表示的位置。位置的数字又有规律的。可以通过容器名称结合位置数字的方式，访问到某个变量。非常容易的访问所有的变量。通过有规律的索引，来访问没有规律的元素。
3、数组的定义：
元素的数据类型[] 数组名称 = new 元素的数据类型[数组容器的大小];
4、详细解释：
元素：数组中的数据、数组中的变量
元素的数据类型：数组中的数据的数据类型，用于决定每个空间的大小
[]：表示是一个一维数组
数组名称：数组本身也是一个变量，用于存储数组的地址的变量。
=：赋值符号，将数组的地址，赋值给数组的名称
new：用于在堆内存中开辟空间
元素的数据类型：和前面的元素的数据类型保持一致
数组容器的大小：可以存储数据的个数
5、打印的数组的结果解释：[I@15db9742
[：表示这是一个一维数组
I：表示数组中存储的是int类型的数据
@：普通的分隔符
15db9742：数组有一个内存地址，通过hashCode方法，将这个内存地址计算成了一个数字，用于表示这个内存地质，将这个数字转成十六进制的表示形式
说明：以后将打印结果，简称为数组的地址
代码示例
class Demo01_数组的概述 {
public static void main(String[] args) {
//声明一个int类型的数组，数组大小为3
int[] arr = new int[3];
System.out.println(arr);
}
}
数组的初始化
1、为数组分配内存空间，并且赋值
2、分类：动态初始化、静态初始化
3、动态初始化：程序运行过程中，才能知道究竟给元素赋什么值
元素的数据类型[] 数组名称 = new 元素的数据类型[数组元素的个数];
元素赋值的方式：
数组名称[元素的索引] = 元素值;
索引：
元素在数组中的位置的数字，别名：下标、角标、脚标；从0开始、数组的长度-1 结束
注意事项：
1、所有的元素，都需要逐个赋值
2、如果数组中的元素，没有赋值，元素也有一个默认的初始化值，整数为0
4、静态初始化：在程序书写的时候，就知道了数组中的元素是什么值
元素的数据类型[] 数组名称 = new 元素的数据类型[] {元素值的罗列};
注意事项：
1、在第二个方括号中，不要写数组元素的个数
2、元素值的罗列，元素和元素之间，使用逗号分隔。写了几个元素，就分配多大 空间
3、罗列出来的元素值，数据类型必须和声明的数组元素的数据类型一致
4、静态初始化有一个简写格式：
元素的数据类型[] 数组名称 = {元素值的罗列};
数组名称的声明，数组名称的赋值，不能分成两行写。
代码示例
class Demo02_数组的初始化 {
public static void main(String[] args) {
//数组的定义
int[] arr = new int[3];
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);

	//给元素逐个动态赋值
	arr[0] = 60;
	arr[1] = 66;
	arr[2] = 68;

	//赋值之后再次查看元素值
	System.out.println(arr[0]);
	System.out.println(arr[1]);
	System.out.println(arr[2]);

	//静态初始化
	int[] arrS = new int[] {80, 86, 88};
	System.out.println(arrS[0]);
	System.out.println(arrS[1]);
	System.out.println(arrS[2]);

	//不要动静结合
	//int[] arrS = new int[3] {80, 86, 88};


	//完整版：可以分成两行写
	int[] arr2;
	arr2 = new int[] {6,7,8};

	//简写版，arr3的声明和赋值，不能分成两行
	int[] arr3 = {16, 17, 18};
}

}
数组的内存理解
Jvm内存的划分
1、jvm是执行java程序的容器，空间很大，需要划分不同的区域：不同的功能，需要使用不同特点的区域来完成。分为：栈内存、堆内存、方法区、本地方法区、程序计数器
2、栈内存【常用】：用于执行方法，每个方法单独的分配一段空间，称为栈帧，把给方法分配内存空间，形象的称为“进栈”。特点：先进后出
3、堆内存【常用】：用于存储数组、对象等数据量较大的数据。一般都是引用数据类型。
4、方法区【常用】：用于存储类的字节码对象，存储常量、存储静态变量
5、本地方法区：用于执行本地方法。C语言、C++方法就是本地方法。
6、程序计数器：用于控制程序的执行、控制程序执行哪行代码
一个数组的内存图

代码示例
class Demo03_一个数组的内存图 {
public static void main(String[] args) {
int[] arr = new int[3];
System.out.println(arr[1]);
arr[0] = 30;
arr[1] = 40;
System.out.println(arr[0] + “…” + arr[1] + “…” + arr[2]);
}
}
两个数组的内存图

代码示例
class Demo04_两个数组的内存图 {
public static void main(String[] args) {
int[] arr1 = new int[3];
arr1[0] = 20;
arr1[1] = 30;
System.out.println(arr1[0] + “…” + arr1[1] + “…” + arr1[2]);

	int[] arr2 = new int[3];
	System.out.println(arr2[0] + "..." + arr2[1] + "..." + arr2[2]);
}

}
两个引用指向同一个数组
1、引用：
在内存中的一个变量，存储另外一个数据的地址。
称数据的地址，为引用
存储引用的变量，称为引用数据类型的变量
2、两个引用指向了同一个数组：
任意一个引用修改了数组中的内容
另外一个数组也能访问到修改了的数据
3、图示：

代码示例
class Demo05_两个引用指向同一个数组 {
public static void main(String[] args) {
int[] arr1 = new int[3];
arr1[0] = 100;
System.out.println(arr1[0] + “…” + arr1[1] + “…” + arr1[2] );

	int[] arr2 = arr1;
	arr2[0] = 300;
	arr2[1] = 500;
	arr2[2] = 700;
	System.out.println(arr2[0] + "..." + arr2[1] + "..." + arr2[2] );
	System.out.println(arr1[0] + "..." + arr1[1] + "..." + arr1[2] );
}

}
数组的异常
异常
1、在程序运行过程中，出现了和生活正常情况不符的条件，就没有必要让程序继续执行下去。将这个情况的信息，封装成一个对象，就是异常对象。一旦有了异常对象，程序就会做一些跳转甚至结束。
2、数组操作的过程中，可能会发生的两个异常：
数组索引越界异常
空指针异常
数组索引越界异常
1、Exception in thread “main” java.lang.ArrayIndexOutOfBoundsException: 3
异常 在 线程 主线程 数组 索引 超过 边界 异常
2、数组索引越界异常
原因：访问了数组中，不存在的索引。数组索引的范围是0~长度-1，超过了这个范围都是越界
避免：不要访问不存在的索引
代码示例
class Demo06_数组索引越界异常 {
public static void main(String[] args) {
int[] arr = {3, 4, 5};
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
System.out.println(arr[3]);

}

}
空指针异常
1、Exception in thread “main” java.lang.NullPointerException
异常 在 线程 主 空 指针 异常
2、空指针异常：
空：null，在栈内存的引用中，不记录任何堆内存的地址
指针：C语言中的概念，表示的就是堆数据的内存地址。在java中，不能直接操作内存地址，将内存地址进行封装，形成了引用。“空指针异常”是其他语言继承过来的说法，是一个舶来品。
原因：当引用不再指向任何的堆内存中的数据时，仍然要通过这个引用访问堆内存中的数据，只能抛出异常。
避免：在使用引用之前，可以先判断是否为null，不为null的时候再去访问
代码示例
class Demo07_空指针异常 {
public static void main(String[] args) {
int[] arr = {7,8,9};
System.out.println(arr[0] + “…” + arr[1] + “…” + arr[2]);

	arr = null;
	if (arr != null) {
		System.out.println(arr[0] + "..." + arr[1] + "..." + arr[2]);
	}
}

}
数组的操作
数组的遍历
1、遍历：一个一个经历元素，所有元素都访问一遍
2、方式：
通过循环，访问到数组中所有元素的索引
通过索引，访问到对应元素
3、索引：
角标、下标、脚标，表示某个元素在数组中的位置
范围：0~长度-1
数组长度：数组名称.length，获取到数组元素的个数
代码示例
class Demo08_数组的遍历 {
public static void main(String[] args) {
int[] arr = {12, 23, 34, 45, 56};
//定义循环，获取所有的索引，由于i不仅表示循环的控制，还表示数组的索引
//所以从0开始
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
数组获取最值
1、给定一个数组，求出数组的最大值
2、思路：擂台思想
声明一个变量，用于存储当前已知的最大值，遍历数组，让每个元素都和该变量比较，如果比最大值变量还要大，那么就让当前元素替换掉最大值变量中的数据。
3、思路图示：

4、注意事项：
变量中，只能存储数组中存在的元素，不要存储其他无关数据
代码示例
class Demo09_数组的最值 {
public static void main(String[] args) {
int[] arr = {-23, -55, -12, -66, -11, -88};
//声明一个变量，就是擂台
int max = arr[0];//擂台上，不要站其他的无关元素，只能存储参赛选手
//获取所有的元素，依次打擂，从第二个元素开始打擂
for (int i = 1; i < arr.length; i++) {
//如果当前元素大于擂台上的元素
if (arr[i] > max) {
max = arr[i];//就让当前元素将擂台上的元素替换掉
}
}
//循环结束之后，擂台上就是最厉害的元素了
System.out.println(max);
}
}
数组的反转
1、数组所有元素都为原来顺序的逆序。第一个变成最后一个，第二个变为倒数第二个。
2、思路：
对称位置的元素，进行交换
3、思路图示：

代码示例
class Demo10_数组的反转 {
public static void main(String[] args) {
int[] arr = {23, 55, 12, 66, 11, 88};
//调用方法，遍历数组内容
printArr(arr);
//对数组进行反转：获取对称位置的索引
for (int i = 0, j = arr.length - 1; i < j; i++, j–) {
//i和j位置的元素，进行交换
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
//反转完成之后，再次遍历数组内容
printArr(arr);
}

/*定义一个方法，遍历一个int类型的数组
 返回值类型：void，因为只需要打印出来即可
 参数列表：
*/
public static void printArr(int[] arr) {
	for (int i = 0; i < arr.length; i++) {
		System.out.print(arr[i] + "  ");
	}
	System.out.println();
}

}
数组的查找
1、给定一个数组，找到指定值的索引
2、思路：
遍历数组，判断每个元素是否与要找的元素值相等，如果相等，那么就返回当前元素的索引；如果没有找到，返回一个-1.
代码示例
class Demo11_数组的查找 {
public static void main(String[] args) {
int[] arr = {23, 55, 12, 66, 11, 88};
//查找元素11的索引
int index = -1;//没有开始找的时候，就认为没找到
for (int i = 0; i < arr.length; i++) {
if (arr[i] == 111) {//如果在循环过程中，找到了，那么就给index修改
index = i;
break;//如果已经找到了，就不用继续找了，结束循环即可
}

		/*if ( i == arr.length - 1) {
			index = -1;
		}*/
	}
	//如果循环结束了，还没有修改index的值，就说明确实没有找到，打印-1
	System.out.println(index);
}

}
二维数组
概述
1、二维数组：数组的每个元素，又是一个数组
2、本质：还是一个一维数组，只不过数组的每个元素，都是另一个一维数组的地址
3、定义格式：
1、int[][] arr = new int[3][5];创建了一个二维数组，有3个元素，每个元素都是一个一维数组的地址，每个一维数组中，有5个元素，每个元素都是一个int类型的数据，图示：

2、int[][] arr = new int[3][];创建了一个二维数组，有三个元素，每个元素都是一个一维数组的地址，每个一维数组中有多少个元素，不知道，所以一维数组没有办法创建。后期可以随意创建一维数组，给二维数组的元素赋值。
3、int[][] arr = {{}, {1}, {1,2}, {3,4,5,6,7}, null};相当于定义了一个二维数组，有5个元素，每个元素都是一个一维数组，每个元素的长度、数据都不相同。

代码示例
class Demo12_二维数组 {
public static void main(String[] args) {
int[][] arr = new int[3][5];
System.out.println(arr);//[[I@15db9742
System.out.println(arr.length);//3
System.out.println(arr[0]);//[I@…
System.out.println(arr[1]);//[I@…
System.out.println(arr[0].length);//5
System.out.println(arr[0][0]);//0
System.out.println("---------------------------");

	int[][] arr2 = new int[3][];
	System.out.println(arr2);//[[I@...
	System.out.println(arr2.length);//3
	System.out.println(arr2[0]);//null
	System.out.println(arr2[1]);
	//System.out.println(arr2[0].length);//空指针异常
	int[] arrOne = {3, 4, 5};
	arr2[0] = arrOne;
	System.out.println(arr2[0] + "..." + arrOne);
	System.out.println(arr2[0].length);//3
	System.out.println(arr2[0][0]);//3

	int[] arrOne2 = {6,7,8,9,11,12,13};
	arr2[1] = arrOne2;
	System.out.println(arr2[1][3]);//9

	System.out.println("------------------------------------");
	int[][] arr3 = {{}, {1}, {1,2}, {3,4,5,6,7}, null};
	System.out.println(arr3);//[[I@....
	System.out.println(arr3.length);//5
	System.out.println(arr3[0]);//[I@...
	System.out.println(arr3[0].length);//0
	//System.out.println(arr3[0][0]);//数组索引越界异常
	System.out.println(arr3[4]);//null
	System.out.println(arr3[4].length);//空指针异常

}

}
二维数组的遍历
1、二维数组是：数组嵌套了数组，遍历的时候，使用循环嵌套循环。
2、外层循环中，获取到所有的一维数组，内层循环中，遍历每个一维数组。
代码示例
class Demo13_二维数组的遍历 {
public static void main(String[] args) {
int[][] arr = {{}, {1}, {1,2}, {3,4,5,6,7}, null};
//定义循环，获取所有的一维数组
for (int i = 0; i < arr.length; i++) {
if ( arr[i] != null) {//如果一维数组不为null，才遍历
//定义循环，遍历一维数组arr[i]
for ( int j = 0; j < arr[i].length; j++) {
System.out.print(arr[i][j] + " ");
}
//一维数组的所有元素打印完成之后，加一个换行
System.out.println();
} else {//如果一维数组为null，就打印字符串null
System.out.println(“null”);
}
}
}
}