07_Java基础语法_第7天（练习）_讲义

浅浅的花香味﹌ 2022-05-10 12:34 203阅读 0赞

今日内容介绍  
1、循环练习  
2、数组方法练习  
第1章 循环练习  
1.1 编写程序求 1+3+5+7+……+99 的和值。  
题目分析：  
通过观察发现，本题目要实现的奇数（范围1-100之间）的累加和。

1.  为了记录累加和的值，我们需要定义一个存储累加和的变量
2.  我们要获取到1-100范围内的数
3.  判断当前数是否为奇数，是奇数，完成累加和操作
4.  累加完毕后，最终显示下累加和的值  
    解题步骤：
5.  定义一个用来记录累加和的变量
6.  使用for循环语句，完成1-100之间每个数的获取
7.  使用if条件语句，判断当前数是否是奇数，是奇数，进行累加和操作
8.  使用输出语句，打印累加和变量的值

/*
    	要求：
    		计算1-100之间的所有的奇数和
    		1+3+5+7+...99
    		
    		有1个数据,从0变到100 循环 int = 0; <= 100 ++
    		从0-100范围内,找到奇数 数&2==1 奇数
    		所有的奇数求和计算
    		需要变量,保存奇数的求和
    		
    		实现步骤：
    			1.程序可以使用到的数据,预先定义好变量
    				需要存储奇数和的变量
    			2.利用循环,让变量从0变化到100
    			3.判断变量的变化情况是不是奇数
    			4.如果是奇数,和预先定义好的变量,求和
    			
    		简化求奇数和/实现步骤：
    			1.程序可以使用到的数据,预先定义好变量
    				需要存储奇数和的变量
    			2.利用循环,让变量从1变化到100  i += 2 遍历找到1-100内所有奇数
    			3.和预先定义好的变量,求和
    */
    public class LoopTest{
    	public static void main(String[] args){
    		//定义变量,保存求和
    		int sum = 0;
    		//for循环,循环中的变量，0-1100
    		for(int i = 0; i <= 100; i++){
    			//对循环的变量,进行奇数的判断 %2 ==1-100之间的所有的奇数和
    			if(i % 2 == 1){
    				//对奇数求和
    				sum += i;
    			}
    		}
    		System.out.println(sum);
    		
    		sum = 0;
    		//简化奇数求和
    		for(int i = 1; i <= 100; i += 2){
    			//对奇数求和
    			sum += i;
    		}
    		System.out.println(sum);
    	}
    	
    }

![在这里插入图片描述][70]  
1.2 输出所有的水仙花数，所谓水仙花数是指一个数3位数，其每位数字立方和等于其本身，  
如153 = 1*1*1 + 3*3*3 + 5*5*5  
题目分析：  
通过观察发现，本题目要实现打印符合要求的数字（即水仙花数）。

1.  明确什么样的数就是水仙花数。水仙花数是指一个3位数（100-999之间），其每位数字立方之和等于该3位数本身。如153 = 1*1*1 + 3*3*3 + 5*5*5，  
    即 3位数本身 = 百位数立方 + 十位数立方 + 个位数立方;
2.  获取水仙花范围内的所有3位数（100-999之间的每个3位数）
3.  判断该3位数是否满足水仙花数，满足，打印该3位数  
    解题步骤：
4.  使用for循环，得到100-999之间的每个3位数
5.  获取3位数中百位数字、十位数字、个位数字
6.  使用if条件语句，判断该3位数是否满足水仙花数，满足，使用输出语句，打印该3位数  
    代码如下：

/*
    	要求：计算出水仙花数
    		三位数 100-999 个位数的立方 + 十位数的立方 + 百位数的立方 = 自己的本身
    		153 = 1*1*1 + 5*5*5 + 3*3*3
    		已知三位数 123 获取出每个数位 利用除法 取模运算
    		
    		实现步骤：
    			1.定义变量存储 三个数位的整数
    			2.利用循环,循环中的变量,从100变化到999
    			3.循环中得到的三位数,利用算法,拆解成三个单独的数位
    			4.将三个数位分别立方求和计算,计算后的求和,和她自己进行比较判断
    				符合,就是水仙花
    */
    public class LoopTest_1{
    	public static void main(String[] args){
    		//1.定义三个数位的变量
    		int bai = 0;
    		int shi = 0;
    		int ge = 0;
    		
    		//2.利用循环,循环中的变量,从100变化到999
    		for(int i = 100; i <= 999; i++){
    			//3.循环中得到的三位数,利用算法,拆解成三个单独的数位
    			bai = i / 100;
    			
    			shi = i /10 % 10;
    			
    			ge = i % 10;
    			
    			//4.将三个数位分别立方求和计算,计算后的求和,和她自己进行比较判断
    			if(bai * bai * bai + shi * shi * shi + ge * ge * ge == i){
    				System.out.println("水仙花数：" + i);
    			}
    		}
    	}
    	
    }

