Java学习day07——循环数组方法练习

最新推荐文章于 2024-07-17 15:48:49 发布

光式

最新推荐文章于 2024-07-17 15:48:49 发布

阅读量138

点赞数

分类专栏： java学习

本文链接：https://blog.csdn.net/weixin_45256659/article/details/105046380

版权

java学习专栏收录该内容

13 篇文章 0 订阅

订阅专栏

7-01奇数求和练习

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

7-02水仙花练习功能实现

/*
   要求: 计算出水仙花数
     三位数 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){
		//定义三个变量
		int bai = 0;
		int shi = 0;
		int ge = 0 ;
		
		//循环,循环变量从100-999
		for(int i = 100 ; i < 1000 ; i++){
			//对i,进行计算,获取出三个数位
			//获取百位
			bai = i / 100;
			//获取十位
			shi = i / 10 % 10;
			//获取个位
			ge = i % 10;
			//对三个数位进行立方求和
			if(bai * bai * bai + shi * shi *shi + ge * ge *ge == i){
				System.out.println(i);
			}
		}
	}
}

7-03ASCII编码表

ASCII编码表由来
* 计算机中，所有的数据在存储和运算时都要使用二进制数表示
* a、b、c、d这样的52个字母（包括大写）、以及0、1等数字还有一些常用的符号, 在计算机中存储时也要使用二进制数来表示
* 具体用哪些二进制数字表示哪个符号，当然每个人都可以约定自己的一套（这就叫编码）
* 大家如果要想互相通信而不造成混乱，那么大家就必须使用相同的编码规则，于是美国有关的标准化组织就出台了ASCII编码，
统一规定了上述常用符号用哪些二进制数来表示。
字符中重要的ASCII码对应关系
* a : 97
* A : 65
* 0 : 48

7-04char类型的存储

取值范围
* short:占两个字节,是有符号数据,取值范围-32768-32767
* char: 占两个字节,是无符号数据,取值范围0-65536
案例代码

/*
	ASCII编码表演示
	字符Java 数据类型,char
	整数Java 数据类型,int
	
	int 类型和 char 数据类型转换
	char  两个字节, int 四个字节
	
	char转成int类型的时候,类型自动提示,char数据类型,会查询编码表,得到整数
	int转成char类型的时候,强制转换,会查询编码表
	
	char存储汉字,查询Unicode编码表
	
	char可以和int计算,提示为int类型, 内存中两个字节
	char取值范围是0-65535, 无符号的数据类型
*/
public class ASCIIDemo{
	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;
	}
}

7-05输出所有英文字母

/*
     利用循环,输出字母包含大写小写,52个
	 输出A-Z  a-z
	 利用编码表实现,字母和数字的对应关系
	 A-Z  65-90
	 a-z  97-122
	 
	 实现步骤:
	   1. 定义变量,保存小写a,大写A
	   2. 循环26次,输出定义好的变量
	      每次循环,变量++ 
*/
public class LoopTest_2{
	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);
			daXie++;
			xiaoXie++;
		}
	}
}

7-06 99乘法表的分析

/*
    利用嵌套for循环,实现99乘法表示
	实现步骤:
	  1. 定义外循环控制行数
	  2. 内循环控制个数,个数,每次都在递增
	  3. 循环中输出,乘法表的格式   1*3=3
*/
public class LoopTest_3{
	public static void main(String[] args){
		print99(6);
	}
	
	public static void print99(int n){
		//定义外循环,循环9次
		for(int i = 1; i <= n; i++){
			//定义内循环,每次递增,循环条件, <=i
			for(int j = 1; j <= i ;j++){
				//按照标准格式,输出打印
				System.out.print(j+"*"+i+"="+i*j+"\t");
			}
			System.out.println();
		}
	}
}

7-07实现数组的遍历

