数组操作
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};
```java
// 找出数组中的最小值下标位置
class Demo7 {
public static void main(String[] args) {
int[] arr = {10, 13, 5, 7, 19, 1, 4, 6, 1, 10};
// 找出数组中的最小值下标位置
class Demo7 {
public static void main(String[] args) {
int[] arr = {10, 13, 5, 7, 19, 1, 4, 6, 1, 10};
// 1. 定义变量存储最小值下标位置
int minIndex = 0;
// 2. 利用 for 循环遍历整个数组 找出最小值下标位置,存储到 minIndex 中
for (int i = 1; i < arr.length; i++) {
// 3. 如果 minIndex 对应元素大于 i 对应元素,minIndex 存储对应数据
if (arr[minIndex] > arr[i]) {
minIndex = i;
}
}
// 4. 展示最小值下标位置
System.out.println("最小值下标位置:" + minIndex);
}
}
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};
// 在数组指定下标位置添加元素
class Demo8 {
public static void main(String[] args) {
// 1. 准备源数据数组,指定下标位置 index,和目标添加元素 num
int[] arr = {1, 3, 5, 7, 9, 11, 13, 15, 17, 0};
int index = 0;
int num = 20;
// 2. 判断用户指定的下标位置是否为 合法下标
if (index > arr.length - 1 || index < 0) {
// 提示用户操作失败
System.out.println("您输入的下标不合法!!!");
// 终止程序运行
System.exit(0);
}
/*
3. for 循环完成,循环从最后一个【有效元素】下标位置开始,到用户
指定添加元素下标结束。
*/
for (int i = arr.length - 1; i > index; i--) {
arr[i] = arr[i - 1];
/*
arr[9] = arr[8];
arr[8] = arr[7];
arr[7] = arr[6];
arr[6] = arr[5];
*/
}
// 4. 将元素放入指定下标位置
arr[index] = num;
/*
5. 利用 for 循环展示数组中存储的数据内容
*/
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
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}
/*
删除数组中指定下标元素内容
【注意】用户删除数组中元素,如果用户未持有被删除元素本身,建议在删除
操作过程中,对被删除的元素内容进行一定程度的保护。
*/
class Demo9 {
public static void main(String[] args) {
// 1. 源数据数组
int[] arr = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};
// 2. 指定下标
int index = 0;
// 3. 判断用户给予的下标是否在合法范围以内
if (index < 0 || index > arr.length - 1) {
System.out.println("指定下标不合法!!!");
System.exit(0);
}
// 4. 利用一个变量保护/保存被删除元素内容
int delete = arr[index];
// 5. for 循环移动数据,大致从被删除位置开始,到有效元素位置
for (int i = index; i < arr.length - 1; i++) {
arr[i] = arr[i + 1];
}
// 6. 原最后一个有效位置赋值为 0
arr[arr.length - 1] = 0;
// 7. 展示数组数据情况和被删除元素情况
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
System.out.println("被删除元素:" + delete);
}
}
10. 找出数组中指定元素的所有下标位置
目标数组:
int[] arr = {1, 3, 5, 1, 3, 5, 1, 3, 5};
要求:
1. 目标数据下标位置存储到另一个数组中
例如:
目标数据 1
存储下标的数组中内容 {0, 3, 6}
【核心知识点】
尾插法操作,计数器变量
用于存储下标位置的新数组,容量和源数据数组一致。
class Demo10 {
public static void main(String[] args) {
// 1. 源数据数组
int[] arr = {1, 1, 1, 1, 1, 1, 1, 1, 1};
// 2. 存储下标的新数组,新数组容量和数组容量一致
int[] newArr = new int[arr.length];
// 3. 目标数据
int num = 1;
// 4. 定义一个变量,用于计数操作,同时满足尾插法数据存储要求
// 【有效元素个数】
int count = 0;
// 5. 利用 for 循环找出数组中指定元素所在下标位置
for (int i = 0; i < arr.length; i++) {
// 6. 如果找到了目标元素,对应下标位置存储到新数组中
if (num == arr[i]) {
// 新数组中存储下标 i
newArr[count] = i;
count++;
}
}
if (count > 0) {
// 6. count 记录查询到的元素个数,展示下标情况
for (int i = 0; i < count; i++) {
System.out.println(newArr[i]);
}
} else {
System.out.println("Not Found!!!");
}
}
}
11. 使用新元素替换指定元素
目标数组:
int[] arr = {1, 3, 5, 1, 3, 5, 1, 3, 5}
例如:
使用 10 替换 1 ==> {10, 3, 5, 10, 3, 5, 10, 3, 5};
// 使用新元素替换指定元素
class Demo11 {
public static void main(String[] args) {
// 1. 源数据数组
int[] arr = {1, 3, 5, 1, 3, 5, 1, 3, 5};
// 2. 定义被替换数据变量和新元素变量
int newNum = 10;
int oldNum = 3;
// 3. 利用 for 循环遍历整个数组
for (int i = 0; i < arr.length; i++) {
// 4. 发现 存在目标数据 oldNum 使用 newNum 替换
if (oldNum == arr[i]) {
arr[i] = newNum;
}
}
// 4. 展示数组中元素内容
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}