![在这里插入图片描述][70 1]  
1.3 ASCII编码表  
American Standard Code for Information Interchange，美国标准信息交换代码.  
在计算机中，所有的数据在存储和运算时都要使用二进制数表示, a、b、c、d这样的52个字母（包括大写）、以及0、1等数字还有一些常用的符号, 在计算机中存储时也要使用二进制数来表示，而具体用哪些二进制数字表示哪个符号，当然每个人都可以约定自己的一套（这就叫编码），而大家如果要想互相通信而不造成混乱，那么大家就必须使用相同的编码规则，于是美国有关的标准化组织就出台了ASCII编码，统一规定了上述常用符号用哪些二进制数来表示。  
![在这里插入图片描述][70 2]  
数字0-9对应ASCII编码十进制为48-57, 字母a-z对应ASCII编码十进制为97-122，字母A-Z对应ASCII编码十进制为65-90

/*
    	ASCII编码演示
    	字符Java数据类型,char
    	整数Java数据类型,int
    	
    	int 类型和char数据类型转换
    	char两个字节  int四个字节
    	short类型有两个字节
    	
    	char转成int类型的时候,类型自动提示,char数据类型,会查询编码表,得到整数
    	
    	int 转成char类型的时候,强制类型转换,会查询编码表
    	
    	char存储汉字,查询Unicode编码表
    		一个汉字需要两个字节存储
    	
    	char类型可以和int计算,提升为int类型,内存中两个字节
    	char类型取值范围0-65535
    */
    public class LoopTest_2{
    	public static void main(String[] args){
    		char c = 'a';
    		int i = c + 1;//小的范围到大的范围自动转换
    		System.out.println(i);
    		
    		int j = 90;
    		char h = (char)j;//大的范围转换成小的范围,需要强制转换
    		System.out.println(h);
    		
    		System.out.println((char)6);
    		
    		char k = '你';
    		System.out.println(k);
    		
    		//涉及short类型和char类型取值范围不同的原因
    		char m = 65536;
    	}
    	
    }

![在这里插入图片描述][70 3]  
![在这里插入图片描述][70 4]  
**short类型与int类型取值范围不同的原因：**  
![在这里插入图片描述][70 5]  
![在这里插入图片描述][70 6]  
![在这里插入图片描述][70 7]  
1.4 利用for循环打印ABCDEFG…XYZ，26个大写字母与26个小写字母  
题目分析：  
通过观察发现，本题目要实现打印26个大写字母、26个小写字母

1.  一共26个大小写字母，那么，可以考虑循环26次。在每次循环中，完成指定字母的大小写打印
2.  找出ABCDEFG…XYZ这些字母之间的变化规律  
    通过ASCII表发现，后面的字母比它前面的字母，ASCII值大1  
    下一个字母 = 上一个字母 + 1  
    如： A B C D  
    65 66 67 68
    
    1.  在每次循环中打印上一个字母大小写，并指定下一个字母  
        解题步骤：
3.  定义初始化大写变量，值为’A’； 初始化小写变量，值为’a’
4.  使用for循环，进行26次循环
5.  在每次循环中，打印大写字母、小写字母。  
    每次打印完成后，更新大写字母值、小写字母值  
    代码如下：