/*
    定义方法,实现数组的遍历
	遍历中,输出结果  [11,33,565,66,78,89]
	int[] arr = {3,4,45,7};
	结果包含字符串, [  ]  ,
	实现步骤:
	  1. 定义方法实现数组的遍历
	  2. 先打印[ 中括号
	  3. 遍历数组
	    输出数组的元素和逗号
		判断是否遍历到了数组的最后一个元素,如果是最后一个元素,输出]中括号
*/
public class ArrayMethodTest{
	public static void main(String[] args){
		int[] arr = {11,44,55,33,66};
		printArray(arr);
		
		int[] arr2 = {22,88,99,33,66};
		printArray(arr2);
		
	}
	/*
	   定义方法,实现功能
	   返回值: void
	   方法参数: 数组
	*/
	public static void printArray(int[] arr){
		//输出一半中括号,不要换行打印
		System.out.print("[");
		//数组进行遍历
		for(int i = 0 ; i < arr.length ; i++){
			//判断遍历到的元素,是不是数组的最后一个元素
			//如何判断 循环变量 到达 length-1
			if( i == arr.length-1 ){
				//输出数组的元素和]
				System.out.print(arr[i]+"]");
			}else{
			//不是数组的最后一个元素,输出数组元素和逗号
			    System.out.print(arr[i]+",");
			}
		}
		System.out.println();
	}
}

7-08数组逆序

/*
   数组的逆序:
     数组中的元素,进行位置上的交换
	 逆序不等于反向遍历
	 而是数组中最远的两个索引,进行位置交换,实现数组的逆序，其实就是把数组中索引为start与end的元素进行互换，每次互换后，start索引位置后移，end索引位置前移，再进行互换，直到start位置超越了end位置，互换结束，此时，数组元素逆序完成。
	 实现步骤:
	   1. 定义方法,实现数组的逆序
	   2. 遍历数组
	     实现数组的最远索引换位置
		 使用临时的第三方变量
*/
public class ArrayMethodTest_1{
	public static void main(String[] args){
		int[] arr = {3,5,7,1,0,9,-2};
		//调用数组的逆序方法
		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){
		//输出一半中括号,不要换行打印
		System.out.print("[");
		//数组进行遍历
		for(int i = 0 ; i < arr.length ; i++){
			//判断遍历到的元素,是不是数组的最后一个元素
			//如何判断 循环变量 到达 length-1
			if( i == arr.length-1 ){
				//输出数组的元素和]
				System.out.print(arr[i]+"]");
			}else{
			//不是数组的最后一个元素,输出数组元素和逗号
			    System.out.print(arr[i]+",");
			}
		}
		System.out.println();
	}
}

7-09选择排序

原理

第一个元素与该元素后面的数组元素依次比较到数组的最后一个元素，把小的值放在第一个数组元素中，数组循环一圈后，则把最小元素值互换到了第一个元素中。
数组再循环一圈后，把第二小的元素值互换到了第二个元素中。按照这种方式，数组循环多圈以后，就完成了数组元素的排序。这种排序方式我们称为选择排序。

步骤

使用for循环（外层循环），指定数组要循环的圈数（数组循环的圈数=数组长度 - 1）
在每一圈中，通过for循环（内层循环）完成数组要比较的第一个元素与该元素后面的数组元素依次比较到数组的最后一个元素，把小的值放在第一个数组元素中
在每一圈中，要参与比较的第一个元素 = 第几圈循环。
进行第一圈元素比较时，要比较的第一个元素为数组第一个元素，即索引为0的元素
进行第二圈元素比较时，要比较的第一个元素为数组第二个元素，即索引为1的元素
依次类推，得出结论：进行第n圈元素比较时，要比较的第一个元素为数组第n个元素，即数组索引为n-1的元素

案例代码

