我在千峰培训的第九天—数组练习跟方法练习

今日感悟

今天没学习啥新知识，还是昨天留的题老师讲了一下。然后让把留的数组的题封装成方法，明天在看。
今天要交钱了，每个人报名时间不同，学费也不同，大概21000-22000之间。

数组

1. 生活中数组模型

归纳总结，编号处理车位:一个相对统一的数据类型，并且在停车场中大量存在规范化排列:车位是连续存放，并且规规矩矩，整整齐齐编号:每一个车位都有一个唯一的编号这就是一个数组模型，在开发中也会有类似情况下，相同数据类型的大量使用，可以按照【数组】形式进行处理和操作。

2. Java中定义数组的格式【重点】

格式:数据类型[] 数组名 = new 数据类型[容量]; 容量 == Capacity赋值号左侧数据类型:明确当前数组存储的数据类型是哪一个，并且严格遵从数据类型一致化要求，只能存储对应数据类型。[]:1. 表示当前定义的数据类型是数组类型2. 明确数组名是一个【引用数据类型】变量引用数据类型 例如 文章中的引用。1. 跳转性 2. 指向性数组名:1. 数组名是当前操作数组非常重要的名称。例如 停车场 我们的车在【C区】，车位号【200】C区 ==> 数组名 200 ==> 下标 2. 数组名是一个【引用数据类型】变量赋值号右侧new:1. 在内存【堆区】，根据当前数据类型和对应的数组容量，申请对应的存储空间。2. new 根据会将申请的内存【堆区】内存空间所有二进制位全部赋值为 0相当于在【仓库】根据个人所需，申请空间存储商品，同时在申请之后，将仓库位置打扫干净数据类型:前后呼应，明确当前数组中允许存储的数据类型是哪一个，并且只能存储对应类型。[容量]:1. 当前数组允许存储对应数据类型的最多数据个数2. 容量一旦确定，无法修改

3. Java中定义数组和操作

