数组

数组

1. 数组

1.1 生活中都是数组

超市
	物品是分门别类
	同样的物品会存放于同一个货架之上

图书馆
	<<世界因你而不同>> 10本
	存在于图书馆中
	1. 在同一个书架上
	2. 是连续存储的
	3. 每一本书都是有独立的编号，整个编号是有规律可循
	A-100-5-2-01 ~ 10

1.2 开发中的数据存储问题

在开发中可能会存在很多情况下，相同数据类型都是数据大量使用的情况，按照目前我们所学的方式，在代码中可能就会出现很多行的变量定义，会导致以下问题:
	1. 代码过于臃肿！！！
	2. 代码阅读性极差！！！
	3. 数据维护性极差！！！
	4. 数据没有任何的复用度可言，操作非常繁琐！！！

可以参考图书馆存放图书的方式来使用数组完成操作
	1. 同样的数据类型
	2. 数据的存储是连续的，同一个空间的
	3. 每一个数据都有一个独立编号，但是有统一的名字

1.3 Java中如何定义数组【重点】

数据类型[] 数组名 = new 数据类型[容量];
/*
赋值左侧
	数据类型:
		告知编译器，当前数组中能够保存的数据类型到底是什么？并且在确定数据类
		型之后，整个数组中保存的数据类型无法修改！！！
	[]:
		1. 告知编译器这里定义的是一个数组类型数据。
		2. 明确告知编译器，数组名是一个【引用数据类型】
	数组名:
		1. 操作数据非常重要的数据！！！
		2. 数组名是一个【引用数据类型】
		小拓展: int(*) (void *, void *)
赋值号右侧：
	new:
		申请【XX】内存空间，并且清空整个内存空间中所有二进制位，所有的二进制
		位都是0
	数据类型:
		前后呼应，告知编译器这里支持存储的数据类型到底是什么？
	[容量]:
		容量==> Capacity
		告知编译器，当前数组中能够存放的对应数据类型的数据，最大存储多少
		个！！
		【注意】
			一旦确定容量，针对于当前数组，后期容量无法修改
*/

1.4 数组的下标【重点】

规定
	数组中的下标是从0开始，到数组的容量 - 1

例如:
	数组容量为10
	有效下标范围: 0 ~ 9
	超出有效下标范围，都是无效下标，后期考虑数组处理异常问题，负数使用问题

操作会出现的问题:
	1. 数组下标越界
		ArrayIndexOutOfBoundsException

1.5 数组内存分析图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uOQWlmdJ-1581427892186)(.\img\数组内存分析图.png)]

【补充知识点 引用数据类型】

生活中
	文章中如果出现了对于其他文章的引用操作，会存在对应角标，用于在文章中进行跳转操作！！！
	快递信息

开发中引用数据类型
	用于保存其他内存空间的首地址，保存地址之后，CPU可以通过对应的引用数据类型，得到对应的地址，从而访问地址对应内存空间。

1.6 数组和循环不得不说的秘密

/*
获取数组容量的方式
	数组名.length 属性
	当前数组的属性length是要占用一定的数组空间的，属于数组中的内容，这就是为什么数组中占用的空间要比存储数据计算空间略大一些。
*/

1.7 数组地址转移问题

class Demo3 {
	public static void main(String[] args) {
		int[] arr1 = new int[10];
		int[] arr2 = new int[10];

		arr1[5] = 100;
		arr2[5] = 500;
		
		System.out.println(arr1[5]);
		System.out.println(arr2[5]);
		
		arr1 = arr2;
		arr1[5] = 2000;
		
		System.out.println(arr1[5]);
		System.out.println(arr2[5]);
	}
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-veKBcx1l-1581427892186)(.\img\数组地址转移问题.png)]

1.8 数组和方法之间的关系

/*
Java中如何数组成为方法的参数，已经使用方式
*/
public static void main(String[] args) {

}
/*
格式:
	public static returnType methodName(arrayType[] arrayName)
	arrayName是一个数组类型的变量，引用数据类型的变量
*/

class Demo4 {
	public static void main(String[] args) {
		int[] array = new int[10];
		
		// 调用赋值数组中元素的方法
		// 调用参数是一个数组类型的方法，需要传入的内容是数组名
		assignIntArray(array);
		printIntArray(array);
	}
	
	/*
	需求：
		赋值一个int类型的数组
	方法分析：
		public static 固定格式 不要问
		返回值类型：
			void 无返回值
		方法名:
			assignIntArray 见名知意，动宾结构，小驼峰命名法
		形式参数列表:
			这里需要的是一个int类型的数组
			(int[] arr)
	方法声明：
		public static void assignIntArray(int[] arr)
	*/
	/**
	* 赋值一个指定的int类型数组
	*
	* @param arr 这里需要的参数是一个int类型数组
	*/
	public static void assignIntArray(int[] arr) {
		for (int i = 0; i < arr.length; i++) {
			arr[i] = i + 1;
		}
	}
	