/*
  数组的排序: 一般都是升序排列,元素,小到大的排列
  
  两种排序的方式
	 选择排序: 数组的每个元素都进行比较
	 冒泡排序: 数组中相邻元素进行比较
	 规则: 比较大小,位置交换
*/
public class ArrayMethodTest_2{
	public static void main(String[] args){
		int[] arr  = {3,1,4,2,56,7,0};
		//调用选择排序方法
		//selectSort(arr);
		printArray(arr);
	}
	/*
		定义方法,实现数组的选择排序
		返回值: 没有
		参数:  数组
		实现步骤:
		  1.嵌套循环实现排序
			外循环,控制的是一共比较了多少次
			内循环,控制的是每次比较了多少个元素
		  2. 判断元素的大小值
			小值,存储到小的索引
	*/
	public static void selectSort(int[] arr){
		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){
		//输出一半中括号,不要换行打印
		System.out.print("[");
		//数组进行遍历
		for(int i = 0 ; i < arr.length ; i++){
			//判断遍历到的元素,是不是数组的最后一个元素
			//如何判断 循环变量 到达 length-1
			if( i == arr.length-1 ){
				//输出数组的元素和]
				System.out.print(arr[i]+"]");
			}else{
			//不是数组的最后一个元素,输出数组元素和逗号
				System.out.print(arr[i]+",");
			}
		}
		System.out.println();
	}
}

7-10冒泡排序

原理
相邻的元素值依次比较，把大的值放后面的元素中，数组循环一圈后，则把最大元素值互换到了最后一个元素中。
数组再循环一圈后，把第二大的元素值互换到了倒数第二个元素中。按照这种方式，数组循环多圈以后，就完成了数组元素的排序。这种排序方式我们称为冒泡排序。
步骤
- 使用for循环（外层循环），指定数组要循环的圈数（通过图解可知，数组循环的圈数为数组长度 - 1）
- 在每一圈中，通过for循环（内层循环）完成相邻的元素值依次比较，把大的值放后面的元素中
- 每圈内层循环的次数，由第几圈循环来决定。
- 进行第一圈元素比较时，内层循环次数为数组长度 - 1
- 进行第二圈元素比较时，内层循环次数为数组长度 - 2
- 依次类推，得出结论：进行第n圈元素比较时，内层循环次数为数组长度 – n
案例代码

