07_Java基础语法_第7天（练习）_讲义(练习加强+在eclipse中实现)

Bertha 。 2022-05-11 13:46 315阅读 0赞

第7天 Java基础语法  
今日内容介绍  
 循环练习  
 数组方法练习

第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.1	编写程序求 1+3+5+7+……+99 的和值
     * 实现步骤：
     * 		1.定义一个用来记录累加和的变量sum
     * 		2.使用for循环,完成1-100之间每个奇数的获取 
     * 			采用for(int i = 1; i < 100; i += 2)
     * 		3.在for循环中,与sum进行累加,求和
     * 		4.使用输出语句,打印累加和变量的值sum
     */
    public class LoopTest {
    
    	public static void main(String[] args) {
    		//1.定义一个用来记录累加和的变量sum
    		int sum = 0;
    		//2.使用for循环,完成1-100之间每个奇数的获取 
    		for (int i = 1; i < 100; i += 2) {
    			//3.在for循环中,与sum进行累加,求和
    			sum += i;
    		}
    		//4.使用输出语句,打印累加和变量的值sum
    		System.out.println("1-100之间的奇数累加和:" + 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位数  
    ![在这里插入图片描述][70 1]

/*
     * 1.2	输出所有的水仙花数，所谓水仙花数是指一个数3位数，其每位数字立方和等于其本身，
     * 		如153 = 1*1*1 + 3*3*3 + 5*5*5
     * 实现步骤：
     * 		1.定义变量存储 三个数位的整数int
     * 		2.利用循环,循环中的变量,从100变化到999
     * 		3.在循环中得到的三位数,拆解成三个独立的数位
     * 		4.将三个数位的各自立方求和计算,求和后的数,用if条件语句
     * 			与她自己进行匹配,符合就是水仙花数,否则继续循环遍历
     * 		5.当找到水仙花数,用输出打印该水仙花数
     */
    public class LoopTest1 {
    
    	public static void main(String[] args) {
    		//1.定义变量存储 三个数位的整数int
    		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条件语句
    			// 	与她自己进行匹配,符合就是水仙花数,否则继续循环遍历
    			if(bai * bai * bai + shi * shi * shi + ge * ge * ge == i){
    				//5.当找到水仙花数,用输出打印该水仙花数
    				System.out.println("水仙花数:" + i);
    			}
    		}
    	}
    
    }

![在这里插入图片描述][70 2]  
1.3 ASCII编码表  
American Standard Code for Information Interchange，美国标准信息交换代码.  
**数字0-9对应ASCII编码十进制为48-57, 字母a-z对应ASCII编码十进制为97-122，字母A-Z对应ASCII编码十进制为65-90**

/*
     * 1.3 char类型存储
     * 数字0-9对应ASCII编码十进制为48-57, 
     * 字母a-z对应ASCII编码十进制为97-122，
     * 字母A-Z对应ASCII编码十进制为65-90	
     * a.取值范围
     * 		short:占两个字节,是有符号数据,取值范围-2^15 - 2^15 (-32767-32767)
     *		char：占两个字节,是无符号数据,取值范围0-2^16	(0-65536) 		
     * b.类型转换
     * 		char类型的数据参加运算时,需要转换成int数据类型
     * c.案例代码
     * 		ASCII编码表演示
     * 			字符JAVA 数据类型,char
     * 			整数JAVA 数据类型,int
     * 		
     * 		int类型 和char数据类型转换
     * 		char两个字节,int四个字节
     * 
     * 		char转成int数据类型的时候,类型自动提升,char数据类型,会查询编码表,得到整数
     * 		int转成char类型的时候,需要强制类型转换,会查询编码表
     * 
     * 		char存储汉字,查询Unicode编码表
     * 
     * 		char可以和int计算,提升为int类型,内存中两个字节
     * 	
     */
    public class LoopTest2 {
    
    	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);
    		
    		//char m = -1;
    	}
    
    }

![在这里插入图片描述][70 3]  
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.  在每次循环中，打印大写字母、小写字母。  
    每次打印完成后，更新大写字母值、小写字母值

