Day07

数组操作

1. 数组和 for 循环不得不说的秘密

数组是一个连续数据存储空间，同时带有下标性质操作，下标范围是 0 ~ 数组容量 - 1 ==> 利用循环来进行操作。

// 利用 for 循环给予数组中的每一个元素进行赋值操作
// 利用 for 循环展示数组中的每一个元素数据存储内容
class Demo1 {
	public static void main(String[] args) {
		// 1. 定义一个 int 类型数组
		int[] arr = new int[10];
		
		/*
		2. 利用 for 循环进行赋值操作
		数组下标从 0 开始，到数组容量 - 1，步进关系为 1 
		*/
		for (int i = 0; i < arr.length; i++) {
			arr[i] = i * 2;
		}
		
		/*
		3. 利用 for 循环展示数组中存储的数据内容
		*/
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
	}
}

2. 找出数组中指定元素第一次出现的下标位置

需求分析：
	1. 在目标数组中找出对应的元素下标位置，如果找到，返回对应下标，如果没有找到，怎么办???
		-1 ???
		目标数据已找到，返回对应下标 ==> 0 ~ 数组容量 - 1 【合法下标范围】
		-1 一定是一个非法下标，可以用于表名当前目标数据在数组中不存在。
		【标记】
	2. 数组中有没有可能出现相同元素多个存在???
		一定有可能，如何保证找到的元素确定是第一次出现的元素???
		发现找到第一个目标元素下标位置，需要终止循环！！！可以利用 break 关键字跳出循环，
		break关键字有且只可以跳出一层循环结构。

/*
2. 找出数组中指定元素第一次出现的下标位置
*/
class Demo2 {
	public static void main(String[] args) {
		/*
		1. 定义一个 int 类型数组，并且进行数据赋值操作
		静态数组创建方式
			a. 数组容量由大括号中有多少个元素决定
			b. 数组数据存储情况根据当前大括号中数据元素内容决定
		*/
		int[] arr = {1, 3, 5, 7, 9, 1, 3, 5, 7, 9};
		// 目标查询元素
		int num = 5;
		
		/*
		2. 定义一个变量存储目标数据下标位置
			a. 后期需要利用 for 循环遍历数组，同时 if 判断找出对应元素下标位置
			b. 如果 if 判断结果为 true， index 重新被赋值，赋值内容就是目标下标位置
			c. 如果 if 判断结果始终为 false, 目标元素不存在，index值还是 -1 可以用于提示
			后续使用者，目标元素在当前数组中不存在，
		*/
		int index = -1;
		
		/*
		3. 利用 for 循环遍历整个数组，if 判断找出目标元素下标位置
		*/
		for (int i = 0; i < arr.length; i++) {
			// 判断数组中下标为 i 的元素是否和用户指定数据 num 一致
			if (num == arr[i]) {
				// index 保存当前下标内容
				index = i;
				// 利用 break 关键字跳出循环结构
				break;
			}
		}
		
		// 4. 判断 index 数据情况，得到目标是否存在，和存在对应下标位置
		if (index > -1) {
			System.out.println("目标元素所在下标位置:" + index);
		} else {
			System.out.println("Source Not Found!!!(未找到)");
		}
	}
}

3. 找出数组中指定元素最后一次出现的下标位置

整体代码流程和找出数组中指定元素第一次出现下标位置一致，但是需要从数组的最后一个下标位置向前找出对应元素。

// 找出数组中指定元素最后一次出现的下标位置
class Demo3 {
	public static void main(String[] args) {
		// 1. 数组准备，选择 int 类型数组
		int[] arr = {1, 3, 5, 7, 9, 1, 3, 5, 7, 9};
		// 2. 准备查询的目标数据
		int num = 15;
		
		// 3. 定义变量 index 用于存储目标数据在数组中最后一个下标位置情况，初始化为 -1
		int index = -1;
		
		/*
		4. for 循环从数组最后一个有效元素下标位置开始，倒置循环，到下标为0终止，步进关系i--
		循环条件终止为 i >= 0 因为 0 是数组元素的有效下标，需要在循环中遍历操作。如果遗漏，
		有可能导致数据结果不正确
		*/
		for (int i = arr.length - 1; i >= 0; i--) {
			/*
			5. 判断数组中下标 i 的元素和目标指定数据一致，保留对应 i 数据，终止循环
			*/
			if (num == arr[i]) {
				index = i;
				break;
			}
		}
		
		// 6. 判断 index 数据情况，得到目标是否存在，和存在对应下标位置
		if (index > -1) {
			System.out.println("目标元素最后出现的下标位置:" + index);
		} else {
			System.out.println("Source Not Found!!!(未找到)");
		}
	}
}

4. 数组元素逆序

要求:
	原数组:
		int[] arr = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};
	逆序之后:
		arr ===> {10, 8, 6, 4, 2, 9, 7, 5, 3, 1};

