java基础课堂笔记02 - 流程控制语句课时
p33 Scanner类
1、Scanner类，是java提供的用户交互的工具类 java.util.Scanner，用来接收键盘的输入
1.1、基本语法格式：（//创建扫描器对象，并创建引用）
import java.util.Scanner;
Scanner scan = new Scanner(System.in);
1.2、另一种定义格式
java.util.Scanner scan = new java.util.Scanner(System.in);
2、Scanner类中包含的方法：
2.1、next()
- 接收一个字符串类型数据
- 一定要读取到有效字符后才能结束
- 有效字符之前的空白，next()方法会自动将其去掉
- 有效字符后的空白被作为结束符，因此next()不能得到带空格的字符串
2.2、nextLine()：
- 接收一个字符串类型数据
以Enter为结束符，返回输入的所有字符，可以获得空白
2.3、nextByte()
- 接收一个byte类型数据
2.4、nextInt()
- 接收一个int类型数据
2.5、nextLong()
- 接收一个long类型数据
2.6、nextDouble()
- 接收一个double类型数据
2.7、close()
- 关闭Scanner线程
- 凡是IO流的类都需要关闭否则会一直占用资源
3、hasNext() 与 hasNextLine()、hasNextInt、hasNextDouble() ...
- 判断是否还有对应类型的数据输入
- 如果有则执行相应的程序
- 如果接收到非对应类型的输入，则跳过程序相应
如：//判断是否有字符串输入
if(scanner.hasNext()){
String str = scanner.next();
java语句；
}
//判断是否有下一个整数输入
if(scanner.hasNextInt()){
int i = scanner.nextInt();
java语句；
}
//判断是否有数字输入
while (scanner.hasNextDouble()){
double d = scanner.nextDouble();
java语句；
}
示例1：用户交互Scanner及其方法
public class Test{ public static void main(String[] args){ java.util.Scanner scan = new java.util.Scanner(System.in); String s = scan.next(); System.out.println(s); String s1 = scan.nextLine(); System.out.println(s1); long s2 = scan.nextLong(); System.out.println(s2); byte s3 = scan.nextByte(); System.out.println(s3); //判断是否有数字输入 while (scan.hasNextDouble()){ double d = scan.nextDouble(); System.out.println(d); } //判断是否有字符串输入 if(scan.hasNext()){ String s4 = scan.next(); System.out.println(s4); } //判断是否有下一个整数输入 if(scan.hasNextInt()){ int i = scan.nextInt(); System.out.println(i); } } }
p35 java语句的语法结构概述：
1、顺序结构，是java语句的基本结构，按照顺序一句一句执行，是最简单的算法结构
2、java的控制语句包括3类：
选择语句
循环语句
转向语句
2.1、选择语句也叫分支语句
if语句
switch语句
2.2、循环语句
for循环
while循环
do...while循环
2.3、转向语句
break
continue
return
2.4、嵌套结构
- 所有合法的控制语句都可以嵌套使用，嵌套的时候最好一个语句一个语句进行分析，避免冗杂在一起
- 在分析外层语句的时候，把里面的代码块当做一段普通的java语句
- 最好的代码是：最少的代码量，最高的效率
p36 if 单选择结构
1、if语句的语法结构及执行原理：
- if语句是分支语句，也叫条件语句，一对大括号{}就是一个分支
1.1、if语句的4种语法格式：
1） if(布尔表达式){
java语句；
}
- 语法原理是：如果布尔表达式的结果是true，则执行分支的语句，如果是false则跳过分支
2） if(布尔表达式){
java语句；
}else{
java语句；
}
- 语法原理是：如果布尔表达式的结果是true，则执行分支1的语句，如果是false则跳过分支1，执行else分支的语句
3） if(布尔表达式1){
java语句；
}else if(布尔表达式2){
java语句；
}else if(布尔表达式3){
java语句；
}else if(布尔表达式4){
java语句；
} ... ...
- 语法原理是：先判断布尔表达式1的结果，如果是true，则执行分支1的语句，如果是false则跳过分支1；再判断布尔表达式2的结果，如果是true，则执行分支2，如果是false则跳过分支2；再判断布尔表达式3 ......
4） if(布尔表达式1){
java语句；
}else if(布尔表达式2){
java语句；
}else if(布尔表达式3){
java语句；
}else if(布尔表达式4){
java语句；
}else{
java语句；
}
- 语法原理是：先判断布尔表达式1的结果，如果是true，则执行分支1的语句，如果是false则跳过分支1；再判断布尔表达式2的结果，如果是true，则执行分支2，如果是false则跳过分支2；再判断布尔表达式3 ......，如果所有的布尔表达式都是false，则执行else分支
5）、当分支中的java语句只有一句时，那么大括号{}可以省略
if(布尔表达式)
java语句；
else
java语句；
1.2、语法说明：
- 如果布尔表达式为空，则默认条件的值为ture
- 从上往下依次判断，只要某个分支执行，则整个if语句结束
- 对于if语句，在任何情况下只能有一个分支执行，不可能存在2个或更多分支执行
- 以上4中语法机制中，第二种和第四种是带有else分支语句，一定可以保证会有一个分支执行
- 第一种和第三种没有else分支的语句，这种语句可能导致所有的分支都不执行
示例1：根据年龄判断生命阶段，if语句的应用，最好的代码是：最少的代码量，最高的效率
/* 业务要求： 1、从键盘上接收一个人的年龄 2、年龄要求为【0-150】，其它值要提示非法信息 3、根据人的年龄来动态判断这个人属于生命的哪个阶段 【0-5】婴幼儿 【6-10】少儿 【11-18】少年 【19-35】青年 【36-55】中年 【56-150】老年 4、请使用if语句完成以上的业务逻辑 */ public class Test{ public static void main(String[] args){ java.util.Scanner s = new java.util.Scanner(System.in); System.out.println("请输入年龄："); int age = s.nextInt(); /* if(age < 0 || age > 150){ System.out.println("对不起，年龄不合法"); }else{ //能够走到这个分支，说明年两是合法的，布尔表达式可以改良 //if(age >= 0 && age <= 5){} if(age < 5){ System.out.println("婴幼儿"); }else if(age < 10){ System.out.println("少儿"); }else if(age < 18){ System.out.println("少年"); }else if(age < 35){ System.out.println("青年"); }else if(age < 55){ System.out.println("中年"); }else { System.out.println("老年"); } } */ /* //不嵌套改良 if(age < 0 || age > 150){ System.out.println("对不起，年龄不合法"); }else if(age < 5){ System.out.println("婴幼儿"); }else if(age < 10){ System.out.println("少儿"); }else if(age < 18){ System.out.println("少年"); }else if(age < 35){ System.out.println("青年"); }else if(age < 55){ System.out.println("中年"); }else { System.out.println("老年"); } */ /* //这里存在一个bug String str = "老年"; if(age < 0 || age > 150){ System.out.println("对不起，年龄不合法"); //return; //这里存在一个bug }else if(age < 5){ str = "婴幼儿"; }else if(age < 10){ str = "少儿"; }else if(age < 18){ str = "少年"; }else if(age < 35){ str = "青年"; }else if(age < 55){ str = "中年"; } System.out.println(str); */ //进一步改良 String str = "老年"; if(age < 0 || age > 150){ str = "对不起，年龄不合法"; }else if(age < 5){ str = "婴幼儿"; }else if(age < 10){ str = "少儿"; }else if(age < 18){ str = "少年"; }else if(age < 35){ str = "青年"; }else if(age < 55){ str = "中年"; } System.out.println(str); } }
示例2：根据成绩判断等级，if语句的应用
/* 题目： 1、系统接收一个学生的考试成绩，根据考试成绩输出成绩的等级 2、等级： 优：【90-100】 良：【80-90） 中：【70-80） 及格：【60-70） 不及格：【0-60） 3、要求成绩是一个合法的数字，成绩必须在【0-100】之间，成绩可能带有小数 */ public class IfTest{ public static void main(String[] args){ java.util.Scanner s = new java.util.Scanner(System.in); System.out.print("请输入成绩："); double score = s.nextDouble(); String str = "不及格"; if(score < 0 || score > 100){ System.out.println("成绩不合法！"); return; }else if(score < 60){ }else if(score < 70){ str = "及格"; }else if(score < 80){ str = "中"; }else if(score < 90){ str = "良"; }else{ str = "优"; } System.out.println(str); } }
示例3：按需求写代码，if嵌套
/* 需求： 从键盘上接收天气的信息： 1表示雨天 0表示晴天 同时从键盘上接收性别的信息： 1表示男 0表示女 当天气是雨天的时候 男：带一把大黑伞 女：带一把小花伞 当天气是晴天的时候： 男：戴墨镜玩耍 女：擦防晒霜 使用if语句及嵌套的方式来展现业务 可以在程序的开始，接收两个数据，一个是天气，一个是性别，将这两个数据保存到变量中 */ public class Test{ public static void main(String[] args){ java.util.Scanner s = new java.util.Scanner(System.in); System.out.println("请输入当前的天气：1表示下雨，0表示晴天"); int weather = s.nextInt(); System.out.println("请输入您的性别：1表示男，0表示女"); int gender = s.nextInt(); //判断天气状况 if(weather == 1){ if(gender == 1){ System.out.println("下雨了，请带一把大黑伞"); }else if(gender == 0){ System.out.println("下雨天，带一把小花伞"); }else { System.out.println("输入错误"); } }else if(weather == 0){ if(gender == 1){ System.out.println("天气不错，老铁们出去玩耍吧"); }else if(gender == 0){ System.out.println("天气晴朗，小姐姐保护好皮肤哦，请擦点防晒霜"); }else { System.out.println("输入错误"); } } } }
p37 switch 多选择结构
2、switch语句的语法结构与执行原理
- switch语句，也叫做分支语句
2.1、switch语句的语法结构：
switch(值){
case 值1：
java语句；
break；
case 值2：
java语句；
break；
case 值3：
java语句；
break；
default：
java语句；
}
- 这是一个完整的switch语句，其中break不是必须的，default也不是必须的
- switch语句支持的值有哪些？
* switch语句支持int类型与String类型，但要注意JDK版本，JDK8之前不支持String类型，只支持int
* byte、short、char也可以使用在switch语句中，因为可以自动类型转换
2.2、switch语句的执行原理：
- switch语句头中“值”与case的“值1”“值2”会使用“==”进行比较
- 拿switch的“值”与case的“值1”进行比较，如果相等，则执行分支1的语句；如果不相等，就与“值2”进行比较，如果相等，则执行分支2的语句 ......
- 如果所有的case都没有匹配成功，那么最后的default分支会执行
- 当遇到分支中的break语句时，switch语句结束
- 如果分支中没有break语句，此时会发生case穿透现象，继续执行后面的分支语句，直到再次遇到break或者穿透到底
2.3、case可以合并，可以有多个匹配条件
switch(值){
case 值1：case 值2：case 值3：
java语句；
break；
case 值4：
java语句；
break；
default：
java语句；
}
示例列举：
long x = 100L;
//错误: 不兼容的类型
switch(x){}
//正确，可以强制类型转换
switch((int)x){}
byte b = 10;
//正确，自动类型转换
switch(b){}
short s = 10;
//正确，
switch(s){}
char c = 'A';
//正确，字符是以数字形式进行比较匹配
switch(c){}
//正确，JDK8以后支持String类型
String name = "zhangsan";
switch(name){}
示例1：switch语句的用法，根据输入的数字来判断星期几
/* 题目： 写一个完整的switch语句 接收键盘输入，根据输入的数字来判断星期几 0 星期日 1星期一 ... */ public class SwitchTest{ public static void main(String[] args){ java.util.Scanner s = new java.util.Scanner(System.in); System.out.print("请输入【0-6】的整数："); int num = s.nextInt(); /* switch(num){ case 0: System.out.println("星期日"); break; case 1: System.out.println("星期一"); break; case 2: System.out.println("星期二"); break; case 3: System.out.println("星期三"); break; case 4: System.out.println("星期四"); break; case 5: System.out.println("星期五"); break; case 6: System.out.println("星期六"); break; } */ /* //default语句 switch(num){ case 1: System.out.println("星期一"); break; case 2: System.out.println("星期二"); break; case 3: System.out.println("星期三"); break; case 4: System.out.println("星期四"); break; case 5: System.out.println("星期五"); break; case 6: System.out.println("星期六"); break; default: System.out.println("星期日"); } */ //case合并 switch(num){ case 1:case 2:case 3:case 4: System.out.println("星期一"); break; case 5:case 6: System.out.println("星期二"); break; case 7: System.out.println("星期三"); break; case 8: System.out.println("星期四"); break; case 9: System.out.println("星期五"); break; case 10: System.out.println("星期六"); break; default: System.out.println("星期日"); } } }
示例2：根据成绩判断等级，使用switch语句
/* 2、等级： 优：【90-100】 良：【80-90） 中：【70-80） 及格：【60-70） 不及格：【0-60） 3、使用switch语句来完成 */ public class Test{ public static void main(String[] args){ java.util.Scanner s = new java.util.Scanner(System.in); System.out.print("请输入成绩："); double score = s.nextDouble(); if(score < 0 || score > 100){ System.out.print("输入的成绩不合法，再见"); return; } String str = "不及格"; int grade = (int)(score/10); /* grade的值可能是：0 1 2 ...10 0 1 2 3 4 5 不及格 6 及格 7 中 8 良 9 10 优 */ switch(grade){ case 9: case 10: str = "优"; break; case 8: str = "良"; break; case 7: str = "中"; break; case 6: str = "及格"; } System.out.println("学生的成绩等级是：" + str); } }
练习1：编辑一个简单计算器
/* 编辑一个简单计算器系统 实现思路： 1、选择所有数据从键盘输入 2、使用switch语句进行判断 3、需要从控制台输入三次 *第一个数字 *运算符 *第二个数字 */ public class Test{ public static void main(String[] args){ java.util.Scanner s = new java.util.Scanner(System.in); System.out.println("欢迎使用简单计算器系统"); System.out.println("请输入第一个数字"); int num1 = s.nextInt(); System.out.println("请输入运算符"); String operator = s.next(); System.out.println("请输入第二个数字"); int num2 = s.nextInt(); double result = 0; //按运算符进行匹配计算 switch(operator){ case "+": result = num1 + num2; break; case "-": result = num1 - num2; break; case "*": result = num1 * num2; break; case "/": result = num1 / num2; break; case "%": result = num1 % num2; } System.out.println(num1 + operator + num2 + "=" + result); } }
p38 while 与 do..while循环结构
3、while循环语句的语法机制及执行原理？
3.1、while循环语法结构：
while(布尔表达式){
java语句；
}
while(true){} //死循环
3.2、执行原理：
- 首先判断布尔表达式的结果，如果为true，就执行循环体；循环体结束之后，再次判断布尔表达式的结果，如果还是true，继续执行循环体 ......；直到布尔表达式的结果为false，while循环结束
- while循环的循环次数是0~n次
- 如果布尔值恒为true，循环就会一直执行下去，成为死循环
- while头的判断条件必须是一个布尔类型boolean，而且不能为空
- 本质上while循环和for循环原理是相同的，是完全可以互换的，只是语法格式不同
初始化表达式；
while(布尔表达式){
java语句；
更新表达式；
}
例：while(2 > 1){System.out.println("这是一个死循环");}
4、do..while循环语句的语法机制及执行原理？
4.1、do..while循环的语法结构：
do{
java语句;
} while(布尔表达式);
do{
} while(true); //死循环
4.2、执行原理：
- 先执行循环体中的代码，执行一次循环体之后，再判断布尔表达式的结果，如果为true，则继续执行一次循环体，如果为false，则循环结束
- while循环是先判断再执行， do..while是先执行后判断
- 对于do..while来说，循环体至少执行一次，循环体的执行次数是1~n次
p40 for 循环结构
5、for循环语句是支持迭代的一种通用结构，for循环的语法机制与运行原理？
5.1、for 循环的语法结构：
for (初始化表达式; 布尔表达式; 更新表达式){
java语句;
java语句;
}
for(;;){} //死循环
- for循环的循环次数在执行前就是确定的（100.fori）
- 最先执行初始化表达式，并且在整个循环中只执行1次
- 条件表达式的结果必须是一个布尔类型boolean：true或false
5.2、执行原理：
- 先执行初始化表达式，然后判断条件表达式的结果；如果为true，则执行循环体；一次循环结束之后执行更新表达式；变量更新后，再判断条件表达式的结果，如果还是true，继续执行循环体 ......；直到条件表达式的结果为false，for循环终止
- 更新表达式的作用是：推动条件表达式达到临界条件，控制循环的次数，避免陷入死循环
示例1：for循环的多种变形样式
public class Test{ public static void main(String[] args){ /* for(int i = 0;i < 10;i++){ System.out.println(i); } */ /*变形1 int i = 0; for(;i < 10;i++){ System.out.println(i); } */ /*变形2 for(int i = 0;i < 10;){ System.out.println(i); i++; } */ /*变形3 for(int i = 0;i < 10;){ i++; System.out.println(i); } */ /*变形4 for(int i = 0;i < 10;i+=2){ System.out.println(i); } */ //变形5 for(int i = 10;i > 0;i--){ System.out.println(i); } } }
练习2：求【1-100】之间的所有奇数之和
/* 使用for循环，求【1-100】之间的所有奇数之和 至少给出两种解决方案 思路： 第一步：先获取【1-100】的数字 第二步：进一步判断这个数字是否为奇数，奇数对2取余，结果都是1 第三部：将奇数累加 */ public class Test{ public static void main(String[] args){ int sum = 0; for(int i = 1;i < 100;i++){ if(i%2 == 1){ sum +=i; } } System.out.println("1~100之间的所有奇数之和是：" + sum); //第二种方案循环更少，效率更高 int sum1 = 0; for(int i = 1;i < 100;i+=2){ sum1 +=i; } System.out.println("1~100之间的所有奇数之和是：" + sum1); } }
练习3：打印九九乘法表
/* 打印九九乘法表 1*1=1 1*2=2 2*2=4 1*3=3 2*3=6 3*3=9 ... ... ... ... 1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81 分析九九乘法表的特点： 第一：共9行 第二：第1行1个 第2行2个 第3行3个...第n行n个 首先获取1-9行的数字 然后获取一行里的算式，内部循环负责输出一行的 */ public class Test{ public static void main(String[] args){ for (int i = 1; i <= 9; i++) { for (int j = 1; j <= i ; j++) { System.out.print(j + "*" + i + "=" + j*i + "\t"); } System.out.println(); } } }
5.3、for each 循环
增强 for 循环主要用于遍历数组或集合，使变量获取所有元素的值
for(声明变量 : 数组名或数组表达式){
循环体；
}
1）声明语句：声明一个局部变量，无需初始化，该变量类型必须和数组元素的类型匹配
2）表达式：是要访问的数组名，或者是返回值为数组的方法
3）变量将获取数组的所有元素的值
//打印数组元素
for(type variable : arrayName){
System.out.println(variable);
}
int[] a = {1,2,3};
for(int i : a){ //遍历a的元素
System.out.println(i);
}
p43 break continue goto
6、break;
- break语句是一个单词成为一个完整的java语句，continue同样如此
- 翻译为打断、终止
6.1、break语句用在哪里呢？
* 用在switch语句当中，用来终止switch语句，并防止case穿透现象
* 用在循环语句的中，用来终止循环语句的执行，跳出循环语句
* 只能终止离它最近的那个循环语句
* 不对 if 语句起作用
6.2、如何终止指定的循环呢？
* 首先给循环起个名字，即使用标签，然后使用break终止标签
如：a：for(){
b：for(){
break a；
}
}
7、continue;
- continue一个单词成为一个完整的java语句
- 翻译为继续
7.1、continue语句的用法？
* continue语句只能用在循环语句当中
* 用于终止当前本次循环，跳过循环体剩余的语句，继续执行下一次循环判定
* continue语句同样可以使用标签，终止标签命名的循环
如：a：for(){ b：for(){ continue a； } }
7.2、goto：
break label;
continue label;
- java没有goto，但有带标签的break和continue，java唯一用到标签的地方是在嵌套循环，用来终止指定命名的循环语句
作业练习：编程最重要的一个环节是书写文字思路，思路是一步一步分析出来的，思路有了，代码就不远了
作业1：计算1+2-3+4-5+6-7...+100的结果
/* 计算1+2-3+4-5+6-7...+100的结果 找规律：奇数时减法，偶数时加法 第一种思路：除1之外所有的偶数求和，所有的奇数求和，然后和相减 第二种思路：循环获取1-100的值，判断奇偶，偶数累加，奇数追减 */ public class Test{ public static void main(String[] args){ int sum = 1; for(int i = 2;i <= 100;i++){ if(i%2 == 0){ sum += i; }else{ sum -= i; } } System.out.println(sum); } }
作业2：计算1000以内不能被7整除的整数之和
/* 计算1000以内不能被7整除的整数之和 第一步：获取1-1000的整数 第二步：判断整数是否“不能被7整除” 第三步：对符合要求的整数累加 */ public class HomeWork{ public static void main(String[] args){ int sum = 0; for(int i = 1;i <= 1000;i++){ if(i%7 != 0){ sum += i; } } System.out.println(sum); } }
作业3：从控制台输入一个正整数，计算该数的阶乘
/* 从控制台输入一个正整数，计算该数的阶乘 分析： 5的阶乘：5*4*3*2*1 8的阶乘：8*7*6*5*4*3*2*1 第一步：从键盘接收一个正整数 第二步：循环递减的方式，获取n-1的数字 第三步：将数字累乘 */ public class HomeWork{ public static void main(String[] args){ java.util.Scanner s = new java.util.Scanner(System.in); System.out.print("请输入一个正整数："); int num = s.nextInt(); int sum = 1; for(int i = num;i > 1;i--){ sum *= i; } System.out.println(sum); } }
作业4：从控制台输入一个正整数，判断该数字是否为质数，巧用外部旗帜/布尔标记
/* 从控制台输入一个正整数，判断该数字是否为质数 质数是在大于1的自然数中，除了1和它本身以外没有其它因数的自然数 分析： 第一步：从键盘接收一个正整数n 第二步：判断n是否为质数，设i为（1-n）之间的数字，判断n是否能被i整除 小技巧：在外部巧用旗帜/布尔标记 */ public class HomeWork{ public static void main(String[] args){ java.util.Scanner s = new java.util.Scanner(System.in); System.out.print("请输入一个正整数："); int num = s.nextInt(); boolean flag = true; for(int i = 2;i <= num/2;i++){ if(num%i == 0){ flag = false; break; } } if(flag){ System.out.println(num + "是质数"); }else{ System.out.println(num + "不是质数"); } } }
作业5：从键盘接收一个正整数，以该正整数为行数，输出一个三角形图形
/* 从键盘接收一个正整数，以该正整数为行数，输出以下图形，如输入5则打印下图 * *** ***** ******* ********* 空格的规律： 第1行4个空格5-1 第2行3个空格5-2 第3行2个空格5-3 第4行1个空格5-4 第5行0个空格5-5 5-行号 个 星号的规律： 第1行1个 第2行3个 第3行5个 第4行7个 第5行9个 ...... 行号*2-1 个 思路： 第一步：接收键盘输入作为行数 第二步：打印空格，每行打印“5-行号”个空格：循环“5-行号”次，打印5行：循环5次 第三步：挨着空格打印星号，每行打印“行号*2-1”个星，打印n行 */ public class HomeWork{ public static void main(String[] args){ java.util.Scanner s = new java.util.Scanner(System.in); System.out.print("请输入一个正整数："); int rows = s.nextInt(); for(int j = 1;j <= rows;j++){ //设j为行号 for(int i = 1;i <= rows-j;i++){ //输出一行空格 System.out.print("_"); } for(int k = 1;k <= j*2-1;k++){ //输出一行星号 System.out.print("*"); } System.out.println(); } } }
作业6：文字题，小芳的妈妈每天给她2.5元钱
/* 小芳的妈妈每天给她2.5元钱，她都会存起来，但是，每当这一天是存钱的第5天或者5的倍数的话，她都会花去6元钱，请问，经过多少天，小芳才可以存到100元钱 分析操作点： 第一：小芳每天有2.5元收入，天数day递增，钱数money累加2.5 第二：天数是5的倍数时，花去6元 第三步：钱数>=100时，输出天数 */ public class HomeWork{ public static void main(String[] args){ int day = 0; double money = 0; while(money < 100){ day++; money += 2.5; if(day % 5 == 0){ money -= 6; } } System.out.println(day); } }
作业7：找出1000内所有的完数
/* 一个数如果恰好等于它的因子之和，这个数就是完数，例如6=1+2+3，编程找出1000内所有的完数 思路： 什么是因子？ 若一整数能除尽另一整数，没有余数，那么前者称为后者的因数/因子 第一步：获取1-1000的正整数 第二步：获取正整数的所有因子（除自身以外），并累加因子 第三步：判断是否是完数 */ public class HomeWork{ public static void main(String[] args){ for(int i = 1;i <= 1000;i++){ int sum = 0; for(int j = 1;j <= i/2;j++){ if(i%j == 0){ sum += j; } } if(i == sum){ System.out.println(i + "是一个完数"); } } } }
题目8：计算5位数中有多少个回文数
/* 判断10000-99999的5位数中有多少个回文数，回文数即12321是回文数，个位与万位相同，十位与千位相同 思路： 第一步：获取所有的5位数的整数 第二步：分别获取整数的个位 十位 千位 万位的数字 第三步：判断是否是回文数，计数累计 */ public class HomeWork{ public static void main(String[] args){ int a = 0,b = 0,c = 0,d = 0; int count = 0; for(int i = 10000;i <= 99999;i++){ a = i % 10; b = i % 100 / 10; c = i / 1000 % 10; d = i / 10000; if(a == d && b == c){ count++; //System.out.println(i); } } System.out.println(count); } }
题目9：文字题，猴子吃桃问题
/* 题目：猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，还不过瘾，又多吃了一个。第二天早上又将剩下的桃子吃了一半，又多吃了一个。以后每天早上都吃了前一天剩下的一半零一个。到第10天早上想再吃时，只剩下一个桃子了。求第一天共摘了多少？ 分析： 第一：从第10天往前推，day = 10，第十天是1个桃子 num = 1 第二：前一天的数量是今天（n+1）*2 第三：天数递减，day-- ，直到获取第一天的桃子数量 */ public class HomeWork{ public static void main(String[] args){ int num = 1; for(int day = 10;day > 1;day--){ num = (num+1)*2; } System.out.println(num); } }
题目10：计算1!+2!+3!+4!+...+10!
/* 题目：计算1!+2!+3!+4!+...+10! 4! = 1*2*3*4 思路： 第一步：获取1-10的整数i 第二步：计算整数的阶乘i！= 1*2*3...*i 第三步：所有的阶乘值累加 */ public class HomeWork{ public static void main(String[] args){ int result = 0; for(int i = 1;i <= 10;i++){ int sum = 1; for(int j = 1;j <= i;j++){ sum *= j; } result += sum; } System.out.println(result); } }
题目11：文字题，一球从100米高度自由落下
/* 题目：一球从100米高度自由落下，每次落地后弹回原高度的一半再落下，求它在第10次落地时，共经过了多少米？ 分析： 第1次落地高度是100 h 第2次落地高度是100/2 h/=2 第3次落地高度是100/2/2 h/=2 第4次落地高度是100/2/2/2 h/=2 反弹高度追除2 思路： 第一步：获取1-10的落地次数， 第二步：每次落地经过的路程是高度的两倍h*2,并且下次的高度减半h/=2 第三步：累加每次的路程就是总路程 */ public class HomeWork{ public static void main(String[] args){ double hight = 100; double length = 0; for(int i = 1;i <= 10;i++){ length += hight*2; hight /= 2; } System.out.println(length-100); } }
题目12：根据条件筛选数字
/* 题目：一个四位数，恰好等于去掉它的首位数字之后所剩的三位数的3倍，这个四位数是多少？ 思路： 第一步：这个数字是1000-9999之间，获取4位数的整数 第二步：截取前三位数字 第三步：判断后三位*3是否等于它 */ public class HomeWork{ public static void main(String[] args){ int n = 0; for(int i = 1000;i <= 9999;i++){ n = i%1000; if(i == n*3){ System.out.println(i); } } } }
题目13：输出1-1000之间能被5整除的数，并且每行输出10个
/* 题目：输出1-1000之间能被5整除的数，并且每行输出10个 思路： 第一步：获取1-1000的整数 第二步：判断能否被5整除 第三步：计数输出 */ public class HomeWork{ public static void main(String[] args){ int count =0; for (int i = 1; i < 1000; i++) { if(i % 5 == 0){ System.out.print(i + "\t"); count ++; if(count%10 == 0){ System.out.println(); } } } } }
题目14：使用循环结构打印如下数值列表
/* 编写java程序，使用循环结构打印如下数值列表： 1 10 100 1000 2 20 200 2000 3 30 300 3000 4 40 400 4000 5 50 500 5000 思路： 第一：获取1-5的行数 第二：获取1-4列 第三：输出行里的数值 */ public class HomeWork{ public static void main(String[] args){ for(int i = 1;i <= 5;i++){ int num = i; for(int j = 1;j <= 4;j++){ System.out.print(num + " "); num *= 10; } System.out.println(); } } }
题目15：打印2-10000的所有素数
/* 打印2-10000的所有素数，每行显示8个 思路： 第一步：获取2-10000的整数数 第二步：判断是否质数 第三步：使用布尔标识，使用计数器，输出质数 */ public class HomeWork{ public static void main(String[] args){ int count = 0; for(int i = 2;i <= 10000;i++){ boolean flag = true; for(int j = 2;j <= i/2;j++){ if(i%j == 0){ flag = false; break; } } if(flag == true){ System.out.print(i + "\t"); count++; if(count%8 == 0){ System.out.println(); } } } } }
题目16：文字题，经过几次球的高度是0.1米
/* 篮球从5米高的地方掉下来，每次弹起的高度是原来的30%，经过几次球的高度是0.1米 分析： 第1次弹起的高度是5*0.3 第2次弹起的高度是5*0.3*0.3 ... 当高度<=0.1时，输出次数 */ public class HomeWork{ public static void main(String[] args){ int count = 0; int hight = 5; while(hight > 0.1){ count++; hight *= 0.3; } System.out.println(count); } }
//即使再小的帆也能远航2021-10-21