	/*
	需求
		展示一个int类型数组中保存的数据
	方法分析：
		public static： 不要问
		返回值类型:
			void
		方法名：
			printIntArray
		形式参数列表：
			这里需要展示的是一个int类型数组
			(int[] arr)
	方法声明:
		public static void printIntArray(int[] arr)
	*/
	/**
	* 展示一个int类型数组中保存的数据
	*
	* @param arr 这里需要的是一个int类型数组
	*/
	public static void printIntArray(int[] arr) {
		for (int i = 0; i < arr.length; i++) {
			System.out.println("array[" + i + "]=" + arr[i]);
		}
	}
}

2. 数组算法

所有的数组全部是使用int类型

2.1 完成一个数组逆序过程

/*
静态数组
	int[] arr = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};
	逆序完成
		{10, 8, 6, 4, 2, 9, 7, 5, 3, 1};
方法的分析
	public static 不要问
	返回值类型:
		void 不需要返回值
	方法名:
		逆序 reverse
	形式参数列表:
		int[] arr
方法声明:
	public static void reverse(int[] arr)
*/

/**
* 完成对于int类型数组的逆序过程
*
* @param arr int类型数组
*/
public static void reverse(int[] arr) {
    int temp = 0;
    for (int i = 0; i < arr.length / 2; i++) {
        /*
        arr[0] = arr[9]
        arr[1] = arr[8]
        arr[2] = arr[7]
        arr[3] = arr[6]
        arr[4] = arr[5]
        */
        temp = arr[i];
        arr[i] = arr[arr.length - 1 - i];
        arr[arr.length - 1 - i] = temp;
    }
}

2.2 找出数组中最大值所在下标位置

/*
需求
	从int类型数组中找出对应的最大值下标位置
方法分析:
	public static 不要问
	返回值类型：
		数组的下标数据类型是int类型
		int
	方法名:
		maxIndexOf
	形式参数列表：
		(int[] arr)
方法声明：
	public static int maxIndexOf(int[] arr)
*/

/**
* 返回指定int类型数组中最大值的下标位置
*
* @param arr int类型数组
* @return 返回值是最大值所在的下标位置
*/
public static int maxIndexOf(int[] arr) {
    // 
    int maxIndex = 0;
}

2.3 找出数组中指定元素所在的第一次出现下标位置

/*
需求:
	找出数组中指定元素出现的第一次下标位置
	1. 第一次出现的问题
	2. 多个元素问题
	3. 有可能不存在指定元素。
方法分析:
	public static 不要问
	返回值类型:
		int 因为需要返回下标
		考虑在int范围以内，使用一个明确和正确数据有对立
		关系的数据作为【错误标记】
		找到对应数据 0 ~ array.length -1 
		-1 是一个明确的非法下标
	
	方法名：
		indexOf 找出对应元素所在下标位置
	形式参数列表:
		首先是一个int类型数组
		查询的数据也是int类型
		(int[] arr, int find)
方法声明：
	public static int indexOf(int[] arr, int find)
*/
/**
* 找出指定数组中，指定元素的下标位置，通过返回值返回
*
* @param arr 指定的int类型源数据数组
* @param find 指定需要查询的数据
* @return 返回值大于等于0，表示找到对应的数据，否则返回-1
*/
public static int indexOf(int[] arr, int find) {
	// 首先假设对应查询的数据是不存在的！！！
	int index = -1;
	
	// 利用循环，从下标为0的元素开始到最大下标，比对是否存在find
	for (int i = 0; i < arr.length; i++) {
		// 发现指定find元素和下标为i的元素一致
		if (find == arr[i]) {
			// 使用index保留对应的下标i
			index = i;
			// 终止循环！！！
			break;
		}
	}
	
	return index;
}

2.4 获取数组中指定下标的元素

/*
需求
	找出指定下标的元素
方法分析：
	public static 不要问
	返回值类型：
		数组为int类型，这里返回值也是int类型
	方法名:
		get
	形式参数列表
		指定的数组 int[] arr
		指定的下标 int index
		0 ~ arr.length - 1
方法声明：
	public static int get(int[] arr, int index)
*/
/**
* 找出数组中指定下标的元素
*
* @param arr 指定的int类型数组  
* @param int 指定查询的下标位置
* @return 返回对应下标位置的元素
*/
public static int get(int[] arr, int index) {
	// 用户指定的index不能超出有效下标范围
	if (index < 0 || index > arr.length - 1) {
		/*
		返回任何的数据类型都不合适，可以考虑终止方法，
		并且告知用户错误是什么
		后期课程中可以使用到异常处理
		【用户输入参数合法性判断】
		*/
		System.out.println("Input Parameter is Invalid!");
		// 当前方法退出！！！
		System.exit(0);
	}
	
	return arr[index];
}





















int index) {
	// 用户指定的index不能超出有效下标范围
	if (index < 0 || index > arr.length - 1) {
		/*
		返回任何的数据类型都不合适，可以考虑终止方法，
		并且告知用户错误是什么
		后期课程中可以使用到异常处理
		【用户输入参数合法性判断】
		*/
		System.out.println("Input Parameter is Invalid!");
		// 当前方法退出！！！
		System.exit(0);
	}
	
	return arr[index];
}

3. 作业

1. 数组内存分析图
2. 数组地址转移分析图
3. 代码三遍
4. 笔记
5. 数组练习题