/*
     * 1.4	利用for循环打印ABCDEFG...XYZ，26个大写字母与26个小写字母
     * 实现步骤：
     * 		1.定义初始化大写变量,值为'A';初始化小写变量,值为'a'
     * 		2.使用for循环,进行26次循环
     * 		3.在每次循环的过程中,打印大写字母和小写字母(与此同时,更新大写字母,小写字母)
     */
    public class LoopTest3 {
    
    	public static void main(String[] args) {
    		//1.定义初始化大写变量,值为'A';初始化小写变量,值为'a'
    		char da = 'A';
    		char xiao = 'a';
    		//2.使用for循环,进行26次循环
    		for (int i = 0; i < 26; i++) {
    			//3.在每次循环的过程中,打印大写字母和小写字母(与此同时,更新大写字母,小写字母)
    			System.out.println("大写字母:" + da + " 小写字母:" + xiao);
    			da++;
    			xiao++;
    		}
    	}
    
    }

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

1*1=1
    		1*2=2  2*2=4
    		1*3=3  2*3=6  3*3=9

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

import java.util.Scanner;
    
    /*
     * 1.5	利用for循环打印 9*9 表?
     * 实现步骤：
     * 		1.定义一个外层for循环,初始值从1开始,循环9次,用来控制打印的行数
     * 		2.在外层for循环内部,定义一个for循环,
     * 		     初始值从1开始,循环次数与当前行数相等,用来完成每行打印指定次数的乘法公式
     * 		3.在内层for循环中,完成每行指定次数的乘法公式打印
     * 		4.在外层for循环中,当每行指定次数的乘法公式打印完毕后,通过System.out.println();切换到下一行
     * 			这样,再次打印乘法公式时,就在下一行输出打印了
     */
    public class LoopTest4 {
    
    	public static void main(String[] args) {
    		Scanner sc = new Scanner(System.in);
    		//打印n * n乘法表
    		System.out.println("请输入你想打印乘法表的维数:");
    		int index = sc.nextInt();
    		System.out.println("如下打印:" + index + " * " + index + " 乘法表");
    		print99(index);
    	}
    	public static void print99(int index){
    		//1.定义一个外层for循环,初始值从1开始,循环index次,用来控制打印的行数
    		for (int i = 1; i <= index; i++) {
    			//2.在外层for循环内部,定义一个for循环
    			for (int j = 1; j <= i; j++) {
    				//3.在内层for循环中,完成每行指定次数的乘法公式打印
    				System.out.print(j + " * " + i + " = " + i * j + "\t");
    			}
    			//4.在外层for循环中,当每行指定次数的乘法公式打印完毕后,通过System.out.println();
    			System.out.println();
    		}
    	}
    }

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

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

/*
     * 2.1	定义打印数组元素方法,按照给定的格式打印[11, 33, 44, 22, 55]
     * 实现步骤：
     * 		1.定义方法实现数组的遍历
     * 		2.先打印括号--[
     * 		3.遍历数组
     * 				判断是否遍历到了数组的最后一个元素,如果是最后一个元素,输出括号]
     * 				(这里打印最后一个元素需要换行,保证下次调用方法,不会显示在同一行,
     * 				否则:输出数组的元素和逗号(这样打印元素,不需要换行,保证元素显示在同一行))
     */
    public class ArrayMethodTest {
    
    	public static void main(String[] args) {
    		//1.定义一个数组
    		int[] arr = {11, 33, 44, 22, 55};
    		print(arr);
    	}
    	/*
    	 * 定义方法实现数组的遍历
    	 * 返回值：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){
    				//3.1.这里打印最后一个元素需要换行,保证下次调用方法,不会显示在同一行
    				System.out.println(arr[i] + "]");
    			}else{
    				//3.1.2这样打印元素,不需要换行,保证元素显示在同一行
    				System.out.print(arr[i] + ",");
    			}
    		}	
    	}
    }

![在这里插入图片描述][70 7]  
2.2 数组元素逆序  
![在这里插入图片描述][70 8]

/*
     * 2.2	数组元素逆序
     * 实现步骤：
     * 		1.利用for循环,实现数组遍历,遍历过程中,最远端换位
     * 		2.for的第一项,定义两个变量,判断条件：min <= max,增量min++,max--
     * 			min索引和max索引的元素进行交换
     * 			(使用临时的第三方变量进行换成min索引对应元素,之后在赋值给max索引对应元素)
     */
    public class ArrayMethodTest1 {
    
    	public static void main(String[] args) {
    			//1.定义一个数组
    			int[] arr = {11, 33, 44, 22, 55};
    			//2.先打印一把数组,看数组正常
    			print(arr);
    			//3.将数组逆序
    			reverse(arr);
    			//4.查看数组逆序后的情况
    			print(arr);
    	}
    	/*
    	 * 定义方法实现数组的遍历
    	 * 返回值：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){
    				//3.1.这里打印最后一个元素需要换行,保证下次调用方法,不会显示在同一行
    				System.out.println(arr[i] + "]");
    			}else{
    				//3.1.2这样打印元素,不需要换行,保证元素显示在同一行
    				System.out.print(arr[i] + ",");
    			}
    		}	
    	}
    	/*
    	 * 定义方法,实现数组的逆序
    	 * 返回值：void
    	 * 参数:数组
    	 */
    	public static void reverse(int[] arr){
    		//利用循环,实现数组遍历,遍历过程中,最远端换位
    		//for的第一项,定义两个变量
    		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;
    		}
    	}
    	
    }