/*
    	利用循环,输出字母包含大写小写,52个
    	输出A-Z a-z
    	利用编码表实现,字母和数字的对应关系
    	A-Z:65-90
    	a-z:97-122
    	
    	类的名字：首字母大写，第二个单词首字母大写 例如：BeiJngShiHaiDiangQuYiYuan
    		public class HelloWorld{   
    				
    		方法的名字：首字母小写，每个单词首字母大写 例如：addSchool
    		
    		public static void main(String[] args){		//2.定义主方法
    		
    	实现步骤：
    		1.定义变量,保存小写a,大写A
    		2.输出26次,输出定义好的变量
    			每次循环,小写变量,大写变量分别++,并且打印
    		
    */
    public class LoopTest_3{
    	public static void main(String[] args){
    		//定义变量,保存2个字母
    		char xiaoXie = 'a';
    		char daXie = 'A';
    		
    		//定义循环,次数26次
    		for(int i = 0; i < 26; i++){
    			//输出保存字母的变量
    			//System.out.println(xiaoXie +  daXie);//这里千万不能这样,否则会出现两个char类型自动转成int类型,数字相加,打印一串数字
    			//字符串数据和其他数据中间为+，结果是字符串拼接
    			System.out.println(xiaoXie + " " + daXie);
    			xiaoXie++;
    			daXie++;
    		}
    	}
    	
    }

![在这里插入图片描述][70 8]  
![在这里插入图片描述][70 9]  
1.5 利用for循环打印 9*9 表?  
如：  
1*1=1  
1*2=2 2*2=4  
1*3=3 2*3=6 3\*3=9

题目分析：  
通过观察发现，如果把1*1=1这样的内容 看做一颗*的话，那么打印结果就成了如下效果：

*
    	**
    	***
    	…

这样，就是打印9行星，每行打印星的个数与当前行数相等。  
再观察“1*3=3 2*3=6 3*3=9”得出它们如下的变化规律：  
每行第n次 +"*"+ 行号 +"="+ 每行第n次 \* 行号

如:	1	+"*"+  2    +"="+   1*2; // 相当于1*2=2
           	2	+"*"+  2    +"="+   2*2; // 相当于2*2=4

解题步骤：

1.  定义一个外层for循环，初始值从1开始，循环9次。用来控制打印的行数
2.  在外层for循环内部，定义一个for循环，初始值从1开始，循环次数与当前行数相等。用来完成每行打印指定次数的乘法公式 如1\*1=1
3.  在内层for循环中，完成每行指定次数的乘法公式打印 如1\*1=1

System.out.print(k +"*"+ j +"="+ j*k +"\t");
    // 变量k代表：每行中的第n次
    // 变量j代表：行号

1.  在外循环中，当每行指定次数的乘法公式打印完毕后，通过System.out.println()切换到下一行。这样，再次打印乘法公式时，就在下一行输出打印了  
    ![在这里插入图片描述][70 10]

/*
    	利用嵌套for循环,实现99乘法表
    	实现步骤：
    		1.定义外循环控制行数
    		2.内循环控制个数,个数每次都在递增
    		3.循环中输出,乘法表的格式
    		
    */
    import java.util.Scanner;
    
    public class LoopTest_4{
    	public static void main(String[] args){
    		Scanner sn = new Scanner(System.in);
    		System.out.println("请输入你想打印乘法表的维数：");
    		int index = sn.nextInt();
    		//"*"不能写成'*'因为+是字符串拼接,不是字符拼接
    		System.out.println("如下打印 " + index + "*" + index + " 乘法表：");
    		print99(index);
    	}
    	public static void print99(int index){
    		//定义外循环控制行数
    		for(int i = 1; i <= index; i++){
    			//定义内循环,每次递增,循环条件
    			for(int j = 1; j <= i; j++){
    				//按照标准格式,输出打印   "\t"--tab键
    				System.out.print(j + "*" + i + "=" + i*j + "\t");
    			}
    			System.out.println();
    		}
    	}
    	
    }

![在这里插入图片描述][70 11]  
第2章 数组方法练习  
2.1 定义打印数组元素方法,按照给定的格式打印\[11, 33, 44, 22, 55\]  
题目分析：  
通过观察发现，本题目要实现按照指定格式，打印数组元素操作

1.  通过循环，我们可以完成数组中元素的获取，数组名\[索引\]
2.  观察发现，每个数组元素之间加入了一个逗号”,”进行分隔；并且，整个数组的前后有一对中括号”\[\]”包裹数组所有元素。  
    解题步骤：
