数组

数组

数组的概念

数组：一组连续的储存空间，储存多个相同数据类型的值

为什么要用到数组

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

数组的定义

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

数组的下标

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

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

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

数组内存分析图

引用数据类型

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

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

获取数组容量的方式

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

数组地址转移问题（重点）

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]);
	}
}

数组地址转移图

数组和方法之间的关系

/*
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]);
		}
	}
}

数组算法

完成一个数组逆序过程

/*
静态数组
	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;
    }
}

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

/*
方法分析:
	public static 不要问
	返回值类型：
		找出对应元素的下标位置，返回值为int类型
	方法名:
		minIndexOfArray
	形式参数列表:
		(int[] array)
方法声明：
	public static int minIndexOfArray(int[] array)
*/
/**
* 找出数组中最小值的下标位置
*
* @param array int类型数组
* @return 返回值是当前数组中最小值的下标位置
*/
public static int minIndexOfArray(int[] array) {
    int minIndex = 0;
    
    for (int i = 1; i < array.length; i++) {
        if (array[minIndex] > array[i]) {
            minIndex = i;
        }
    }
    
    return minIndex;
}

找出数组中指定元素的下标位置

/*
方法分析:
	public static
	返回值类型:
		返回值是数组的下标位置，为int类型
	方法名:
		indexOf
	形式参数列表:
		1. int类型数组
		2. 告知方法指定查询的数据
		(int[] array, int find);
方法声明:
	public static int indexOf(int[] array, int find)
*/
/**
* 找出指定元素的下标位置
* 
* @param array 指定的int类型数组
* @param find 指定查询的数据，为int类型
* @return 找到对应下标位置，返回值大于等于0，没有找到返回-1
*/
public static int indexOf(int[] array, int find) {
	// 这里假设找不到对应的数据
    int index = -1;
    
    // 利用循环遍历数组
    for (int i = 0; i < array.length; i++) {
        // 发现存在数据和指定find数据一致
        if (find == array[i]) {
            // 保留下标
            index = i;
            // 没有继续循环下去的必要，终止循环
            break;
        }
    }
    
    return index;
}

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

/**
* 找出指定下标的元素
*
* @param array 指定的数组 
* @param index 指定的下标位置
* @return 对应当前下标的元素，为int类型
*/
public static int get(int[] array, int index) {
    // 参数合法性判断的思想
    if (index > array.length - 1 || index < 0) {
        System.out.println("Input Parameter is Invalid!");
        System.exit(0);
    }
    
    return array[index];
}

找出指定元素在指定数组中所有下标位置 【难点】

/*
要求：
	a. 不允许在方法内打印展示
	b. 考虑多个数据情况
	c. 需要在方法外获取到下标数据信息
	d. 不允许使用数组作为返回值
【重点】
	1. 尾插法思想，计数器同时也是下一次存放数据的位置
	2. 数组作为方法参数之后，是可以近似数据传导
*/	
package com.qfedu.a_array;

/**
 * 【重点】
 * 
 * @author Anonymous
 */
public class Demo3 {
	public static void main(String[] args) {
		int[] arr = {5, 3, 5, 7, 5, 1, 3, 5, 7, 9};
		int[] indexArr = new int[arr.length];
		
		int count = allIndexOf(arr, indexArr, 5);
		
		// count是查询到的指定元素个数，同时可以利用与循环中，找到对应的元素
		for (int i = 0; i < count; i++) {
			System.out.println(indexArr[i]);
		}
		
	}
	
