java练习题

ゝ一世哀愁。 2022-08-31 00:46 205阅读 0赞

### for循环案例-求1-5数据和 ###

*  需求：求1-5之间的数据和，并把求和结果在控制台输出
 *  示例代码：

public class ForTest02 { 
        public static void main(String[] args) { 
    		//求和的最终结果必须保存起来，需要定义一个变量，用于保存求和的结果，初始值为0
    		int sum = 0;
    		//从1开始到5结束的数据，使用循环结构完成
    		for(int i=1; i<=5; i++) { 
    			//将反复进行的事情写入循环结构内部
                 // 此处反复进行的事情是将数据 i 加到用于保存最终求和的变量 sum 中
    			sum += i;
    			/* sum += i; sum = sum + i; 第一次：sum = sum + i = 0 + 1 = 1; 第二次：sum = sum + i = 1 + 2 = 3; 第三次：sum = sum + i = 3 + 3 = 6; 第四次：sum = sum + i = 6 + 4 = 10; 第五次：sum = sum + i = 10 + 5 = 15; */
    		}
    		//当循环执行完毕时，将最终数据打印出来
    		System.out.println("1-5之间的数据和是：" + sum);
        }
    }

*  本题要点：
    
     *  今后遇到的需求中，如果带有求和二字，请立即联想到求和变量
     *  求和变量的定义位置，必须在循环外部，如果在循环内部则计算出的数据将是错误的

### for循环案例-求1-100偶数和 ###

*  需求：求1-100之间的偶数和，并把求和结果在控制台输出 \}
 *  示例代码：

public class ForTest03 { 
        public static void main(String[] args) { 
    		//求和的最终结果必须保存起来，需要定义一个变量，用于保存求和的结果，初始值为0
    		int sum = 0;
    		//对1-100的数据求和与1-5的数据求和几乎完全一样，仅仅是结束条件不同
    		for(int i=1; i<=100; i++) { 
    			//对1-100的偶数求和，需要对求和操作添加限制条件，判断是否是偶数
    			if(i%2 == 0) { 
    				sum += i;
    			}
    		}
    		//当循环执行完毕时，将最终数据打印出来
    		System.out.println("1-100之间的偶数和是：" + sum);
        }
    }

### for循环案例-水仙花数 ###

*  需求：在控制台输出所有的“水仙花数”
 *  解释：什么是水仙花数？
    
     *  水仙花数，指的是一个三位数，个位、十位、百位的数字立方和等于原数
        
         *  例如`153 3*3*3 + 5*5*5 + 1*1*1 = 153`
 *  思路：
    
    1.  获取所有的三位数，准备进行筛选，最小的三位数为100，最大的三位数为999，使用for循环获取
    2.  获取每一个三位数的个位，十位，百位，做if语句判断是否是水仙花数
 *  示例代码

public class ForTest04 { 
        public static void main(String[] args) { 
    		//输出所有的水仙花数必然要使用到循环，遍历所有的三位数，三位数从100开始，到999结束
    		for(int i=100; i<1000; i++) { 
    			//在计算之前获取三位数中每个位上的值
    			int ge = i%10;
    			int shi = i/10%10;
    			int bai = i/10/10%10;
    			
    			//判定条件是将三位数中的每个数值取出来，计算立方和后与原始数字比较是否相等
    			if(ge*ge*ge + shi*shi*shi + bai*bai*bai == i) { 
    				//输出满足条件的数字就是水仙花数
    				System.out.println(i);
    			}
    		}
        }
    }

### for循环案例-每行打印2个水仙花数(统计) ###

*  需求：在控制台输出所有的“水仙花数”，要求每行打印2个
 *  示例代码：