3.  使用输出语句完成打印 左边的中括号”\[”
4.  使用循环，输出数组元素值。输出元素值分为两种情况，如下：  
    a) 最后一个数组元素，加上一个右边的中括号”\]”  
    b) 非最后一个数组元素，加上一个逗号”,”  
    代码如下：

/*
    	定义方法,实现数组的遍历
    	遍历中,输出结果[11, 33, 44, 22, 55]
    	int[] arr = {3,4,45,7}
    	结果包含字符串,[],
    	实现步骤：
    		1.定义方法实现数组的遍历
    		2.先打印括号--[ 
    		3.遍历数组
    			判断是否遍历到了数组的最后一个元素,如果是最后一个元素,输出括号]  
    			(这里打印最后一个元素需要换行,保证下次调用该方法,不会显示在同一行)
    			否则：输出数组的元素和逗号(这里打印元素不需要换行,保证元素打印在同一行中)
    
    */
    public class ArrayMethodTest{
    	public static void main(String[] args){
    		int[] arr = {11, 33, 44, 22, 55};
    		print(arr);
    		
    		int[] arr1 = {11, 33, 44, 22, 55};
    		print(arr1);
    	}
    	/*
    		定义方法实现数组的遍历
    		返回值？void
    		参数？数组
    	*/
    	public static void print(int[] arr){
    		//1.打印括号[
    		System.out.print("[");
    		//2.遍历数组
    		for(int i = 0; i < arr.length; i++){
    			//3.判断是否遍历到了数组的最后一个元素,如果是最后一个元素,输出括号] 
    			if(i == arr.length - 1){
    				System.out.println(arr[i] + "]");
    			}else{
    				//否则：输出数组的元素和逗号(这里打印元素不需要换行,保证元素打印在同一行中)
    				System.out.print(arr[i] + ",");
    			}
    		}
    	}
    	
    }

![在这里插入图片描述][70 12]  
2.2 数组元素逆序  
图解：  
![在这里插入图片描述][70 13]  
题目分析：  
通过观察发现，本题目要实现原数组元素倒序存放操作。即原数组存储元素为\{11,22,33,44\}，逆序后为原数组存储元素变为\{44,33,22,11\}。

1.  通过图解发现，想完成数组元素逆序，其实就是把数组中索引为start与end的元素进行互换。
2.  每次互换后，start索引位置后移，end索引位置前移，再进行互换
3.  直到start位置超越了end位置，互换结束，此时，数组元素逆序完成。  
    解题步骤：
4.  定义两个索引变量start值为0，变量end值为数组长度减去1（即数组最后一个元素索引）
5.  使用循环，完成数组索引start位置元素与end位置元素值互换。
6.  在循环换过程中，每次互换结束后，start位置后移1，end位置前移1
7.  在循环换过程中，最先判断start位置是否超越了end位置，若已超越，则跳出循环  
    代码如下：  
    ![在这里插入图片描述][70 14]

/*
    	数组的逆序：
    		数组中的元素,进行位置上的交换(这才叫真正数组的逆序,并不是倒序输出)
    		逆序 不等于 反向遍历
    		数组中最远的两个索引,进行位置交换,实现数组逆序
    		使用的是数组的指针思想,就是变量,思想,可以随时交换位置
    	实现步骤：
    		1.定义方法,实现数组的逆序
    		2.遍历数组
    			实现数组的最远索引换位置
    			使用临时的第三方变量
    
    */
    public class ArrayMethodTest_1{
    	public static void main(String[] args){
    		int[] arr = {11, 33, 44, 22, 55};
    		//调用数组的逆序方法
    		reverse(arr);
    		//看到数组的元素,遍历
    		printArray(arr);
    		
    	}
    	/*
    		定义方法,实现数组的逆序
    		返回值：没有返回值
    		参数：数组就是参数
    	*/
    	public static void reverse(int[] arr){
    		//利用循环,实现数组遍历,遍历过程中,最远端换位
    		//for的第一项,定义2个变量,最后,两个变量++ --
    		for(int min = 0,max = arr.length-1; min < max; min++,max--){
    			//对数组中的元素,进行位置交换
    			//min索引和max索引的元素交换
    			//定义变量,保存min索引
    			int temp = arr[min];
    			//max索引上的元素,赋值给min索引
    			arr[min] = arr[max];
    			//临时变量,保存的数据,赋值给max索引上
    			arr[max] = temp;
    		}
    	}
    	/*
    		定义方法实现数组的遍历
    		返回值？void
    		参数？数组
    	*/
    	public static void printArray(int[] arr){
    		//1.打印括号[
    		System.out.print("[");
    		//2.遍历数组
    		for(int i = 0; i < arr.length; i++){
    			//3.判断是否遍历到了数组的最后一个元素,如果是最后一个元素,输出括号] 
    			if(i == arr.length - 1){
    				System.out.println(arr[i] + "]");
    			}else{
    				//否则：输出数组的元素和逗号(这里打印元素不需要换行,保证元素打印在同一行中)
    				System.out.print(arr[i] + ",");
    			}
    		}
    	}
    	
    }