	/*
	 * 1.3. 找出指定元素在指定数组中所有下标位置 【难点】
	 * 要求：
	 * 		a. 不允许在方法内打印展示
	 * 		b. 考虑多个数据情况
	 * 		c. 需要在方法外获取到下标数据信息
	 * 		d. 不允许使用数组作为返回值
	 * 方法分析:
	 * 		public static 不要问
	 * 		返回值类型:
	 * 			int 返回找到的指定元素个数
	 * 			void 不行！！！少用黑盒方法！！！
	 * 			boolean true false 局限性比较大
	 * 		方法名:
	 * 			allIndexOf tips:感谢雄飞同学的友情提示
	 * 			找出所有指定元素的下标位置
	 * 		形式参数列表:
	 * 			1. 查询数据的源数据数组 int[] arr
	 * 			2. 指定查询的元素  int find
	 * 			3. 和源数据数组容量一致的int类型数组，保存对应的下标位置
	 * 			(int[] arr, int[] indexArr, int find)
	 * 问题：
	 * 		1. 查询数据可能是多个！！！
	 * 		2. 数组不能作为返回值！！！
	 * 		3. 不允许打印！！！
	 * 		4. 外部获取！！！
	 * 思考:
	 * 		1. 保存查询数据的下标位置一定会使用到数组
	 * 		2. 保存下标的数组数据类型是int类型
	 * 解决方案:
	 * 		通过方法为参数形式传入一个数组，int类型，保存找到的下标位置
	 * 思考:
	 * 		保存下标的数组容量如果考虑
	 * 解决方案:
	 * 		哪怕源数据数组中所有数据都是指定的元素，最大容量也就是
	 * 		和源数据数组的容量一致【判断的地方！！！】
	 * 
	 * 问题:
	 * 		有没有可能性下标为0的元素就是目标元素???
	 * 		0是有效下标范围
	 * 
	 * 		new创建一个新的数组，int类型数组中，所有的元素初始值都是0
	 * 		任何判断0是有效下标还是无效数据???
	 * 需求:
	 * 		这里需要一个数据，告知我找到数据到底有多少个
	 * 返回值:
	 * 		找到的指定元素的个数，如果没有找到，返回0 
	 * 
	 * 方法声明:
	 * 		public static int allIndexOf(int[] arr, int[] indexArr, int find)
	 *
	 */
	/**
	 * 找到指定源数据数组中所有指定元素所在的下标位置，保存到indexArr中，并且返回值
	 * 是找到的元素个数
	 * 
	 * @param arr 源数据数组，int类型
	 * @param indexArr 找到的下标位置存储数组，要求该数组的容量不得小于源数据容量
	 * @param find 需要查询的指定数据
	 * @return 返回值大于0，找到的数据个数，没有找到返回0
	 */
	public static int allIndexOf(int[] arr, int[] indexArr, int find) {
		// 参数合法性判断
		if (arr.length > indexArr.length) {
			System.out.println("Input Parameter is Invalid!");
			// 参数不合法，没有找到数据
			return 0;
		}
		
		/*
		 * 定义一个变量，
		 * 		1. 计数器，记录找到的元素个数
		 * 		2. 尾插法当中下一次存放元素的位置
		 */
		int count = 0;
		
		// 利用for循环遍历整个源数据arr数组
		for (int i = 0; i < arr.length; i++) {
			// 找到了对应的元素，需要保存下标i
			if (find == arr[i]) {
				// 保存到indexArr数组中
				// 需要使用尾插法！！！保存下一次存放数据的位置
				indexArr[count] = i; 
				// 计数器 += 1 
				count += 1;
			}
		}
		
		return count;
	}
}

在指定位置插入指定元素【难点】

/*
存在一个数组，数组中的元素为
	int[] array = {1, 3, 5, 7, 9, 11, 13, 15, 17, 0};
	要求
		1. 0是无效元素，仅占位使用
		2. 当前数组中【有效元素】个数为9
	需求
		在该数组中的指定下标位置放入指定元素
【重点】
	1. 空数据，无效数据思想
	2. 数据的移动过程，粗加工，细打磨过程
	3. 时间消耗问题
*/

代码

package com.qfedu.a_array;

import java.util.Arrays;

public class Demo4 {
	public static void main(String[] args) {
		int[] array = {1, 3, 5, 7, 9, 11, 13, 15, 17, 0};
		
		add(array, 9, 20);
		
		System.out.println(Arrays.toString(array));
	}
	
