其他分享
首页 > 其他分享> > 我在千峰培训的第九天---数组练习跟方法练习

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

作者：互联网

文章目录

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

今日感悟

今天没学习啥新知识，还是昨天留的题老师讲了一下。然后让把留的数组的题封装成方法，明天在看。
今天要交钱了，每个人报名时间不同，学费也不同，大概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 类型的数组，容量限制为 10
		int[] 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 对应的元素为 oldNum
			if (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};

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0PxilkZM-1635944993185)(img/01-指定元素添加过程分析.png)]

// 在数组指定下标位置添加元素【难点】
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 的位置添加元素 20
		int 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 ==> true
			arr[9] = arr[9 - 1];
		② i => 8 ==> 8 > 5 ==> true
			arr[8] = arr[8 - 1];
		③ i => 7 ==> 7 > 5 ==> true
			arr[7] = arr[7 - 1];
		④ i => 6 ==> 6 > 5 ==> true
			arr[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 ==> true
		    arr[6] = arr[6 + 1];
		③ i = 7 ==> 7 < 9 ==> true
			arr[7] = arr[7 + 1];
		④ i = 8 ==> 8 < 9 ==> true
			arr[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 = 0
					target[0] = 0;
					count += 1 ==> count = 1
				② 目标数据下标位置 3 count = 1
					target[1] = 3;
					count += 1 ==> count = 2
				③ 目标数据下标位置 6 count = 2
					target[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));
    }
}

标签：第九天,arr,元素,下标,index,int,练习,---,数组
来源： https://blog.csdn.net/qq1379423218/article/details/121130715