![在这里插入图片描述][70 15]  
2.3 数组元素选择排序  
图解：  
![在这里插入图片描述][70 16]  
题目分析：  
通过观察发现，本题目要实现把数组元素\{13,46,22,65,3\}进行排序

1.  提到数组排序，就要进行元素值大小的比较，通过上图发现，我们想完成排序要经过若干次的比较才能够完成。
2.  上图中用每圈要比较的第一个元素与该元素后面的数组元素依次比较到数组的最后一个元素，把小的值放在第一个数组元素中，数组循环一圈后，则把最小元素值互换到了第一个元素中。
3.  数组再循环一圈后，把第二小的元素值互换到了第二个元素中。按照这种方式，数组循环多圈以后，就完成了数组元素的排序。这种排序方式我们称为选择排序。  
    解题步骤：
4.  使用for循环（外层循环），指定数组要循环的圈数（通过图解可知，数组循环的圈数为数组长度 - 1）
5.  在每一圈中，通过for循环（内层循环）完成数组要比较的第一个元素与该元素后面的数组元素依次比较到数组的最后一个元素，把小的值放在第一个数组元素中
6.  在每一圈中，要参与比较的第一个元素由第几圈循环来决定。如上图所示  
    a) 进行第一圈元素比较时，要比较的第一个元素为数组第一个元素，即索引为0的元素  
    b) 进行第二圈元素比较时，要比较的第一个元素为数组第二个元素，即索引为1的元素  
    c) 依次类推，得出结论：进行第n圈元素比较时，要比较的第一个元素为数组第n个元素，即数组索引为n-1的元素  
    ![在这里插入图片描述][70 17]  
    ![在这里插入图片描述][70 18]

/*
    	数组的排序：一般都是升序排列,元素,小到大的排列
    	
    	两种排序的方式：
    		选择排序:数组的每个元素都进行比较
    		冒泡排序：数组中相邻元素进行比较
    		规则：比较大小,位置交换
    
    */
    public class ArrayMethodTest_2{
    	public static void main(String[] args){
    		//1.给定一个需要排序的数组
    		int[] arr = {3,1,5,-8,0,9,2};
    		//2.调用选择排序方法、
    		selectSort(arr);
    		//3.实现数组的遍历
    		printArray(arr);
    	}
    	/*
    		定义方法实现数组的选择排序
    		返回值？void
    		参数？数组
    	*/
    	public static void selectSort(int[] arr){
    		//外循环,选择排序,外循环需要arr.length-1次数
    		for(int i = 0; i < arr.length - 1; i++){
    			//内循环,是每次都在减少,修改变量的定义
    			for(int j = i + 1; j < arr.length; j++){
    				//数组的元素进行判断 从小到大的顺序 排列数组中的元素
    				if(arr[i] > arr[j]){
    					//数组换位
    					int temp = arr[i];
    					arr[i] = arr[j];
    					arr[j] = temp;
    				}
    			}
    		}
    		
    	}
    	/*
    		定义方法实现数组的遍历
    		返回值？void
    		参数？数组
    	*/
    	public static void printArray(int[] arr){
    		//1.打印括号[
    		System.out.print("[");
    		//2.遍历数组
    		for(int i = 0; i < arr.length; i++){
    			//3.判断是否遍历到了数组的最后一个元素,如果是最后一个元素,输出括号] 
    			if(i == arr.length - 1){
    				System.out.println(arr[i] + "]");
    			}else{
    				//否则：输出数组的元素和逗号(这里打印元素不需要换行,保证元素打印在同一行中)
    				System.out.print(arr[i] + ",");
    			}
    		}
    	}
    	
    }