	/*
	1.4 在指定位置插入指定元素【难点】
	存在一个数组，数组中的元素为
		int[] array = {1, 3, 5, 7, 9, 11, 13, 15, 17, 0};
		要求
			1. 0是无效元素，仅占位使用 ==> null
			2. 当前数组中【有效元素】个数为9
		需求
			在该数组中的指定下标位置放入指定元素
	推演过程:
		    在数组下标为5的位置插入元素，从下标5开始
		之后的元素整体向右移动
		    arr[9] = arr[8];
		    arr[8] = arr[7];
		    arr[7] = arr[6];
		    arr[6] = arr[5];
		    arr[5] = 20;
		指定下标为5的位置添加元素，数组中的元素整体
		向后移动的4次
	
	方法分析：
		public static 不要问
		返回值类型:
			void 可用，但是不建议
			boolean 可以 true false 选择boolean类型
			int 可用 返回值的含义约束较为麻烦
		方法名:
			add 添加操作
		形式参数列表：
			1. 需要插入数据的数组
			2. 指定插入数据的下标位置
			3. 指定插入的数据
			(int[] arr, int index, int insert);
	方法声明：
		public static boolean add(int[] arr, int index, int insert);
		
	 */
	/**
	 * 在指定的数组中，指定位置插入指定元素
	 * 
	 * @param arr 指定的int类型数组
	 * @param index 指定的下标位置，必须在合理的区间范围以内
	 * @param insert 指定插入的元素，int类型
	 * @return 添加成功返回true，否则返回false
	 */
	public static boolean add(int[] arr, int index, int insert) {
		// 参数合法性判断
		if (index < 0 || index > arr.length - 1) {
			System.out.println("Input Parameter is Invalid!");
			// 方法运行失败！！！
			return false;
		}
		
		/*
		 arr[9] = arr[8];
		 arr[8] = arr[7];
		 arr[7] = arr[6];
		 arr[6] = arr[5];
		 arr[i] = arr[i - 1];
		 arr[i + 1] = arr[i];
		 
		 arr[5] = 20;
		 */
		for (int i = arr.length - 1; i > index; i--) {
			arr[i] = arr[i - 1];
		}
		
		arr[index] = insert;
		
		return true;
	}
}

删除数组中的指定下标的元素【难点】

/*
存在一个数组，数组中的元素为
	int[] array = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};
	要求:
		1. 0是无效元素，仅占位使用
	需求:
		在当前数组中删除指定下标的元素
	例如:
		指定下标5
		结果 {1, 3, 5, 7, 9, 13, 15, 17, 19, 0} 
		0占位！！！
*/

package com.qfedu.a_array;

import java.util.Arrays;

public class Demo5 {
	public static void main(String[] args) {
		int[] array = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};
		remove(array, 9);
		
		System.out.println(Arrays.toString(array));
	}
	/*
	1.5 删除数组中的指定下标的元素【难点】
	存在一个数组，数组中的元素为
		int[] array = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};
		要求:
			1. 0是无效元素，仅占位使用
		需求:
			在当前数组中删除指定下标的元素
		例如:
			指定下标5
			结果 {1, 3, 5, 7, 9, 13, 15, 17, 19, 0} 
			0占位！！！
	推理过程:
		    从删除位置开始，之后的元素整体向前移动，
		并且需要在数组原本最后一个位置上存放元素0,0
		是无效元素，占位使用
		    arr[3] = arr[4];
		    arr[4] = arr[5];
		    arr[5] = arr[6];
		    arr[6] = arr[7];
		    arr[7] = arr[8];
		    arr[8] = arr[9];
		    arr[i] = arr[i + 1];
		    arr[i - 1] = arr[i];
		    arr[9] = 0;
	方法分析：
		public static 不要问
		返回值类型:
			boolean
		方法名:
			remove
		形式参数列表:
			1. 删除数据的数组
			2. 指定删除数据的下标位置
	方法声明:
		public static boolean remove(int[] arr, int index)
	*/
	/**
	 * 删除数组中指定下标元素的内容
	 * 
	 * @param arr 源数据数组，int类类型
	 * @param index 指定删除的下标位置
	 * @return 删除操作成功返回true，失败返回false
	 */
	public static boolean remove(int[] arr, int index) {
		// 参数合法性判断
		// index < 0 || index >= arr.length
		if (index < 0 || index > arr.length - 1) {
			System.out.println("Input Parameter is Invalid");
			return false;
		}
		
		/*
		    arr[3] = arr[4];
		    arr[4] = arr[5];
		    arr[5] = arr[6];
		    arr[6] = arr[7];
		    arr[7] = arr[8];
		    arr[8] = arr[9];
		    arr[i] = arr[i + 1];
		    从删除位置开始，到数组的最后一个有效元素位置结束
		 */
		for (int i = index; i < arr.length - 1; i++) {
			arr[i] = arr[i + 1];
		}
		
		// 最后一位数据赋值为0，占位，同时告知用户这是一个无效数据
		arr[arr.length - 1] = 0;
		return true;
	}
}

