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

第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);
	}

}

1.2 输出所有的水仙花数，所谓水仙花数是指一个数3位数，其每位数字立方和等于其本身，如153 = 111 + 333 + 555
题目分析：
通过观察发现，本题目要实现打印符合要求的数字（即水仙花数）。

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

/*
 * 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);
			}
		}
	}

}

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;
	}

}

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
   3. 在每次循环中打印上一个字母大小写，并指定下一个字母
      解题步骤：
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++;
		}
	}

}

1.5 利用for循环打印 9*9 表?
如：

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

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();
		}
	}
}

第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] + ",");
			}
		}	
	}
}

2.2 数组元素逆序

/*
 * 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;
		}
	}
	
}

2.3 数组元素选择排序

/*
 * 数组的排序：一般是升序,元素,从小到大的排列
 * 
 * 两种排序的方式：
 * 			选择排序:数组的每个元素都进行比较
 * 			冒泡排序:数组中的相邻元素进行比较
 * 			规则:比较大小,位置交换
 * 
 */
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] + ",");
			}
		}	
	}
}

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] + ",");
			}
		}	
	}

}

2.5 数组元素普通查找
2.6 数组元素二分查找（折半查找）

/*
 * 二分查找法：
 * 		在一个数组中,找到一个元素,是否存在于数组中,如果存在,就返回索引
 *实现步骤：
 *		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;
	}
}