![在这里插入图片描述][70 19]  
2.4 数组元素冒泡排序  
图解：数组元素\{13,46,22,65,3\}  
![在这里插入图片描述][70 20]  
题目分析：  
通过观察发现，本题目要实现把数组元素\{13,46,22,65,3\}进行排序

1.  提到数组排序，就要进行元素值大小的比较，通过上图发现，我们想完成排序要经过若干次的比较才能够完成。
2.  上图中相邻的元素值依次比较，把大的值放后面的元素中，数组循环一圈后，则把最大元素值互换到了最后一个元素中。数组再循环一圈后，把第二大的元素值互换到了倒数第二个元素中。按照这种方式，数组循环多圈以后，就完成了数组元素的排序。这种排序方式我们称为冒泡排序。  
    解题步骤：
3.  使用for循环（外层循环），指定数组要循环的圈数（通过图解可知，数组循环的圈数为数组长度 - 1）
4.  在每一圈中，通过for循环（内层循环）完成相邻的元素值依次比较，把大的值放后面的元素中
5.  每圈内层循环的次数，由第几圈循环来决定。如上图所示  
    a) 进行第一圈元素比较时，内层循环次数为数组长度 - 1  
    b) 进行第二圈元素比较时，内层循环次数为数组长度 - 2  
    c) 依次类推，得出结论：进行第n圈元素比较时，内层循环次数为数组长度 - n  
    ![在这里插入图片描述][70 21]

/*
    	冒泡排序：
    	数组的排序：一般都是升序排列,元素,小到大的排列
    	
    	两种排序的方式：
    		选择排序:数组的每个元素都进行比较
    		冒泡排序：数组中相邻元素进行比较
    		规则：比较大小,位置交换
    
    */
    public class ArrayMethodTest_3{
    	public static void main(String[] args){
    		//1.给定一个需要排序的数组
    		int[] arr = {3,1,5,-8,0,9,2};
    		//2.调用选择排序方法、
    		bubbleSort(arr);
    		//3.实现数组的遍历
    		printArray(arr);
    	}
    	/*
    		定义方法实现数组的冒泡排序
    		返回值？void
    		参数？数组
    	*/
    	public static void bubbleSort(int[] arr){
    		//外循环次数arr.length-1
    		for(int i = 0; i < arr.length - 1; i++){
    			//内循环,从0索引开始到arr.length-1-i;每次遍历的次数都在递减
    			for(int j = 0; j < arr.length-1-i; j++){
    				//数组中相邻元素进行比较大小,并根据大小交换位置
    				if(arr[j] > arr[j+1]){
    					//进行交换数组中元素位置
    					int temp = arr[j];
    					arr[j] = arr[j+1];
    					arr[j+1] = temp;
    				}
    			}
    		}
    		
    	}
    	/*
    		定义方法实现数组的遍历
    		返回值？void
    		参数？数组
    	*/
    	public static void printArray(int[] arr){
    		//1.打印括号[
    		System.out.print("[");
    		//2.遍历数组
    		for(int i = 0; i < arr.length; i++){
    			//3.判断是否遍历到了数组的最后一个元素,如果是最后一个元素,输出括号] 
    			if(i == arr.length - 1){
    				System.out.println(arr[i] + "]");
    			}else{
    				//否则：输出数组的元素和逗号(这里打印元素不需要换行,保证元素打印在同一行中)
    				System.out.print(arr[i] + ",");
    			}
    		}
    	}
    	
    }

![在这里插入图片描述][70 22]  
2.5 数组元素普通查找  
图解：  
![在这里插入图片描述][70 23]  
题目分析：  
通过观察发现，本题目要实现查找指定数值第一次在数组中存储的位置（索引），返回该位置（索引）。

1.  我们可以通过遍历数组，得到每个数组元素的值
2.  在遍历数组过程中，使用当前数组元素值与要查找的数值进行对比  
    a) 数值相等，返回当前数组元素值的索引  
    b) 整个循环结束后，比对结果数值没有相等的情况，说明该数组中没有存储要查找的数值，此时，返回一个索引值-1，来表示没有查询到对应的位置。（使用 -1来表示没有查询到，是因为数组的索引没有负数）  
    解题步骤：