找出数组中最大值元素，放到下标为0的位置

int[] arr = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 10 };
System.out.println(Arrays.toString(arr));

// 假设最大值的下标位置为0
int index = 0;

// 这里一定可以得到最大值所在的下标位置
for (int i = 1; i < arr.length; i++) {
	if (arr[index] < arr[i]) {
		index = i;
	}
}

// 交换数据
if (index != 0) {
	int temp = arr[0];
	arr[0] = arr[index];
	arr[index] = temp;
}

System.out.println(Arrays.toString(arr));

接上一题，找出数组中剩余元素的最大值，放到下标为1的位置

int index1 = 1;

for (int i = 2; i < arr.length; i++) {
	if (arr[index1] < arr[i]) {
		index1 = i;
	}
}

if (index1 != 1) {
	int temp = arr[1];
	arr[1] = arr[index1];
	arr[index1] = temp;
}

System.out.println(Arrays.toString(arr));

再接上一题，找出数组中剩余元素的最大值，放到下标为2的位置

int index2 = 2;

for (int i = 3; i < arr.length; i++) {
	if (arr[index2] < arr[i]) {
		index2 = i;
	}
}

if (index2 != 2) {
	int temp = arr[2];
	arr[2] = arr[index2];
	arr[index2] = temp;
}

System.out.println(Arrays.toString(arr));

选择排序算法

package com.qfedu.a_array;

import java.util.Arrays;

public class Demo7 {
	public static void main(String[] args) {
		int[] arr = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 10 };
		System.out.println(Arrays.toString(arr));
		
		selectSort(arr);
		
		System.out.println(Arrays.toString(arr));
	}
	
	/*
	 * 选择排序算法
	 * 方法分析：
	 * 		public static 不要问
	 * 		返回值类型:
	 * 			void
	 * 		方法名:
	 * 			selectSort
	 * 		形式参数列表:
	 * 			需要处理一个int类型数据
	 * 			(int[] arr)
	 * 
	 * 方法声明:
	 * 		public static void selectSort(int[] arr)
	 */
	
	/**
	 * 选择排序算法
	 * 
	 * @param arr 需要进行排序的int类型数据
	 */
	public static void selectSort(int[] arr) {
		// 外层循环控制核心算法的循环次数
		for (int i = 0; i < arr.length - 1; i++) {
			// 从index位置开始找寻极值
			int index = i;
			
			for (int j = i + 1; j < arr.length; j++) {
				if (arr[index] > arr[j]) {
					index = j;
				}
			}
			
			if (index != i) {
				int temp = arr[i];
				arr[i] = arr[index];
				arr[index] = temp;
			}
		}
	}
}

Arrays数组工具类使用

数组的工具类:
	提供了数组操作的基本方法
	sort(int[] arr);
		经过XXX,XXX,XXX三个大牛优化的利用XXX技术完成的快速排序算法
	binarySearch(int[] arr, int find);
		二分法查询，要求数组是有序的。
	toString(任何类型数组);
		把数组内容作出一个String类型字符串返回值
		{1, 3, 5, 7, 9} ==> [1, 3, 5, 7, 9]