public class Demo6For { 
    	/* 需求：在控制台输出所有的“水仙花数”，要求每行打印2个 System.out.print (打印内容); 打印后不换行 System.out.println(打印内容); 打印后换行 分析: 1. 定义变量count，用于保存“打印过”的数量，初始值为0 2. 在判定和打印水仙花数的过程中，拼接空格, 但不换行，并在打印后让count变量+1，记录打印过的数量 3. 在每一次count变量+1后，判断是否到达了2的倍数，是的话，换行。 */
    	public static void main(String[] args){ 
    		// 1. 定义变量count，用于保存“打印过”的数量，初始值为0
    		int count = 0;
    		for(int i = 100; i <= 999; i++){ 
    			int ge = i % 10;
    			int shi = i / 10 % 10;
    			int bai = i / 10 / 10 % 10;
    			
    			if(	(ge*ge*ge + shi*shi*shi + bai*bai*bai) == i){ 
    				// 2. 在判定和打印水仙花数的过程中，拼接空格, 但不换行，并在打印后让count变量+1，记录打印过的数量
    				System.out.print(i + " ");
    				count++;
    				// 3. 在每一次count变量+1后，判断是否到达了2的倍数，是的话，换行
    				if(count % 2 == 0){ 
    					System.out.println();
    				}
    			}
    		}
    	}
    }

*  本题要点：
    
     *  今后如果需求带有统计xxx，请先想到计数器变量
     *  计数器变量定义的位置，必须在循环外部

### while循环案例-珠穆朗玛峰 ###

*  需求：世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米)，假如我有一张足够大的纸，它的厚度是0.1毫米。请问，我折叠多少次，可以折成珠穆朗玛峰的高度?
 *  示例代码：

public class WhileTest { 
        public static void main(String[] args) { 
    		//定义一个计数器，初始值为0
    		int count = 0;
    		//定义纸张厚度
    		double paper = 0.1;
    		//定义珠穆朗玛峰的高度
    		int zf = 8844430;
    		//因为要反复折叠，所以要使用循环，但是不知道折叠多少次，这种情况下更适合使用while循环
    		//折叠的过程中当纸张厚度大于珠峰就停止了，因此继续执行的要求是纸张厚度小于珠峰高度
    		while(paper <= zf) { 
    			//循环的执行过程中每次纸张折叠，纸张的厚度要加倍
    			paper *= 2;
    			//在循环中执行累加，对应折叠了多少次
    			count++;
    		}
    		//打印计数器的值
    		System.out.println("需要折叠：" + count + "次");
        }
    }

## 4. 循环细节 ##

### 5.3 Random练习-猜数字（应用） ###

*  需求：
    
    程序自动生成一个1-100之间的数字，使用程序实现猜出这个数字是多少？
    
    当猜错的时候根据不同情况给出相应的提示
    
    A. 如果猜的数字比真实数字大，提示你猜的数据大了
    
    B. 如果猜的数字比真实数字小，提示你猜的数据小了
    
    C. 如果猜的数字与真实数字相等，提示恭喜你猜中了
 *  示例代码：

import java.util.Scanner;
    import java.util.Random;
    
    public class Test { 
    	/* 需求：程序自动生成一个1-100之间的数字，使用程序实现猜出这个数字是多少？ 当猜错的时候根据不同情况给出相应的提示 如果猜的数字比真实数字大，提示你猜的数据大了 如果猜的数字比真实数字小，提示你猜的数据小了 如果猜的数字与真实数字相等，提示恭喜你猜中了 1. 准备Random和Scanner对象, 分别用于产生随机数和键盘录入 2. 使用Random产生一个1-100之间的数, 作为要猜的数 3. 键盘录入用户猜的的数据 4. 使用录入的数据(用户猜的数据)和随机数(要猜的数据)进行比较, 并给出提示 5. 以上内容需要多次进行, 但无法预估用户输入几次可以猜测正确, 使用while(true)死循环包裹 6. 猜对之后, break结束. */
    	public static void main(String[] args){ 
    		// 1. 准备Random和Scanner对象, 分别用于产生随机数和键盘录入
    		Random r = new Random();
    		Scanner sc = new Scanner(System.in);
    		// 2. 使用Random产生一个1-100之间的数, 作为要猜的数
    		int randomNum = r.nextInt(100) + 1;
    		
    		// 5. 以上内容需要多次进行, 但无法预估用户输入几次可以猜测正确, 使用while(true)死循环包裹
    		while(true){ 
    			// 3. 键盘录入用户猜的的数据
    			System.out.println("请输入您猜的数据:");
    			int num = sc.nextInt();
    			// 4. 使用录入的数据(用户猜的数据)和随机数(要猜的数据)进行比较, 并给出提示
    			if(num > randomNum){ 
    				System.out.println("猜大了");
    			}else if(num < randomNum){ 
    				System.out.println("猜小了");
    			}else{ 
    				// 6. 猜对之后, break结束.
    				System.out.println("恭喜,猜中了");
    				break;
    			}
    		}
    		
    		System.out.println("感谢您的使用");
    		
    	}
    }