/*
  数组的排序: 一般都是升序排列,元素,小到大的排列
  
  两种排序的方式
	 选择排序: 数组的每个元素都进行比较
	 冒泡排序: 数组中相邻元素进行比较
	 规则: 比较大小,位置交换
*/
public class ArrayMethodTest_2{
	public static void main(String[] args){
		int[] arr  = {3,1,4,2,56,7,0};
		//调用选择排序方法
		//selectSort(arr);
		
		//调用冒泡排序方法
		bubbleSort(arr);
		printArray(arr);
	}
	/*
	   定义方法,实现数组的冒泡排序
	   返回值: 没有
		参数:  数组
	*/
	public static void bubbleSort(int[] arr){
		for(int i = 0 ; i < arr.length - 1; i++){
			//每次内循环的比较,从0索引开始, 每次都在递减
			for(int j = 0 ; j < arr.length-i-1; j++){
				//比较的索引,是j和j+1
				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){
		//输出一半中括号,不要换行打印
		System.out.print("[");
		//数组进行遍历
		for(int i = 0 ; i < arr.length ; i++){
			//判断遍历到的元素,是不是数组的最后一个元素
			//如何判断 循环变量 到达 length-1
			if( i == arr.length-1 ){
				//输出数组的元素和]
				System.out.print(arr[i]+"]");
			}else{
			//不是数组的最后一个元素,输出数组元素和逗号
				System.out.print(arr[i]+",");
			}
		}
		System.out.println();
	}
}

7-11数组的折半查找

原理
使用数组最中间位置的元素值与要查找的指定数值进行比较，若相等，返回中间元素值的索引；
若不相等，则根据比较的结果，缩小查询范围为上次数组查询范围的一半；再根据新的查询范围，更新最中间元素位置，然后使用中间元素值与要查找的指定数值进行比较
比较结果相等，返回中间元素值的索引；比较结果不相等，继续缩小查询范围为上次数组查询范围的一半，更新最中间元素位置，继续比较，依次类推。
当查询范围缩小到小于0个元素时，则指定数值没有查询到，返回索引值-1。
步骤

定义3个用来记录索引值的变量，变量min记录当前范围最小索引值，初始值为0；变量max记录当前范围最大索引值，初始值为数组长度-1；变量mid记录当前当前范围最中间元素的索引值，初始值为(min+max) / 2
使用循环，判断当前范围下，最中间元素值与指定查找的数值是否相等，若相等，结束循环，返回当前范围最中间元素的索引值mid；若不相等，根据比较结果，缩小查询范围为上一次查询范围的一半
中间元素值比要查询的数值大，说明要查询的数值在当前范围的最小索引位置与中间索引位置之间，此时，更新查询范围为:
范围最大索引值 = 上一次中间索引位置 -1；
中间元素值比要查询的数值小，说明要查询的数值在当前范围的最大索引位置与中间索引位置之间，此时，更新查询范围为:
范围最小索引值 = 上一次中间索引位置 +1；
在新的查询范围中，更新中间元素值的位置，再次使用最中间元素值与指定查找的数值是否相等。
*中间索引值 = (范围最小索引值 +范围最大索引值) / 2;
每次查询范围缩小一半后，使用if语句判断，查询范围是否小于0个元素，若小于0个元素，则说明指定数值没有查询到，返回索引值-1。

案例代码

public class ArrayMethodTest_3{
 public static void main(String[] args){
	 int[] arr = {1,3,5,7,9,11,15};
	 int index = binarySearch(arr,10);
	 System.out.println(index);
	 
 }
 
 /*
	 定义方法,实现,折半查找
	 返回值: 索引
	 参数: 数组,被找的元素 
	 实现步骤:
	   1. 需要的变量定义
		  三个,三个指针
		  
	   2. 进行循环折半
		  可以折半的条件  min <= max
	   
	   3. 让被找元素,和中间索引元素进行比较
		   元素 > 中间索引  小指针= 中间+1
		   元素 < 中间索引  大指针= 中间-1
		   元素 == 中间索引  找到了,结束了,返回中间索引
		   
		4. 循环结束,无法折半
		  元素没有找到 ,返回-1
 */
 public static int binarySearch(int[] arr, int key){
	 //定义三个指针变量
	 int min = 0 ;
	 int max = arr.length -1 ;
	 int mid = 0;
	 //循环折半,条件 min<=max
	 while( min <= max){
		 //公式,计算中间索引
		 mid = (min+max)/2;
		 //让被找元素,和中间索引元素进行比较
		 if(key > arr[mid]){
			 min = mid + 1;
		 }else if (key < arr[mid]){
			 max = mid - 1;
		 }else{
			 //找到元素,返回元素索引
			 return mid;
		 }
	 }
	 return -1;
 }
 
/*
   定义方法,实现数组的普通查询
   返回值: 索引
   参数:   数组, 被找的元素
   
   实现步骤:
	 1. 遍历数组
	 2. 遍历过程中,使用元素和数组中的元素进行比较
		如果相同,返回元素在数组中的索引
		如果不同,返回负数
*/
public static int search(int[] arr, int key){
	//遍历数组
	for(int i = 0 ; i < arr.length ; i++){
		//数组元素,被查找的元素比较
		if(arr[i] == key){
			//返回索引
			return i;
		}
	}
	return -1;
}
}

光式

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java学习day07——循环数组方法练习

7-01奇数求和练习/* 要求: 计算1-100之间的所有的奇数和 1+3+5+7...+99 有1个数据,从0变到100 循环 int =0 <= 100 ++ 从0-100,范围内,找到奇数数%2==1 奇数所有的奇数求和计算需要变量,保存奇数的求和实现步骤: 1. 程序可以使用到的数据,预先定义好变量 ...
复制链接

扫一扫

专栏目录