![在这里插入图片描述][70 9]  
2.3 数组元素选择排序  
![在这里插入图片描述][70 10]

/*
     * 数组的排序：一般是升序,元素,从小到大的排列
     * 
     * 两种排序的方式：
     * 			选择排序:数组的每个元素都进行比较
     * 			冒泡排序:数组中的相邻元素进行比较
     * 			规则:比较大小,位置交换
     * 
     */
    public class ArrayMethodTest2 {
    	public static void main(String[] args) {
    			//1.给定一个需要排序的数组
    			int[] arr = {3,1,5,-8,0,9,2};
    			//2.调用选择排序方法
    			selectSort(arr);
    			//3.实现数组的遍历打印
    			print(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 print(int[] arr){
    		//1.打印括号[ 不要换行
    		System.out.print("[");
    		//2.遍历数组
    		for(int i = 0; i < arr.length; i++){
    			//3.判断是否遍历了数组的最后一个元素,如果是最后一个元素,输出括号]
    			if(i == arr.length -1){
    				//3.1.这里打印最后一个元素需要换行,保证下次调用方法,不会显示在同一行
    				System.out.println(arr[i] + "]");
    			}else{
    				//3.1.2这样打印元素,不需要换行,保证元素显示在同一行
    				System.out.print(arr[i] + ",");
    			}
    		}	
    	}
    }

![在这里插入图片描述][70 11]  
2.4 数组元素冒泡排序

/*
     * 数组的冒泡排序法:数组的相邻元素进行比较大小,交换位置
     * N个数字要排序完成，总共进行N-1趟排序，每i趟的排序次数为(N-i-1)次(i = 0,1,2)
     * 所以可以用双重循环语句，外层控制循环多少趟，内层控制每一趟的循环次数
     * 实现步骤：
     * 		1.进行外循环,冒泡排序,外循环需要arr.length-1次数
     * 		2.进行内循环,内循环进行相邻元素大小比较,根据升序交换位置,内循环结束一趟,出来一个最大值
     * 			等又一次外循环,已经出来的最大的数,就无需进行纳入比较中,但是,其他继续相邻元素比较大小,
     * 			直至所有最大的数出来
     */
    public class ArrayMethodTest3 {
    
    	public static void main(String[] args) {
    		//1.给定一个需要排序的数组
    		int[] arr = {3,1,5,-8,0,9,2};
    		//2.调用冒泡排序方法
    		bubbleSort(arr);
    		//3.实现数组的遍历打印
    		print(arr);
    	}
    	/*
    	 * 冒泡排序法
    	 * 返回值：void
    	 * 参数：数组
    	 * N个数字要排序完成，总共进行N-1趟排序，每i趟的排序次数为(N-i-1)次 (i = 0,1,2)
    	 */
    	public static void bubbleSort(int[] arr){
    		//1.进行外循环,冒泡排序,外循环需要arr.length-1次数,总共进行N-1趟排序
    		for(int i = 0; i < arr.length - 1; i++){
    			//2.进行内循环,内循环进行相邻元素大小比较,每i趟的排序次数为(N-i-1)次
    			//故内循环：判断条件为：j < arr.length - 1 - i
    			for(int j = 0; j < arr.length - 1 - i;j++){
    				//3.根据升序交换位置
    				if(arr[j] > arr[j+1]){
    					//4.进行交换数组中的元素位置
    					int temp = arr[j];
    					arr[j] = arr[j+1];
    					arr[j+1] = temp;
    				}
    			}
    		}
    	}
    	/*
    	 * 定义方法实现数组的遍历
    	 * 返回值：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){
    				//3.1.这里打印最后一个元素需要换行,保证下次调用方法,不会显示在同一行
    				System.out.println(arr[i] + "]");
    			}else{
    				//3.1.2这样打印元素,不需要换行,保证元素显示在同一行
    				System.out.print(arr[i] + ",");
    			}
    		}	
    	}
    
    }

![在这里插入图片描述][70 12]  
![在这里插入图片描述][70 13]  
2.5 数组元素普通查找  
2.6 数组元素二分查找（折半查找）  
![在这里插入图片描述][70 14]

/*
     * 二分查找法：
     * 		在一个数组中,找到一个元素,是否存在于数组中,如果存在,就返回索引
     *实现步骤：
     *		1.三个指针变量mid min max
     *		2.进行循环折半：可以折半的条件min <= max (需要用到的循环体是while循环体-因为不知道具体需要多少次遍历)
     *		3.循环体中,公式计算中间索引		
     *		4.循环体中,让被查找的元素与中间的索引所对应的元素进行比较：
     *			4.1.key < arr[mid]： max = mid - 1
     *			4.2.key > arr[mid]: min = mid + 1
     *			4.3.key == arr[mid]:return mid
     *		5.若循环体结束,元素没有找到,没有找到索引,需要返回-1,代表元素没有找到
     * 普通查询法:
     * 		找到元素在数组中出现的索引,如果没有这个元素,结果就是负数
     */
    public class findArrayTest {
    
    	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("数组中没有找到该元素！");
    		}	
    	}
    	/*
    	 * 定义方法,实现折半查找
    	 * 返回值:索引
    	 * 参数：数组,需要查找的元素
    	 */
    	public static int binarySearch(int[] arr,int key){
    		//1.三个指针变量mid min max
    		int min = 0;
    		int max = arr.length - 1;
    		int mid = 0;
    		//2.进行循环折半：可以折半的条件min <= max (需要用到的循环体是while循环体-因为不知道具体需要多少次遍历)
    		while(min <= max){
    			//3 公式计算中间索引
    			mid = (min + max) / 2;
    			//4.循环体中,让被查找的元素与中间的索引所对应的元素进行比较：
    			if(key < arr[mid]){
    				 //4.1.key < arr[mid]： max = mid - 1
    				 max = mid - 1;
    			}else if(key > arr[mid]){
    				//4.2.key > arr[mid]: min = mid + 1
    				 min = mid + 1;
    			}else{
    				//4.3.key == arr[mid]:return mid
    				return mid;
    			}
    		}
    		//5.循环体结束,元素没有找到,需要返回-1,代表元素没有找到
    		return -1;
    	}
    	/*
    	 * 定义方法，实现数组的普通查询
    	 * 返回值:索引int
    	 * 参数:数组,查找的元素
    	 * 实现步骤：
    	 * 		1.for循环遍历数组
    	 * 		2.遍历过程中,遍历数组中的元素与查找的元素进行比较
    	 * 			符合:返回索引
    	 * 			不符合:继续遍历数组,直至结束
    	 * 		3.若遍历结束,没有找到索引,返回-1,代表数组中没有该元素
    	 */
    	public static int search(int[] arr,int key){
    		//1.for循环遍历数组
    		for (int i = 0; i < arr.length; i++) {
    			//2.遍历过程中,遍历数组中的元素与查找的元素进行比较
    			if(arr[i] == key){
    				return i;
    			}
    		}
    		//3.若遍历结束,没有找到索引,返回-1,代表数组中没有该元素
    		return -1;
    	}
    }

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

[70]: /images/20220505/653874cadd944b0a9ba2952ca170be76.png
[70 1]: /images/20220505/13c720273f7f4f228b063cd138414984.png
[70 2]: /images/20220505/e2e7a6b744384be1b5bb6c8b47b4bc04.png
[70 3]: /images/20220505/cb547d9c57934c2c83bc1ac43e90e737.png
[70 4]: /images/20220505/9e9b15dc229d47949db9a00b534468f1.png
[70 5]: /images/20220505/caa6dbc9ac2b41e49e1f4141e2e541d8.png
[70 6]: /images/20220505/5badfdbc4c4540ff9d6b4e3182b93055.png
[70 7]: /images/20220505/6346562757424c14a23729eb1b286393.png
[70 8]: /images/20220505/0e842b47280d4e8084a9d0f13ddd135b.png
[70 9]: /images/20220505/008e529d53c04f46824f6d1282d0f929.png
[70 10]: /images/20220505/235c11539d204573b6db56dd1b76fd3d.png
[70 11]: /images/20220505/b7da16d3827646338c21e096e5c1892b.png
[70 12]: /images/20220505/9e49a6c9d40e42859bbe37a98aa54fdf.png
[70 13]: /images/20220505/cc494888384d458e8d329a6e0305e61f.png
[70 14]: /images/20220505/8d388122ced04944ac309bf520e85d15.png
[70 15]: /images/20220505/7103d15dec3f46ff88a2cf38dfaccc20.png