### 数组获取最大值 ###

*  最大值获取：从数组的所有元素中找出最大值。
 *  实现思路：
    
     *  定义变量，保存数组0索引上的元素
     *  遍历数组，获取出数组中的每个元素
     *  将遍历到的元素和保存数组0索引上值的变量进行比较
     *  如果数组元素的值大于了变量的值，变量记录住新的值
     *  数组循环遍历结束，变量保存的就是数组中的最大值
 *  代码实现：
    
        package com.itheima.test;
        
        import java.util.Scanner;
        
        public class Test2Array { 
            /* 需求: 从数组中查找最大值 int[] arr = {12,45,98,73,60}; 实现步骤: 1. 假设数组中的第一个元素为最大值 2. 遍历数组, 获取每一个元素, 准备进行比较 3. 如果比较的过程中, 出现了比max更大的, 让max记录更大的值 4. 循环结束后, 打印最大值. */
            public static void main(String[] args) { 
                int[] arr = { 12,45,98,73,60};
                // 1. 假设数组中的第一个元素为最大值
                int max = arr[0];
                // 2. 遍历数组, 获取每一个元素, 准备进行比较
                for(int i = 1; i < arr.length; i++){ 
                    // 3. 如果比较的过程中, 出现了比max更大的, 让max记录更大的值
                    if(arr[i] > max){ 
                        max = arr[i];
                    }
                }
                // 4. 循环结束后, 打印最大值.
                System.out.println("max:" + max);
            }
        }

### 数组元素求和 ###

*  需求：键盘录入5个整数，存储到数组中，并对数组求和
 *  思路：  
    1.创建键盘录入对象，准备键盘录入  
    2.定义一个求和变量，准备记录累加后的结果  
    3.动态初始化一个长度为5的int数组，准备存储键盘录入的数值  
    4.将键盘录入的数值存储到数组中  
    5.遍历数组，取出每一个元素，并求和  
    6.输出总和
 *  代码实现：
    
        package com.itheima.test;
        
        import java.util.Scanner;
        
        public class Test3Array { 
            /* 需求：键盘录入5个整数，存储到数组中，并对数组求和 思路： 1.创建键盘录入对象，准备键盘录入 2.定义一个求和变量，准备记录累加后的结果 3.动态初始化一个长度为5的int数组，准备存储键盘录入的数值 4.将键盘录入的数值存储到数组中 5.遍历数组，取出每一个元素，并求和 6.输出总和 */
            public static void main(String[] args) { 
                // 1.创建键盘录入对象，准备键盘录入
                Scanner sc = new Scanner(System.in);
                // 2.定义一个求和变量，准备记录累加后的结果
                int sum = 0;
                // 3.动态初始化一个长度为5的int数组，准备存储键盘录入的数值
                int[] arr = new int[5];
                // 4.将键盘录入的数值存储到数组中
                for(int i = 0; i < arr.length; i++){ 
                    System.out.println("请输入第" + (i+1) + "个整数:");
                    //arr[i] = 10;
                    arr[i] = sc.nextInt();
                }
        
                // 5.遍历数组，取出每一个元素，并求和
                for (int i = 0; i < arr.length; i++) { 
                    sum += arr[i];
                }
        
                // 6.输出总和
                System.out.println("sum:" + sum);
        
            }
        }