3.  使用for循环，遍历数组，得到每个数组元素值
4.  在每次循环中，使用if条件语句进行当前数组元素值与要查找的数值进行对比，若比较结果相等，直接返回当前数组元素的索引值
5.  若整个循环结束后，比对结果数值没有相等的情况，说明该数组中没有存储要查找的数值，此时，返回一个索引值-1  
    2.6 数组元素二分查找（折半查找）  
    ![在这里插入图片描述][70 24]  
    题目分析：  
    通过观察发现，本题目要实现查找指定数值在元素有序的数组中存储的位置（索引），返回该位置（索引）。
6.  我们使用数组最中间位置的元素值与要查找的指定数值进行比较，若相等，返回中间元素值的索引
7.  最中间位置的元素值与要查找的指定数值进行比较，若不相等，则根据比较的结果，缩小查询范围为上次数组查询范围的一半；  
    再根据新的查询范围，更新最中间元素位置，然后使用中间元素值与要查找的指定数值进行比较  
     比较结果相等，返回中间元素值的索引  
     比较结果不相等，继续缩小查询范围为上次数组查询范围的一半，更新最中间元素位置，继续比较，依次类推。
8.  当查询范围缩小到小于0个元素时，则指定数值没有查询到，返回索引值-1。  
    解题步骤：
9.  定义3个用来记录索引值的变量，变量min记录当前范围最小索引值，初始值为0；变量max记录当前范围最大索引值，初始值为数组长度-1；变量mid记录当前当前范围最中间元素的索引值，初始值为(min+max) / 2
10. 使用循环，判断当前范围下，最中间元素值与指定查找的数值是否相等  
     若相等，结束循环，返回当前范围最中间元素的索引值mid  
     若不相等，根据比较结果，缩小查询范围为上一次查询范围的一般  
     中间元素值 比 要查询的数值大，说明要查询的数值在当前范围的最小索引位置与中间索引位置之间，此时，更新查询范围为:

范围最大索引值 = 上一次中间索引位置 -1；

 中间元素值 比 要查询的数值小，说明要查询的数值在当前范围的最大索引位置与中间索引位置之间，此时，更新查询范围为:

范围最小索引值 = 上一次中间索引位置 +1；

 在新的查询范围中，更新中间元素值的位置，再次使用最中间元素值与指定查找的数值是否相等。

中间索引值 = (范围最小索引值 +范围最大索引值) / 2;

1.  每次查询范围缩小一半后，使用if语句判断，查询范围是否小于0个元素，若小于0个元素，则说明指定数值没有查询到，返回索引值-1。  
    ![在这里插入图片描述][70 25]