// Java中定义数组和操作数组演示
class Demo1 {public static void main(String[] args) {// 数据类型[] 数组名 = new 数据类型[容量];// 把引用不当引用，这个引用更好用。int[] arr = new int[10];/*数组的【有效下标】数组容量为10，当前数组的有效下标范围0 ~ 9注意:数组的有效下标范围是从 0 开始到数组容量 - 1  *//*赋值数组下标为0的元素数组名[有效下标] ==> 赋值/取值*/arr[0] = 10;// 赋值数组下标为5的元素arr[5] = 20;// 取值展示数组中下标为 0 和下标为 5 的元素System.out.println(arr[0]);System.out.println(arr[5]);}
}

4. 数组内存分析图【重点，难点】

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

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

5. 数组操作

5.1 利用循环给予数组赋值和取值操作

// 利用循环给予数组赋值和取值操作
class Demo3 {public static void main(String[] args) {// 定义一个存储数据类型为 int 类型的数组，容量限制为 10int[] arr = new int[10];/*arr.length. 的获取当前数组容量属性目前 int[] arr = new int[10];  arr.length ==> 10*/// 循环赋值操作for (int i = 0; i < arr.length; i++) {arr[i] = i * 2;}// 利用循环取值数组中的元素内容for (int i = 0; i < arr.length; i++) {System.out.println("arr[" + i + "] = " + arr[i]);}}
}

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

知识点:1. 静态方式赋值数组数据int[] arr = {1, 3, 5, 7, 9, 1, 3, 5, 7, 9};2. break 关键字【重点】功能:1. 跳出【一层】循环结构2. 跳出【一层】switch case 结构

// 找出指定元素在数组中第一次出现的下标位置
class Demo4 {public static void main(String[] args) {// 静态方式赋值数组元素内容int[] arr = {1, 3, 5, 7, 9, 1, 3, 5, 7, 9};// num 用于存储用户指定的元素数据int num = 20;/*index 在数据搜索过程中，用于存储目标数据的下标位置考虑下标位置有可能没有找到。index 初始化为 -1 ，需要考虑未找到目标数据下标位置的情况下有明确的信息提示，告知结果的使用者，数据未找到，-1 是数组的非法下标/无效下标。*/int index = -1;// 利用 for 循环遍历整个数组，判断找出目标数据下标位置for (int i = 0; i < arr.length; i++) {if (num == arr[i]) {// 使用 index 保存下标 i index = i;// 利用 break 跳出/终止循环break;}}// 判断 index 数据保存情况if (index >= 0) {System.out.println("目标数据下标位置 : " + index);} else {System.out.println("Source Not Found 404 !!!");}}
}

5.3 找出指定元素在数中最后一次出现的下标位置

// 找出指定元素在数组中最后一次出现的下标位置
class Demo5 {public static void main(String[] args) {// 静态方式赋值数组元素内容int[] arr = {1, 3, 5, 7, 9, 1, 3, 5, 7, 9};int num = 7;int index = -1;// 利用循环从数组的最后一个有效位置开始，向前遍历数组中的数据内容for (int i = arr.length - 1; i >= 0; i--) {if (arr[i] == num) {index = i;break;}}if (index >= 0) {System.out.println("指定元素最后一次出现的下标位置:" + index);} else {System.out.println("Source Not Found 404");}}
}

5.4 找出指定下标元素数据内容

核心:用户提供的下标数据，是否合法，是否在合理的范围以内。【用户输入数据的合法性判断过程】

// 5.4 找出指定下标元素数据内容
class Demo6 {public static void main(String[] args) {int[] arr = {1, 3, 5, 7, 9, 1, 3, 5, 7, 9};// 提供一个变量，用于保存用户指定的下标数据int index = 5;// 【核心】判断用户提供的下标 index 是否合理合法if (index < 0 || index > arr.length - 1) {System.out.println("您输入的数据不合法!!!");return;}System.out.println(arr[index]);}
}

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

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

// 找出数组中的最大值下标位置
class Demo7 {public static void main(String[] args) {int[] arr = {1, 3, 5, 7, 19, 2, 4, 6, 8, 110};// 假设下标为 0 的元素是最大值下标位置int maxIndex = 0;// 循环下标从 1 开始，因为数组中假设下标为0的元素为最大值，没必要下标 0 再次出现for (int i = 1; i < arr.length; i++) {// maxIndex 对应元素小于 i 对应元素if (arr[maxIndex] < arr[i]) {maxIndex = i;}} System.out.println("最大值下标位置:" + maxIndex);}
}

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

5.7 使用新元素替换指定元素

目标数组:int[] arr = {1, 3, 5, 1, 3, 5, 1, 3, 5}例如:使用 10 替换 1 ==> {10, 3, 5, 10, 3, 5, 10, 3, 5};

/*
使用新元素替换指定元素
目标数组:int[] arr = {1, 3, 5, 1, 3, 5, 1, 3, 5}例如:使用 10 替换 1 ==> {10, 3, 5, 10, 3, 5, 10, 3, 5};
*/
import java.util.Arrays;class Demo1 {public static void main(String[] args) {int[] arr = {1, 3, 5, 1, 3, 5, 1, 3, 5};// oldNum 是指 指定需要被替换的数据int oldNum = 1;// newNum 是替换使用的新数据int newNum = 20;System.out.println("执行操作之前:" + Arrays.toString(arr));// 利用 for 循环遍历整个数组for (int i = 0; i < arr.length; i++) {// 如果发现当前数组中下标 i 对应的元素为 oldNumif (oldNum == arr[i]) {arr[i] = newNum;}}System.out.println("执行操作之后:" + Arrays.toString(arr));}
}

5.8 在数组指定下标位置添加元素【难点】

目标数组:	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};

// 在数组指定下标位置添加元素【难点】
import java.util.Arrays;class Demo2 {public static void main(String[] args) {int[] arr = {1, 3, 5, 7, 9, 11, 13, 15, 17, 0};System.out.println("执行操作之前:" + Arrays.toString(arr));// 在下标 5 的位置添加元素 20int index = 19;int number = 20;// 用户输入数据合法性判断，重点是用户指定插入数据的下标位置必须在合理范围以内if (index < 0 || index > arr.length - 1) {System.out.println("指定下标位置不合法！！！");return;}// 利用 for 循环，从数组最后一个有效元素位置下标开始，到指定插入数据下标结束，进行循环// 控制 【粗加工】for (int i = arr.length - 1; i > index; i--) {arr[i] = arr[i - 1]; // arr[i + 1] = arr[i];}/*for (int i = arr.length - 2; i >= index; i--) {arr[i + 1] = arr[i];}*//*以上循环执行完毕，可以保证，需要移动的数据已经全部操作完成，同时指定下标位置已空出，可以赋值元素。① i => 9 ==> 9 > 5 ==> truearr[9] = arr[9 - 1];② i => 8 ==> 8 > 5 ==> truearr[8] = arr[8 - 1];③ i => 7 ==> 7 > 5 ==> truearr[7] = arr[7 - 1];④ i => 6 ==> 6 > 5 ==> truearr[6] = arr[6 - 1];⑤ i => 5 ==> 5 > 5 ==> false循环终止*/arr[index] = number;System.out.println("执行操作之后:" + Arrays.toString(arr));}
}

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

目标数组: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}

// 在数组中删除指定下标的元素【难点】
import java.util.Arrays;class Demo3 {public static void main(String[] args) {int[] arr = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};System.out.println("执行操作之前:" + Arrays.toString(arr));// index 保存用户指定的下标位置int index = 12;// 保存被删除的数据int number = 0;// 判断用户指定下标位置是否合法if (index < 0 || index > arr.length - 1) {System.out.println("指定下标不符合!!!");return;}// 在执行删除操作之前，保留被删除数据number = arr[index];// 从删除位置开始，到数据的最后一个有效元素结束for (int i = index; i < arr.length - 1; i++) {arr[i] = arr[i + 1];}/*苟磊 20个俯卧撑① i = 5 ==> 5 < 9 ==> true	arr[5] = arr[5 + 1];② i = 6 ==> 6 < 9 ==> truearr[6] = arr[6 + 1];③ i = 7 ==> 7 < 9 ==> truearr[7] = arr[7 + 1];④ i = 8 ==> 8 < 9 ==> truearr[8] = arr[8 + 1];⑤ i = 9 ==> 9 < 9 ==> false循环终止*/arr[arr.length - 1] = 0;System.out.println("执行操作之后:" + Arrays.toString(arr));System.out.println("被删除数据为:" + number);}
}

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

目标数组:int[] arr = {1, 3, 5, 1, 3, 5, 1, 3, 5};要求:1. 目标数据下标位置存储到另一个数组中例如：目标数据 1 存储下标的数组中内容 {0, 3, 6}思考问题:1. 请问存储下标的数组容量是多少???极值/边界思想 最多是当前查询数据的目标数组容量一致的情况，如果比当前要求小，容易出现数据不够放的情况。阈值2. 需要利用尾插法数据存储方式，完成目标数据下标位置在第二个数组中存储的要求【尾插法】【计数器】

// 找出数组中指定元素的所有下标位置
class Demo4 {public static void main(String[] args) {int[] arr = {1, 3, 5, 1, 3, 5, 1, 3, 5};// 1. 目标数据int num = 15;// 2. 存储下标的数组int[] target = new int[arr.length];/*3. 定义一个计数器尾插法核心变量1, 协助记录本次存储数据的下标位置2, 统计当前数组中有多少个有效元素*/int count = 0;for (int i = 0; i < arr.length; i++) {if (num == arr[i]) {target[count] = i;count += 1;/*① 目标数据下标位置 0 count = 0target[0] = 0;count += 1 ==> count = 1② 目标数据下标位置 3 count = 1target[1] = 3;count += 1 ==> count = 2③ 目标数据下标位置 6 count = 2target[2] = 6;count += 1 ==> count = 3最终结果:target = {0, 3, 6, 0, 0, 0, 0, 0, 0 }*/}}// 展示所有的查询下标位置if (count > 0) {for (int i = 0; i < count; i++) {System.out.println(target[i]);}} else {System.out.println("没有数据");}}
} 

一框二看三封装要求1. 完成方法分析过程2. 完成方法声明3. 【注意】a. 方法的返回值不得使用数组类型b. 方法的返回值有且只有一个

5.11 选择排序算法推演

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

5.11.1 找出数组中最大值和下标为0的元素交换位置

5.11.2 接上一题:找出数组中剩余最大值和下标为1的元素交换位

5.11.3 接上一题:找出数组中剩余最大值和下标为2的元素交换位

import java.util.Arrays
class Demo6 {public static void main(String[] args) {int[] arr = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};// 外层循环控制 核心代码重复 次数 10个数据需要进行9次循环产出结果for (int i = 0; i < arr.length - 1; i++) {// 核心内容1 找出数组中从指定位置开始的最大值下标位置int index = i;for (int j = index + 1; j < arr.length; j++) {if (arr[index] < arr[j]) {index = j;}}// 核心内容2 和指定下标位置交换数据if (index != i) {int temp = arr[index];arr[index] = arr[i];arr[i] = temp;}}System.out.println(Arrays.toString(arr));}
}