### 数组基本查找【应用】 ###

*  需求：  
    已知一个数组 arr = \{19, 28, 37, 46, 50\}; 键盘录入一个数据，查找该数据在数组中的索引，并在控  
    制台输出找到的索引值。
 *  思路：  
    1.定义一个数组，用静态初始化完成数组元素的初始化  
    2.键盘录入要查找的数据，用一个变量接收  
    3.定义一个索引变量，初始值为-1  
    4.遍历数组，获取到数组中的每一个元素  
    5.拿键盘录入的数据和数组中的每一个元素进行比较，如果值相同，就把该值对应的索引赋值给索引变量，并结束循环  
    6.输出索引变量
 *  代码实现：
    
        public static void main(String[] args) { 
                // 1.定义一个数组，用静态初始化完成数组元素的初始化
                int[] arr = { 19, 28, 37, 46, 50};
                // 2.键盘录入要查找的数据，用一个变量接收
                Scanner sc = new Scanner(System.in);
                System.out.println("请输入您要查找的元素:");
                int num = sc.nextInt();
                // 3.定义一个索引变量，初始值为-1
                // 假设要查找的数据, 在数组中就是不存在的
                int index = -1;
                // 4.遍历数组，获取到数组中的每一个元素
                for (int i = 0; i < arr.length; i++) { 
                    // 5.拿键盘录入的数据和数组中的每一个元素进行比较，如果值相同，就把该值对应的索引赋值给索引变量，并结束循环
                    if(num == arr[i]){ 
                        // 如果值相同，就把该值对应的索引赋值给索引变量，并结束循环
                        index = i;
                        break;
                    }
                }
                // 6.输出索引变量
                System.out.println(index);
            }
        }

### 评委打分【应用】 ###

*  需求：在编程竞赛中，有6个评委为参赛的选手打分，分数为0-100的整数分。  
    选手的最后得分为：去掉一个最高分和一个最低分后 的4个评委平均值 (不考虑小数部分)。
 *  思路：  
    1.定义一个数组，用动态初始化完成数组元素的初始化，长度为6  
    2.键盘录入评委分数  
    3.由于是6个评委打分，所以，接收评委分数的操作，用循环  
    4.求出数组最大值  
    5.求出数组最小值  
    6.求出数组总和  
    7.按照计算规则进行计算得到平均分  
    8.输出平均分
 *  代码实现：
    
        public static void main(String[] args) { 
                // 1.定义一个数组，用动态初始化完成数组元素的初始化，长度为6
                int[] arr = new int[6];
                // 2.键盘录入评委分数
                Scanner sc = new Scanner(System.in);
                // 3.由于是6个评委打分，所以，接收评委分数的操作，用循环
                for (int i = 0; i < arr.length; i++) { 
                    System.out.println("请输入第" + (i+1) + "个评委的打分:");
                    int score = sc.nextInt();
                    if(score >= 0 && score <= 100){ 
                        // 合法的分值
                        arr[i] = score;
                    }else{ 
                        // 非法的分值
                        System.out.println("您的打分输入有误, 请检查是否是0-100之间的");
                        i--;
                    }
                }
        
                // 4.求出数组最大值
                int max = arr[0];
                for (int i = 1; i < arr.length; i++) { 
                    if(max < arr[i]){ 
                        max = arr[i];
                    }
                }
        
                // 5.求出数组最小值
                int min = arr[0];
                for (int i = 1; i < arr.length; i++) { 
                    if(min > arr[i]){ 
                        min = arr[i];
                    }
                }
        
                // 6.求出数组总和
                int sum = 0;
                for (int i = 0; i < arr.length; i++) { 
                    sum += arr[i];
                }
        
                // 7.按照计算规则进行计算得到平均分
                int avg = (sum - max - min ) / 4;
        
                // 8.输出平均分
                System.out.println(avg);
            }
        }

### 带返回值方法的练习-求两个数的最大值(应用) ###