逆序操作
	1. 需要进行数据的前后交换
	2. 交换数据的次数 = 数组容量 / 2 
		例如:
			10 / 2 ==> 5 
			9 / 2 ==> 4
	3. 循环从下标为0的元素开始，小于计算得到的需要进行交换数据的次数
		例如 
			需要交换五次
			开始下标 0 ~ 4 ==> 5 末尾下标是 9 ~ 5
	4. 推演
		arr[0] <==> arr[9];
		arr[1] <==> arr[8];
		arr[2] <==> arr[7];
		假设循环变量为 i
			arr[i] <==> arr[arr.length - 1 - i];
		

// 数组元素逆序
class Demo4 {
	public static void main(String[] args) {
		// 1. 源数据数组
		int[] arr = {1, 3, 5, 7, 9, 2, 4, 6, 8};
		
		// 2. 利用 for 循环逆序数组内容
		for (int i = 0; i < arr.length / 2; i++) {
			int temp = arr[i];
			arr[i] = arr[arr.length - 1 - i];
			arr[arr.length - 1 - i] = temp;
		}
		
		// 3. 展示数据存储结果
		for (int i = 0; i < arr.length; i++) {
			System.out.println(arr[i]);
		}
	}
}

5. 复制数组数据到新数组

要求:
	源数据数组
		int[] arr = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10}
	复制数组中 下标 3 到 下标 6 之间的数据到新数组
	新数组数据容量和内容如下
		int[] newArr = {7, 9, 2}

流程:
	1. 新数组容量多少???
		新数组容量 => 大下标 - 小下标
		例如:
			下标 3 到 下标 6  ==> 6 - 3 ==> 3 newCapacity
	2. 需要从数组中复制数据到新数组内，采用的限制条件是要头不要尾
		[3, 6) ==> 要下标3元素内容，不需要下标6数据内容
		for (int i = 3; i < 6; i++) {
			newArr[0] = arr[3];
			newArr[1] = arr[4];
			newArr[2] = arr[5];
			// count == 3;
		}
	3. 【计数器】
		初始化为 0 每一次复制数据，累加 1
		count 有两个作用:
			1. 记录当前数组中有多少个有效元素
			2. 作为下一次存放元素的下标位置
		int count = 0;
		for (int i = 3; i < 6; i++) {
			newArr[count] = arr[i];
			count++;
		}

6. 找出数组中的最大值下标位置

目标数组:
	int[] arr = {1, 3, 5, 7, 19, 2, 4, 6, 8, 10};
/*
思路:
	1. 定义一个变量 
		int maxIndex = 0; 假设下标为 0 的元素为最大值。
	2. 从下标 1 开始，和 maxIndex 对应下标元素进行比较，如果发现 maxIndex 元素小于对应元素，maxIndex 存储对应元素下标。
	例如:
		arr[maxIndex] < arr[1]; ==> arr[0] < arr[1];
		maxIndex = 1;
		arr[maxIndex] < arr[2]; ==> arr[1] < arr[2];
		maxIndex = 2;
		arr[maxIndex] < arr[3]; ==> arr[2] < arr[3];
		maxIndex = 3;
		arr[maxIndex] < arr[4]; ==> arr[3] < arr[4];
		maxIndex = 4;
		arr[maxIndex] < arr[5]; ==> arr[4] < arr[5];
		maxIndex 保持;
		......
*/

// 找出数组中的最大值下标位置
class Demo6 {
	public static void main(String[] args) {
		// 1. 源数据数组
		int[] arr = {100, 3, 5, 7, 19, 2, 4, 6, 8, 20};
		
		// 2. 假设下标为 0 的元素为最大值，使用 int 类型变量 maxIndex 保存
		int maxIndex = 0;
		
		// 3. for 循环从下标为 1 的元素开始，到整个数组的最后一个元素，进行两两比较，最大值下标
		// 存储到 maxIndex 中
		for (int i = 1; i < arr.length; i++) {
			// 4. 如果 maxIndex 下标对应元素，小于下标为 i 的元素，maxIndex 存储下标 i
			if (arr[maxIndex] < arr[i]) {
				maxIndex = i;
			}
		}
		
		// 4. 展示最大值下标数据情况
		System.out.println("最大值下标位置:" + maxIndex);
	}
}

7. 找出数组中的最小值下标位置

目标数组:
	int[] arr = {10, 13, 5, 7, 19, 2, 4, 6, 8, 10};

8. 找出数组中指定下标元素

目标数组:
	int[] arr = {10, 13, 5, 7, 19, 2, 4, 6, 8, 10};

9. 在数组指定下标位置添加元素

目标数组:	
	int[] arr = {1, 3, 5, 7, 9, 11, 13, 15, 17, 0};
	注意:
		1. 0 无效元素，仅占位使用
		2. 插入数据下标的位置必须在合法范围以内
		例如：
			添加指定元素 20 到下标为 5 的位置
			{1, 3, 5, 7, 9, 20, 11, 13, 15, 17};

10. 删除数组中指定下标元素内容

目标数组:
	int[] arr = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};
	注意:
		1. 0 是无效元素，仅占位使用
		2. 删除之后，要求数组元素向前移动
		3. 删除数据下标的位置必须在合法范围以内
		例如:
			删除指定下标 5 的元素
            {1, 3, 5, 7, 9, 13, 15, 17, 19, 0}