/*
    	二分查找法：
    		在一个数组中,找一个元素,是否存在于数组中,如果存在,就返回索引
    	
    	普通查询法：
    		找到元素在数组中出现的索引,如果没有这个元素,结果就是负数
    
    */
    public class ArrayMethodTest_4{
    	public static void main(String[] args){
    		//1.给定一个需要排序的数组
    		int[] arr = {1,2,3,4,5};
    		//2.调用二分查找方法
    		int index = binarySearch(arr,4);
    		if(index != -1){
    			System.out.println("数组中查找到该元素,该元素的索引为：" + index);
    		}else{
    			System.out.println("数组中没有查找到该元素！");
    		}
    		//3.调用普通查询法
    		int index1 = search(arr,4);
    		if(index1 != -1){
    			System.out.println("数组中查找到该元素,该元素的索引为：" + index1);
    		}else{
    			System.out.println("数组中没有查找到该元素！");
    		}
    	}
    	/*
    		定义方法,实现,折半查找
    		返回值？索引
    		参数？数组,需要查找的元素
    		实现步骤：
    			1.需要的变量定义
    				三个,三个指针
    			2.进行循环折半
    				可以折半的条件 min <= max
    			3.让被查找的元素,和中间索引对应元素,进行比较
    				元素 > 中间索引对应元素 	小指针 = 中间 + 1
    				元素 < 中间索引对应元素 	大指针 = 中间 - 1
    				元素 == 中间索引对应元素	找到了,结束循环体,返回中间索引
    			4.循环结束,无法折半
    				元素没有找到,返回-1
    	*/
    	public static int binarySearch(int[] arr,int key){
    		//1.定义三个变量
    		int min = 0;
    		int max = arr.length - 1;
    		int mid = 0;
    		
    		//2.循环折半,条件min <= max
    		while(min <= max){
    			//3.公式,计算中间索引
    			mid = (min + max) / 2;
    			//4.让被查找的元素,和中间索引对应元素,进行比较
    			if(key > arr[mid]){
    				//4.1.元素 > 中间索引对应元素 	小指针 = 中间 + 1
    				min = mid + 1;
    			}else if(key < arr[mid]){
    				//4.2.元素 < 中间索引对应元素 	大指针 = 中间 - 1
    				max = mid - 1;
    			}else{
    				//4.3.元素 == 中间索引对应元素	找到了,结束循环体,返回中间索引
    				return mid;
    			}
    		}
    		//5.循环结束,无法折半 元素没有找到,返回-1
    		return -1;
    	}
    	/*
    		定义方法,实现数组的普通查询
    		返回值？索引
    		参数？数组,需要查找的元素
    		
    		实现步骤：
    			1.遍历数组
    			2.遍历过程中,使用元素和数组中的元素进行比较
    				如果相同,返回元素在数组中的索引
    				如果不同,继续遍历数组中元素进行比较
    			3.遍历数组,直至结束,也没有查找到该元素,在循环结束后,返回-1
    	*/
    	public static int search(int[] arr,int key){
    		//1.遍历数组
    		for(int i = 0; i < arr.length; i++){
    			//2.使用元素和数组中的元素进行比较
    			if(arr[i] == key){
    				//3.返回索引
    				return i;
    			}
    		}
    		return -1;
    	}	
    }

![在这里插入图片描述][70 26]

[70]: /images/20220505/643c7578e77d4dd1be735e4752e1f377.png
[70 1]: /images/20220505/66acff1d36be4176b8e1ef765d769cf2.png
[70 2]: /images/20220505/fe72aeee550344a4945865ab77c69814.png
[70 3]: /images/20220505/56e1d78a9f504287a5c2238da062f298.png
[70 4]: /images/20220505/b22bdfe7791741f991e6304edc644be7.png
[70 5]: /images/20220505/d3881f22c2c741b1a648b8c045114f12.png
[70 6]: /images/20220505/657fff4646974e7a9b6137cc9182e1bb.png
[70 7]: /images/20220505/4ae781ce898a4ce0a157b92fb54fd5fe.png
[70 8]: /images/20220505/13310c5ea67b4e309ad97aec9073f71b.png
[70 9]: /images/20220505/b3e58a2f3d9c4761b81b66651e956047.png
[70 10]: /images/20220505/cd088535e1714e0b81d73b815a30b2e0.png
[70 11]: /images/20220505/57593553504e47789b2d0068215b36c4.png
[70 12]: /images/20220505/21c276e8d4f149728e6c0045e8c2713b.png
[70 13]: /images/20220505/835d9a5dca09425394fbb38a21f5a630.png
[70 14]: /images/20220505/f758d84af81a4bf192fb31c827ba28d1.png
[70 15]: /images/20220505/ffebc33877674195b08cd3ce2cf4a3c2.png
[70 16]: /images/20220505/b43b103b4a4e476eb49fece5c6403670.png
[70 17]: /images/20220505/3534a7c66c874a909d5de95b2d2f02d5.png
[70 18]: /images/20220505/ea33be38dfa143b0ac83842d1bed936a.png
[70 19]: /images/20220505/56cb9add22824ffa896f914dc4c8bd6e.png
[70 20]: /images/20220505/27ec1e307c0f467f9cafd633b812bf2a.png
[70 21]: /images/20220505/2b680b4f0b6b4738b6f80c7a844476e6.png
[70 22]: /images/20220505/bd832f24c93842009c629b5cef4a0258.png
[70 23]: /images/20220505/273ed07c21364918a713c9895233b8ac.png
[70 24]: /images/20220505/85c2396d15d34b2eb4bfa3acddd3a3ab.png
[70 25]: /images/20220505/c19efd73b0b6413da632888209ee8ecd.png
[70 26]: /images/20220505/ab8d4216a2914cf0a0062855c3019915.png