*  需求：设计一个方法可以获取两个数的较大值，数据来自于参数
 *  思路：
    
    1.  定义一个方法，声明两个形参接收计算的数值，求出结果并返回
    2.  使用 if 语句 得出 a 和 b 之间的最大值，根据情况return具体结果
    3.  在main()方法中调用定义好的方法并使用 【 变量保存 】
 *  代码：
    
        /* 需求：设计一个方法可以获取两个数的较大值，数据来自于参数 1. 定义一个方法，声明两个形参接收计算的数值，求出结果并返回 2. 使用 if 语句 得出 a 和 b 之间的最大值，根据情况return具体结果 3. 在main()方法中调用定义好的方法并使用 【 变量保存 】 */
            public static void main(String[] args) { 
                // 3. 在main()方法中调用定义好的方法并使用 【 变量保存 】
                System.out.println(getMax(10,20));  // 输出调用
        
                int result = getMax(10,20);
                System.out.println(result);
        
                for(int i = 1; i <= result; i++){ 
                    System.out.println("HelloWorld");
                }
        
            }
        
            // 方法可以获取两个数的较大值
            public static int getMax(int a, int b){ 
                if(a > b){ 
                    return a;
                }else{ 
                    return b;
                }
            }
        
        }

### 6.2 方法重载练习 ###

*  需求：使用方法重载的思想，设计比较两个整数是否相同的方法，兼容全整数类型（byte,short,int,long）
 *  思路：
    
     ①定义比较两个数字的是否相同的方法compare()方法，参数选择两个int型参数
    
     ②定义对应的重载方法，变更对应的参数类型，参数变更为两个long型参数
    
     ③定义所有的重载方法，两个byte类型与两个short类型参数
    
     ④完成方法的调用，测试运行结果
 *  代码：
    
        public class MethodTest { 
            public static void main(String[] args) { 
                //调用方法
                System.out.println(compare(10, 20));
                System.out.println(compare((byte) 10, (byte) 20));
                System.out.println(compare((short) 10, (short) 20));
                System.out.println(compare(10L, 20L));
            }
        
            //int
            public static boolean compare(int a, int b) { 
                System.out.println("int");
                return a == b;
            }
        
            //byte
            public static boolean compare(byte a, byte b) { 
                System.out.println("byte");
                return a == b;
            }
        
            //short
            public static boolean compare(short a, short b) { 
                System.out.println("short");
                return a == b;
            }
        
            //long
            public static boolean compare(long a, long b) { 
                System.out.println("long");
                return a == b;
            }
        
        }

### 7.4 数组最大值 ###

*  需求：设计一个方法用于获取数组中元素的最大值
 *  思路：
    
     *  ①定义一个数组，用静态初始化完成数组元素初始化
     *  ②定义一个方法，用来获取数组中的最大值，最值的认知和讲解我们在数组中已经讲解过了
     *  ③调用获取最大值方法，用变量接收返回结果
     *  ④把结果输出在控制台
 *  代码：
    
        package com.itheima.test;
        
        public class Test2 { 
            /* 需求：设计一个方法用于获取数组中元素的最大值 思路： 1.定义一个数组，用静态初始化完成数组元素初始化 2.定义一个方法，用来获取数组中的最大值 3.调用获取最大值方法，用变量接收返回结果 4.把结果输出在控制台 */
            public static void main(String[] args) { 
                // 1.定义一个数组，用静态初始化完成数组元素初始化
                int[] arr = { 11, 55, 22, 44, 33};
                // 3.调用获取最大值方法，用变量接收返回结果
                int max = getMax(arr);
                // 4.把结果输出在控制台
                System.out.println(max);
            }
        
            /* 2.定义一个方法，用来获取数组中的最大值 1, 参数 int[] arr 2, 返回值类型 int */
            public static int getMax(int[] arr){ 
                int max = arr[0];
                for (int i = 1; i < arr.length; i++) { 
                    if(max < arr[i]){ 
                        max = arr[i];
                    }
                }
                return max;
            }
        }

### 7.5 方法同时获取数组最大值和最小值 ###

*  需求：设计一个方法，该方法能够同时获取数组的最大值，和最小值
 *  注意: return语句, 只能带回一个结果.
 *  代码：
    
        public class Test3 { 
            /* 需求：设计一个方法，该方法能够同时获取数组的最大值，和最小值 注意: return语句, 只能带回一个结果. */
            public static void main(String[] args) { 
        
                int[] arr = { 11,55,33,22,44};
        
                int[] maxAndMin = getMaxAndMin(arr);
        
                System.out.println(maxAndMin[0]);
                System.out.println(maxAndMin[1]);
        
            }
        
            public static int[] getMaxAndMin(int[] arr){ 
                int max = arr[0];
                for (int i = 1; i < arr.length; i++) { 
                    if(max < arr[i]){ 
                        max = arr[i];
                    }
                }
        
                int min = arr[0];
                for (int i = 1; i < arr.length; i++) { 
                    if(min > arr[i]){ 
                        min = arr[i];
                    }
                }
        
                int[] maxAndMin = { min, max};
        
                return maxAndMin;
            }
        }

### .7 二维数组遍历 ###

**需求 :**

已知一个二维数组 arr = \{ \{11, 22, 33\}, \{33, 44, 55\}\};

遍历该数组，取出所有元素并打印

**步骤 :**

1. 遍历二维数组，取出里面每一个一维数组
    2. 在遍历的过程中，对每一个一维数组继续完成遍历，获取内部存储的每一个元素

**代码实现 :**

package com.itheima.test;
    
    public class Test1 { 
        /* 需求: 已知一个二维数组 arr = { {11, 22, 33}, {33, 44, 55}}; 遍历该数组，取出所有元素并打印 步骤: 1. 遍历二维数组，取出里面每一个一维数组 2. 在遍历的过程中，对每一个一维数组继续完成遍历，获取内部存储的每一个元素 */
        public static void main(String[] args) { 
            int[][] arr = { { 11, 22, 33}, { 33, 44, 55}};
    
            // 1. 遍历二维数组，取出里面每一个一维数组
            for (int i = 0; i < arr.length; i++) { 
                //System.out.println(arr[i]);
                // 2. 在遍历的过程中，对每一个一维数组继续完成遍历，获取内部存储的每一个元素
                //int[] temp = arr[i];
                for (int j = 0; j < arr[i].length; j++) { 
                    System.out.println(arr[i][j]);
                }
            }
        }
    }

### 二维数组求和 ###

**需求 :**

某公司季度和月份统计的数据如下：单位(万元)
    第一季度：22,66,44
    第二季度：77,33,88
    第三季度：25,45,65
    第四季度：11,66,99

**步骤 :**

1.  定义求和变量，准备记录最终累加结果
2.  使用二维数组来存储数据，每个季度是一个一维数组，再将4个一维数组装起来
3.  遍历二维数组，获取所有元素，累加求和
4.  输出最终结果

**代码实现 :**

package com.itheima.test;
    
    public class Test2 { 
        /* 需求: 某公司季度和月份统计的数据如下：单位(万元) 第一季度：22,66,44 第二季度：77,33,88 第三季度：25,45,65 第四季度：11,66,99 步骤: 1. 定义求和变量，准备记录最终累加结果 2. 使用二维数组来存储数据，每个季度是一个一维数组，再将4个一维数组装起来 3. 遍历二维数组，获取所有元素，累加求和 4. 输出最终结果 */
        public static void main(String[] args) { 
            // 1. 定义求和变量，准备记录最终累加结果
            int sum = 0;
            // 2. 使用二维数组来存储数据，每个季度是一个一维数组，再将4个一维数组装起来
            int[][] arr = {  { 22,66,44} , { 77,33,88} , { 25,45,65} , { 11,66,99}};
            // 3. 遍历二维数组，获取所有元素，累加求和
            for (int i = 0; i < arr.length; i++) { 
                for(int j = 0; j < arr[i].length; j++){ 
                    sum += arr[i][j];
                }
            }
            // 4. 输出最终结果
            System.out.println(sum);
        }
    }