跟光磊学Java应用开发与系统架构-Java程序流程控制
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了跟光磊学Java应用开发与系统架构-Java程序流程控制，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含63175字，纯文字阅读大概需要91分钟。
内容图文
跟光磊学Java应用开发与系统架构-Java程序流程控制
跟光磊学Java应用开发与系统架构流程控制语句概述
之前编写的绝大多数程序都是顺序执行，也就是从main函数开始，由上到下一行一行的顺序执行，也被称为顺序结构。
在生活中除了顺序结构以外还有分支结构、循环结构，例如在淘宝购物时登录账号就是一个分支结构，如果输入的正确的用户名和密码才能购买商品，否则就会提示用户名密码错误。
而在淘宝首页的Banner就是一个循环结构,在指定的时间内循环切换图片。
在Java中，支持if/else和switch case两种分支结构，同时支持while，do...while,for循环以及JDK1.5以后支持foreach循环，同时还支持带标签的循环结构以及通过使用break,continue来中断循环。
package net.ittimeline.java.core.jdk.foundational.control;
/**
* 理解变量，表达式，语句
*
* 值: 就是指的数据
* 变量:用来存储或者保存值
* 表达式:由变量和运算符组成，目的是完成某项计算
* 语句:可以独立执行，并且是为了完成某项任务(例如打印输出变量值或者赋值),不是所有的表达式加;构成语句
*
* 三种流程控制语句
* 顺序结构:从上往下依次执行
* 分支结构:选择其中的一个分支执行
* 循环结构:重复执行某些语句
*
* @author liuguanglei 18601767221@163.com
* @version 2020/11/10 8:50 上午
* @since JDK11
*/
public class StatementTest {
public static void main(String[] args) {
int number = 10;
// 这个表达式计算完成以后，没有任何赋值或者打印的操作，因此这里不能算语句
// number > 0 ? true : false;
//顺序结构
System.out.println("number = " + number);
//分支结构
if (number % 2 == 0) {
System.out.printf("%d是偶数\n", number);
} else {
System.out.printf("%d不是偶数\n", number);
}
//循环结构
for (int i = 0; i < 5; i++) {
System.out.println(number);
}
}
}
使用Scanner读取键盘输入
平常在使用PC浏览电商网站时，如果想要购买商品通常需要输入用户名和密码来登录系统。
而登录的目的正是验证账号的合法性，在Java中可以使用Scanner类来模拟用户的输入数据，
可以读取的数据类型是boolean,byte,short,int,long,String,double等等，可以通过IDEA的Structure视图查看Scanner类的源码支持读取的类型。
在Java程序中如果想要使用一个类，必须使用import关键字加上类的包名+类名+分号实现,而且导包语句在package语句之后
import java.util.Scanner;
Java默认为所有的源文件导入java.lang包下的类，因此在之前编写的Java程序中使用的String,System等类无需使用import导入。
Java开发中常用的包还有util,io,nio,text,time等等。同学们有时间可以多去看看这些包下的源码实现，提升自己的编程功底。
在导入之后便可以通过new关键字创建Scanner对象来模拟键盘，
同时在Scanner构造器中传入System.in作为数据的来源，表示来源于控制台
Scanner input =new Scanner(System.in);
使用Scanner读取用户信息并输出到控制台
package net.ittimeline.java.core.jdk.foundational.control;
import java.util.Scanner; //导入位于java.util包中的Scanner类
/**
* 使用Scanner读取用户信息并输出到控制台
*
* @author liuguanglei 18601767221@163.com
* @version 2020/11/10 9:15 下午
* @since JDK11
*/
public class ScannerTest {
/**
* 使用Scanner读取用户从键盘输入的常用数据类型
*
* @param args
*/
public static void main(String[] args) {
//创建扫描仪，指定数据的来源是从控制台终端
// Scanner是java.util包中的一个类，属于引用数据类型，用于扫描数据
// input是一个引用类型的变量，代表Scanner对象
// new Scanner(System.in) 是给input赋值，用于创建Scanner对象
// System.in 指定的数据来源是表示的输入设备，默认代表键盘输入
Scanner input = new Scanner(System.in);
//提示信息在输入数据之前执行
System.out.println("请输入你的年龄");
//nextInt()是Scanner对象的方法
//读取整数值
int age = input.nextInt();
System.out.println("请输入你的身高");
//读取double值
double height = input.nextDouble();
System.out.println("请输入你的性别?");
//读取字符.即字符串的第一个字符
char gender = input.next().charAt(0);
System.out.println("请输入你的姓名");
//读取字符串
String name = input.next();
if ('男'==gender) {
System.out.printf("%s先生 你的年龄是%d，你的身高是%.2f", name, age, height);
} else {
System.out.printf("%女士 你的年龄是%d，你的身高是%.2f", name, age, height);
}
}
}
程序运行结果
关于Scanner类的更多介绍以及使用方式，可以查阅JDK的API文档
分支结构
条件判断
if/else用于布尔类型的变量或者表达式作为条件判断来进行程序流程控制，if/else语句有单分支if条件判断，双分支if/else条件判断和多分支if/else if/else if /else条件判断三种结构。
单分支条件判断-if语句
- if语句的语法结构
if(条件表达式){
代码块
}-
if语句的执行流程
执行流程是如果条件表达式结果为true，则会执行代码块的内容
-
if语句的注意事项
条件表达式的结果类型是boolean值，例如boolean类型的变量，逻辑运算符，关系运算符
如果代码块只有一条执行语句,其中一条执行语句可以是简单语句，也可以是复合语句，可以省略{}，但是日常开发中不建议省略，这样是为了增强代码的可读性
if语句案例:读取用户输入的年份，并判断是不是闰年，计算闰年对应2月份的天数
package net.ittimeline.java.core.jdk.foundational.control.ifstatement;
import java.util.Scanner;
/**
* 分支结构之条件判断
* 单分支条件判断
*
* 语法格式
* if(条件表达式){
* 代码块
* }
* 条件表达式的结果类型是boolean值，例如boolean类型的变量，逻辑运算符，关系运算符
* 如果代码块只有一条执行语句，可以省略{}，但是日常开发中不建议省略，这样增强代码的可读性
*
*
*
* @author liuguanglei 18601767221@163.com
* @version 2020/11/10 9:53 上午
* @since JDK11
*/
public class IfStatementTest {
public static void main(String[] args) {
//创建扫描仪
Scanner input=new Scanner(System.in);
System.out.println("请输入年份");
//接收用户输入的年份
int year=input.nextInt();
//判断年份是否是闰年，并显示2月份的总天数
// 判断一年是否是闰年的标准 ①可以被4整除，不能被100整除 ② 可以被400整除
// 平年2月是28天，如果是闰年2月是29天
// 初始化整数变量day的值为平年的天数
int day=28;
//短路与的优先级高于短路或 ()可以省略
if((year%4==0&&year%100!=0) || (year%400==0)){
//if 语句的条件成立，才会执行if()语句的代码块内容
day=29;
System.out.printf("%d是闰年,2月份的天数是%d",year,day);
}
}
}
双分支条件判断-if/else语句
- if/else语句的语法结构
if(条件表达式){
代码块1
}else{
代码块2
}-
if/else语句的执行流程
如果条件表达式结果为true,执行代码块1;否则执行代码块2
-
if/else语句注意事项
条件表达式的结果类型是boolean值，例如boolean类型的变量，逻辑运算符，关系运算符
如果代码块只有一条执行语句,其中一条执行语句可以是简单语句，也可以是复合语句，可以省略{}，但是日常开发中不建议省略，这样是为了增强代码的可读性
if/else语句案例1:判断用户输入的整数是不是偶数
package net.ittimeline.java.core.jdk.foundational.control.ifstatement;
import java.util.Scanner;
/**
* 分支结构之条件判断
* 双分支条件判断
* 双分支条件判断是2选1，
* 语法格式
* if(条件表达式){
* 代码块1
* }else{
* 代码块2
* }
* 执行流程:如果条件表达式结果为true,执行代码块1;否则执行代码块2
*
*
* @author liuguanglei 18601767221@163.com
* @version 2020/11/10 10:07 上午
* @since JDK11
*/
public class IfElseStatementTest {
public static void main(String[] args) {
//创建扫描仪
Scanner input=new Scanner(System.in);
System.out.println("请输入一个整数");
//接收用户输入的年份
int number=input.nextInt();
if(number%2==0){
System.out.printf("%d是偶数",number);
}else{
System.out.printf("%d不是偶数",number);
}
}
}
if/else语句案例2:判断用户输入的年份是不是闰年
package net.ittimeline.java.core.jdk.foundational.control.ifstatement;
import java.util.Scanner;
/**
* 判断用户输入的年份是不是闰年
* @author liuguanglei 18601767221@163.com
* @version 2020/11/10 3:40 下午
* @since JDK11
*/
public class IfElseStatementLeapYearExample2 {
public static void main(String[] args) {
//创建虚拟键盘
Scanner input =new Scanner(System.in);
System.out.println("请输入年份");
int year=input.nextInt();
/**
* 闰年判断的公式
* 年份能被4整除不能被100整除 或者 年份不能被400整除
*
* 2016 2020 都是闰年
*/
boolean flag=(year%4==0&&year%100!=0)||year%400==0;
if(flag){
System.out.printf("你输入的年份%d是闰年",year);
}
else{
System.out.printf("你输入的年份%d不是闰年",year);
}
}
}
if/else语句案例3:使用if/else模拟淘宝登录
package net.ittimeline.java.core.jdk.foundational.control.ifstatement;
import java.util.Scanner;
/**
* 使用if/else模拟淘宝登录
* @author liuguanglei 18601767221@163.com
* @version 2020/11/10 3:40 下午
* @since JDK11
*/
public class IfElseStatementTaoBaoLoginExample3 {
public static void main(String[] args) {
Scanner input =new Scanner(System.in);
System.out.println("请输入你的用户名");
String name =input.next();
System.out.println("请输入你的密码");
String password=input.next();
String targetName="tony";
String targetPassword="123456";
if(targetName.equals(name)&&targetPassword.equals(password)){
System.out.println("欢迎登录淘宝");
}
else{
System.out.println("用户名或者密码输入错误，请检查");
}
}
}
多分支条件判断-if/else if/else语句
- if/else if /else语句的语法结构
if(条件表达式1){
代码块1
}else if(条件表达式2){
代码块2
}else if(条件表达式3){
代码块3
}else{
代码块4
}
-
if/else if /else的执行流程
当条件表达式1成立时，执行代码块1
当条件表达式1不成立时，执行条件表达式2，如果条件表达式2成立，则执行代码块2
当条件表达式2不成立时，执行条件表达式3，如果条件表达式3成立，则执行代码块3
当条件表达式1,2,3不成立时，执行代码块4，其中else{}语句在if/else if 语句中是可选的
-
if/else if /else的使用注意事项
-
所有的条件表达式必须是boolean类型的值
-
当{}代码块的语句只有一句时，可以省略{}，但是还是不建议省略，增强程序的可读性
-
当多个条件的范围是互斥关系(没有重叠部分)，顺序可以随意
-
当多个条件的范围是包含关系(有重叠部分)，顺序不能随意,范围小的在上，范围大的在下。
理解if/else if/else语句的执行过程
package net.ittimeline.java.core.jdk.foundational.control.ifstatement;
import java.util.Scanner;
/**
* 分支结构之条件判断
* 多分支条件判断:多选一
*
* 语法格式
* if(条件表达式1){
* 代码块1
* }else if(条件表达式2){
* 代码块2
* }else if(条件表达式3){
* 代码块3
* }else{
* 代码块4
* }
*
* 执行流程
* 当条件表达式1成立时，执行代码块1
* 当条件表达式1不成立时，执行条件表达式2，如果条件表达式2成立，则执行代码块2
* 当条件表达式2不成立时，执行条件表达式3，如果条件表达式3成立，则执行代码块3
* 当条件表达式1,2,3不成立时，执行代码块4，其中else{}语句在if/else if 语句中是可选的
*
* 执行的特点:
* 多分支条件判断是多选1
* if/else if是从上往下执行，如果上面的条件成立，那么不会再执行下面剩余的语句，如果上面的条件不成立，才会执行剩余的语句
*
* 注意事项:
* 所有的条件表达式必须是boolean类型的值
* 当{}代码块的语句只有一句时，可以省略{}，但是还是不建议省略，增强程序的可读性
*
* 当多个条件的范围是互斥关系(没有重叠部分)，顺序可以随意
* 当多个条件的范围是包含关系(有重叠部分)，顺序不能随意,范围小的在上，范围大的在下。
*
* @author liuguanglei 18601767221@163.com
* @version 2020/11/10 10:12 上午
* @since JDK11
*/
public class IfElseIfStatementTest {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
System.out.println("请输入你的分数:");
int score=input.nextInt();
/*
成绩计算的规则
100分，输出成绩满分
90-99 输出成绩优秀
70-89 输出成绩良好
60-69 输出成绩及格
60以下，输出成绩不及格
*/
// 条件的顺序可以随意，因为是互斥，不存在重叠部分，即存在包含关系
if(score==100){
System.out.println("成绩满分");
}else if(score>=90 && score<=99){
System.out.println("成绩优秀");
}else if(score>=70&&score<=89){
System.out.println("成绩良好");
}else if(score>=60&&score<=69){
System.out.println("成绩及格");
}else if(score<60){
System.out.println("成绩不及格");
}
//优化
//但是不能改变顺序，因为存在重叠部分，即存在包含关系
if(score==100){
System.out.println("成绩满分");
}else if(score>=90){
System.out.println("成绩优秀");
}else if(score>=70){
System.out.println("成绩良好");
}else if(score>=60){
System.out.println("成绩及格");
}else if(score<60){
System.out.println("成绩不及格");
}
}
}
if/else if /else语句的案例1:根据分数获取奖品
package net.ittimeline.java.core.jdk.foundational.control.ifstatement;
import java.util.Scanner;
/**
* 根据分数获取奖品
*
* @author liuguanglei 18601767221@163.com
* @version 2020/11/10 10:51 上午
* @since JDK11
*/
public class IfElseIfStatementExample1 {
public static void main(String[] args) {
System.out.println("请输入你的分数");
Scanner input=new Scanner(System.in);
int score=input.nextInt();
if(score==100){
System.out.println("奖励一辆BMW");
}else if(score>=80&&score<=99){
System.out.println("奖励一台iphone12ProMax");
}else if(score>=60 &&score<80){
System.out.println("奖励一台iPad Pro 2021");
}else{
System.out.println("啥也不是，啥也没有");
}
//另外一种写法
if(score==100){
System.out.println("奖励一辆BMW");
}else if(score>=80){
System.out.println("奖励一台iphone12ProMax");
}
else if(score>=60){
System.out.println("奖励一台iPad Pro 2021");
}else{
System.out.println("啥也不是，啥也没有");
}
}
}
if/else if /else语句的案例2:从键盘输入三个整数，分别使用number1,number2,number3存储，然后排序并按照从小到大输出
package net.ittimeline.java.core.jdk.foundational.control.ifstatement;
import java.util.Scanner;
/**
* 从键盘输入三个整数，分别使用number1,number2,number3存储，然后排序并按照从小到大输出
*
* @author liuguanglei 18601767221@163.com
* @version 2020/11/10 10:59 上午
* @since JDK11
*/
public class IfElseIfStatementExample2 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("请输入第一个数");
int number1 = input.nextInt();
System.out.println("请输入第二个整数");
int number2 = input.nextInt();
System.out.println("请输入第三个整数");
int number3 = input.nextInt();
System.out.printf("你输入的三个整数分别是%d\t%d\t%d\n", number1, number2, number3);
//排序算法
/*
三个整数排序一共会有6种结果
number1<=number2<=number3
number1<=number3<=number2
number2<=number1<=number3
number2<=number3<=number1
number3<=number1<=number2
number3<=number2<=number1
*/
if(number1<=number2&&number2<=number3){
System.out.printf("排序的结果%d<%d<%d\n", number1, number2, number3);
}else if(number1<=number3&&number3<number2){
System.out.printf("排序的结果%d<%d<%d\n", number1, number3, number2);
}else if(number2<=number1&&number1<number3){
System.out.printf("排序的结果%d<%d<%d\n", number2, number1, number3);
}else if(number2<=number3&&number3<number1){
System.out.printf("排序的结果%d<%d<%d\n", number2, number3, number1);
}else if(number3<=number1&&number1<number2){
System.out.printf("排序的结果%d<%d<%d\n", number3, number1, number2);
}else if(number3<=number2&&number2<number1){
System.out.printf("排序的结果%d<%d<%d\n", number3, number2, number1);
}
}
}
if/else if /else语句的案例3:模拟相亲场景(读取布尔值)
package net.ittimeline.java.core.jdk.foundational.control.ifstatement;
import java.util.Scanner;
/**
* 模拟相亲场景
* @author liuguanglei 18601767221@163.com
* @version 2020/11/10 11:36 上午
* @since JDK11
*/
public class IfElseIfStatementExample3 {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
System.out.println("请输入身高(单位:厘米)");
int height=input.nextInt();
System.out.println("请输入你的资产(单位:千万)");
double money=input.nextDouble();
System.out.println("请输入是否帅(true/false)");
boolean handSom=input.nextBoolean();
System.out.println("请输入是否帅(帅/不帅)");
String handSomStr=input.next();
//身高大于等于180并且财富大于等于1000万还长得帅
if(height>=180&&money>=1&&handSom){
System.out.println("一定要嫁给你");
}else if(height>=180||money>=1||handSom){
System.out.println("比上不足比下有余，嫁吧");
}else{
System.out.println(" 不嫁屌丝男");
}
}
}
if/else if /else语句的案例4:模拟相亲场景(读取字符串)
package net.ittimeline.java.core.jdk.foundational.control.ifstatement;
import java.util.Scanner;
/**
* 模拟相亲场景
* @author liuguanglei 18601767221@163.com
* @version 2020/11/10 11:36 上午
* @since JDK11
*/
public class IfElseIfStatementExample4 {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
System.out.println("请输入身高(单位:厘米)");
int height=input.nextInt();
System.out.println("请输入你的资产(单位:千万)");
double money=input.nextDouble();
System.out.println("请输入是否帅(帅/丑)");
String handSomStr=input.next();
//身高大于等于180并且财富大于等于1000万还长得帅
if(height>=180&&money>=1&& handSomStr.equals("帅")){
System.out.println("一定要嫁给你");
}else if(height>=180||money>=1||handSomStr.equals("帅")){
System.out.println("比上不足比下有余，嫁吧");
}else{
System.out.println(" 不嫁屌丝男");
}
}
}
if/else if /else语句的案例5:模拟相亲场景(读取字符)
package net.ittimeline.java.core.jdk.foundational.control.ifstatement;
import java.util.Scanner;
/**
* 模拟相亲场景
*
* @author liuguanglei 18601767221@163.com
* @version 2020/11/10 11:36 上午
* @since JDK11
*/
public class IfElseIfStatementExample5 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("请输入身高(单位:厘米)");
int height = input.nextInt();
System.out.println("请输入你的资产(单位:千万)");
double money = input.nextDouble();
System.out.println("请输入是否帅(帅/丑)");
char handSomChar = input.next().charAt(0);
//身高大于等于180并且财富大于等于1000万还长得帅
if (height >= 180 && money >= 1 && handSomChar == '帅') {
System.out.println("一定要嫁给你");
} else if (height >= 180 || money >= 1 || handSomChar == '帅') {
System.out.println("比上不足比下有余，嫁吧");
} else {
System.out.println(" 不嫁屌丝男");
}
}
}
理解随机数方法Math.random()的使用
package net.ittimeline.java.core.jdk.foundational.control.ifstatement;
/**
* 随机数使用
*
* @author liuguanglei 18601767221@163.com
* @version 2020/11/10 11:55 上午
* @since JDK11
*/
public class RandomTest {
public static void main(String[] args) {
// Math.random()产生[0-1)之间的小数
System.out.println( Math.random());
//如何产生[1-10]之间的随机整数
// Math.random()*10 产生的随机数是[0,10)之间的小数
int number=(int)(Math.random()*10+1);
System.out.println(number);
}
}
if/else if /else语句的案例6:模拟彩票抽奖
package net.ittimeline.java.core.jdk.foundational.control.ifstatement;
import java.util.Scanner;
/**
* 彩票程序
* 假设开发一个彩票程序
* 程序随机的产生一个两位数[10-99]的彩票，提示用户输入一个两位数
* 然后按照下面的规则判断用户是否能赢
* 如果用户输入的数字匹配彩票的实际顺序，奖励100000美元 即完全相等
* 如果用户输入的数字匹配彩票的所有数字，但是顺序不一致，奖励30000美元 15 51
* 如果用户输入的数字且满足顺序的情况下匹配一个数字，奖励10000美元 15 16 11 17
* 如果用户输入的数字不满足顺序的情况下匹配一个数字，奖励5000美元15 52 61
* 如果用户输入的数字没有任何匹配任何一个数字，则彩票作废15 23
*
* @author liuguanglei 18601767221@163.com
* @version 2020/11/10 12:06 下午
* @since JDK11
*/
public class IfElseIfStatementLotteryExample6 {
public static void main(String[] args) {
//首先产生一个[10-99]之间的随机整数
int randomNumber = (int) (Math.random() * 90 + 10);
System.out.println("randomNumber = " + randomNumber);
//然后创建Scanner对象，读取用户输入的两位数赋值给inputNumber
Scanner input = new Scanner(System.in);
System.out.println("请输入 两位数的彩票号码");
int inputNumber = input.nextInt();
System.out.printf("用户输入的彩票号码是%d\t随机生成彩票号码是%d",inputNumber,randomNumber);
// 分别求出随机数和用户输入的两位数的十位和个位
int randomNumberDecade=randomNumber/10;
int randomNumberUnit=randomNumber%10;
int inputNumberDecade=inputNumber/10;
int inputNumberUnit=inputNumber%10;
//使用if/else 判断中奖条件
if(inputNumber==randomNumber){
System.out.println("奖励100000美元");
}else if(randomNumberDecade==inputNumberUnit&&randomNumberUnit==inputNumberDecade){
System.out.println("奖励30000美元");
}else if(randomNumberDecade==inputNumberDecade||randomNumberUnit==inputNumberUnit){
System.out.println("奖励10000美元");
}else if(randomNumberDecade==inputNumberUnit||randomNumberUnit==inputNumberDecade){
System.out.println("奖励5000美元");
}else{
System.out.println("彩票作废");
}
}
}
嵌套if/else语句
在进行复杂业务开发时，还会使用到嵌套的if/else
- 嵌套if/else语句的语法结构
if(表达式1){
if(表达式2){
代码块1
}else{
代码块2
}
}else{
if(表达式3){
代码块3
}else{
代码块4
}
}- 嵌套if/else的执行流程
嵌套if/else时，当表达式1的结果为true,才会执行表达式2，如果表达式2的结果为true,会执行代码块1，否则会执行代码块2
当表达式1的结果为false,会执行表达式3，表达式3的结果为true，会执行代码块3，否则会执行代码块4
理解嵌套if/else的执行流程
package net.ittimeline.java.core.jdk.foundational.control.ifstatement;
import java.util.Scanner;
/**
* 分支结构之条件判断
* if/else 语句嵌套条件判断
*
* if(表达式1){
* if(表达式2){
* 代码块1
* }else{
* 代码块2
* }
* }else{
* if(表达式3){
* 代码块3
* }else{
* 代码块4
* }
*
* }
* 执行流程
* 嵌套if/else时，当表达式1的结果为true,才会执行表达式2，如果表达式2的结果为true,会执行代码块1，否则会执行代码块2
* 当表达式1的结果为false,会执行表达式3，表达式3的结果为true，会执行代码块3，否则会执行代码块4
*
*
*
* @author liuguanglei 18601767221@163.com
* @version 2020/11/10 11:45 上午
* @since JDK11
*/
public class IfElseStatementNestTest {
public static void main(String[] args) {
System.out.println("请输入你的分数");
Scanner input=new Scanner(System.in);
int score=input.nextInt();
//分数合法时
if(score>=0&&score<=100){
//才会去判断
if(score==100){
System.out.println("奖励一辆BMW");
}else if(score>=80&&score<=99){
System.out.println("奖励一台iphone12ProMax");
}else if(score>=60 &&score<80){
System.out.println("奖励一台iPad Pro 2021");
}else{
System.out.println("啥也不是，啥也没有");
}
}else{
System.out.println("你输入的分数有误，分数的范围是[0,100]");
}
}
}
选择结构switch/case
switch语句由一个表达式和多个case语句以及default语句组成，switch语句中表达式的数据类型只能是byte,short,char和int以及枚举(enum)类型，不能是boolean类型，否则会编译出错，同时在JDK7以后switch语句的表达式支持String类型。case之后只能声明常量值，不能使用变量或者表达式。
- switch/case语句的语法结构
switch(表达式){
case 常量值1:
语句块1
[break]
case 常量值2:
语句块2
default:
语句块3
break
}-
switch/case语句的执行流程
当表达式运算的结果和某个case语句的常量值相等时，就会从对应的case语句依次往下顺序执行，
直到执行完所有的case语句或者中途遇到break或return时结束switch case语句，break关键字表示跳出switch语句，根据实际业务场景是可选的。通常情况下switch case语句都会有default语句，即表达式运算的结果和所有的case语句的常量值不相等时会执行default的语句块3，
而default语句类似于if/else的else语句，也是可选的，位置也是灵活的，但是通常放到最后一个case语句下面。
如果default语句放在第一个case语句的前面，那么也会依次往下顺序执行所有的case，直到遇到break或者是return关键字 -
switch/case语句的注意事项
case 后面只能跟固定的常量值，不能是变量或者表达式
case 的常量值不能重复
switch的表达式必须是byte,short,char,int类型，JDK1.5支持枚举，JDK7以后增加了String
理解switch/case语句的执行流程
package net.ittimeline.java.core.jdk.foundational.control.switchcasestatement;
import java.util.Scanner;
/**
* 分支结构之选择结构switch case
*
* 语法结构
* switch(表达式){
* case 常量值1:
* 语句块1
* [break]
* case 常量值2:
* 语句块2
* ...
* default:
* 语句块3
* break
* }
*
* 执行流程
* 当表达式运算的结果和某个case语句的常量值相等时，就会从对应的case语句依次往下顺序执行，
* 直到执行完所有的case语句或者中途遇到break或return时结束switch case语句，break关键字表示跳出switch语句，根据实际业务场景是可选的。
* 通常情况下switch case语句都会有default语句，即表达式运算的结果和所有的case语句的常量值不相等时会执行default的语句块3，
* 而default语句类似于if/else的else语句，也是可选的，位置也是灵活的，但是通常放到最后一个case语句下面。
* 如果default语句放在第一个case语句的前面，那么也会依次往下顺序执行所有的case，直到遇到break或者是return关键字
*
* 使用注意事项
* case 后面只能跟固定的常量值，不能是变量或者表达式
* case 的常量值不能重复
* switch的表达式必须是byte,short,char,int类型，JDK1.5支持枚举，JDK7以后增加了String
*
*
* @author liuguanglei 18601767221@163.com
* @version 2020/11/10 1:50 下午
* @since JDK11
*/
public class SwitchCaseStatementTest {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
System.out.println("请输入星期对应的数字(1-7)");
int weekday=input.nextInt();
switch (weekday){
case 1:
System.out.println("Monday");
break;
case 2:
System.out.println("Tuesday");
break;
case 3:
System.out.println("Wednesday");
break;
case 4:
System.out.println("Thursday");
break;
case 5:
System.out.println("Friday");
break;
case 6:
System.out.println("Saturday");
break;
case 7:
System.out.println("Sunday");
break;
}
}
}
switch/case语句案例1:使用switch case语句实现将数字转换为大写，其他都输入other
package net.ittimeline.java.core.jdk.foundational.control.switchcasestatement;
import java.util.Scanner;
/**
* 使用switch case语句实现将数字转换为大写，其他都输入other
*
* @author liuguanglei 18601767221@163.com
* @version 2020/11/10 2:10 下午
* @since JDK11
*/
public class SwitchCaseStatementExample1 {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
System.out.println("请输入一个[1-9]数字");
int number=input.nextInt();
switch (number){
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;
case 7:
System.out.println("柒");
break;
case 8:
System.out.println("捌");
break;
case 9:
System.out.println("玖");
break;
default:
System.out.println("other");
break;
}
}
}
switch case语句案例2:使用switch case语句实现根据用户输入的数字来判断季节
package net.ittimeline.java.core.jdk.foundational.control.switchcasestatement;
import java.util.Scanner;
/**
* 使用switch case语句实现根据用户输入的数字来判断季节
* 3,4,5 表示春季
* 6,7,8 表示夏季
* 9,10,11 表示秋季
* 12,1,2 表示冬季
*
* @author liuguanglei 18601767221@163.com
* @version 2020/11/10 2:10 下午
* @since JDK11
*/
public class SwitchCaseStatementExample2 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("请输入一个[1-12]月份");
int month = input.nextInt();
switch (month) {
case 3:
case 4:
case 5:
System.out.println("春季");
break;
case 6:
case 7:
case 8:
System.out.println("夏季");
break;
case 9:
case 10:
case 11:
System.out.println("秋季");
break;
case 12:
case 1:
case 2:
System.out.println("冬季");
break;
default:
System.out.println("你输入的数字非法");
break;
}
}
}
switch/case语句案例3: 使用switch case语句实现 从键盘分别输入年、月、日，判断这一天是当年的第几天
package net.ittimeline.java.core.jdk.foundational.control.switchcasestatement;
import java.util.Scanner;
/**
* 使用switch case语句实现 从键盘分别输入年、月、日，判断这一天是当年的第几天
* 判断一年是否是闰年的标准:① 可以被4整除，不能被100整除，可以被400整除
*
* @author liuguanglei 18601767221@163.com
* @version 2020/11/10 2:10 下午
* @since JDK11
*/
public class SwitchCaseStatementExample3 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("请输入一个年份");
int year = input.nextInt();
System.out.println("请输入一个[1-12]的月份");
int month = input.nextInt();
System.out.println("请输入一个[1-31]的天数");
int day = input.nextInt();
//计算这一天是当年的多少天
//月份加上天数即可算出这一天是当年的多少天
//但是2月份要特殊处理，因为还要考虑闰年的情况
//总天数
int dayOfYear = 0;
//二月份的天数
int februaryDay = 0;
//计算二月份的天数
if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
februaryDay = 29;
} else {
februaryDay = 28;
}
//将一月份的天数赋值给dayOfYear变量
dayOfYear = day;
switch (month) {
case 12:
//累加1-11月份
dayOfYear += 31;
case 11:
//累加1-10月份
dayOfYear += 30;
case 10:
//累加1-9月份
dayOfYear += 30;
case 9:
dayOfYear += 31;
case 8:
dayOfYear += 31;
case 7:
dayOfYear += 30;
case 6:
dayOfYear += 31;
case 5:
dayOfYear += 30;
case 4:
dayOfYear += 31;
case 3:
dayOfYear += februaryDay;
case 2:
dayOfYear += day;
}
System.out.printf("%d年%d月%d日是一年的第%d天\n", year, month, day, dayOfYear);
}
}
switch/case语句案例4: 猜数字游戏
package net.ittimeline.java.core.jdk.foundational.control.switchcasestatement;
import java.util.Scanner;
/**
* 猜数字游戏
* 随机产生三个1-6之前的整数
* 如果三个数相等称为豹子
* 如果三个数之和大于9，称为大
* 如果三个数之和小于等于9称为小
* 用户从键盘输入豹子、大、小，并判断是猜对了
*
* @author liuguanglei 18601767221@163.com
* @version 2020/11/10 2:10 下午
* @since JDK11
*/
public class SwitchCaseStatementExample4 {
public static void main(String[] args) {
System.out.println("请输入豹子或者大、小");
Scanner input = new Scanner(System.in);
String answer = input.next();
// 产生3个1-6之间的随机数
int randNumber1 = (int) (Math.random() * 6 + 1);
int randNumber2 = (int) (Math.random() * 6 + 1);
int randNumber3 = (int) (Math.random() * 6 + 1);
System.out.printf("随机生成的三个整数分别是%d,%d,%d\n", randNumber1, randNumber2, randNumber3);
int sum = randNumber1 + randNumber2 + randNumber3;
System.out.println("三个随机整数的和是" + sum);
if ((randNumber1 == randNumber2 && randNumber2 == randNumber3) && "豹子".equals(answer)) {
System.out.println("你猜对了，豹子!");
} else if (sum > 9 && "大".equals(answer)) {
System.out.println("你猜对了，大!");
} else if (sum <= 9 && "小".equals(answer)) {
System.out.println("你猜对了，小!");
} else {
System.out.println("你猜错了...");
}
}
}
switch/case语句案例5:判断字符是元音还是辅音
package net.ittimeline.java.core.jdk.foundational.control.switchcasestatement;
import java.util.Random;
/**
* 判断字符是元音还是辅音
* @author liuguanglei 18601767221@163.com
* @version 2020/11/10 4:14 下午
* @since JDK11
*/
public class SwitchCaseStatementVowelsAndConsonantsExample5 {
public static void main(String[] args) {
Random random=new Random(88);
for (int i=0;i<100;i++){
//产生97-122之间的随机数
int c=random.nextInt(26)+'a';
//打印 字符对应的数字以及是元音还是辅音
System.out.println((char)c+", "+c);
switch (c){
//元音
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
System.out.println(",vowel");
break;
case 'y':
case 'w':
//有时候是元音
System.out.println(",Sometimes a vowel");
break;
//默认是辅音
default:
System.out.println(",consonant");
}
System.out.println();
}
}
}
在JDK7以前，switch/case语句的条件表达式的类型只能支持byte,short,int,char和enum，而String是日常开发中最常用的数据类型，在JDK7后switch/case终于支持String。
package net.ittimeline.java.core.jdk.foundational.control.switchcasestatement;
import java.util.Scanner;
/**
* 字符串在switch case语句中的使用
* @author liuguanglei 18601767221@163.com
* @version 2020/11/10 4:23 下午
* @since JDK11
*/
public class SwitchStringTest {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String description;
System.out.println("请输入你的性别");
String gender = input.next();
/**
* 根据输入的性别生成招呼用语
*/
switch (gender) {
case "男":
description = "你好,先生";
break;
case "女":
description = "你好,女士";
break;
default:
description="你好";
break;
}
System.out.println(description);
}
}
但是由于switch/case语句的case 值是不能重复的，在使用String时尤其要注意。因为在Java中字符串可以使用Unicode字符来替换，也可能造成case值重复。
package net.ittimeline.java.core.jdk.foundational.control.switchcasestatement;
import java.util.Scanner;
/**
* switch case值重复
*
* @author liuguanglei 18601767221@163.com
* @version 2020/11/10 4:25 下午
* @since JDK11
*/
public class SwitchStringDuplicateTest {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String description;
System.out.println("请输入你的性别");
String gender = input.next();
/**
* 根据输入的性别生成招呼用语
*/
switch (gender) {
case "男":
//字符串男对应的unicode编码就是\u7537
// case "\u7537":
description = "你好,先生";
break;
case "女":
description = "你好,女士";
break;
default:
description = "你好";
break;
}
System.out.println(description);
}
}
switch case语句案例5: 使用switch/case实现基于字符和字符串的小写字母转大写字母
package net.ittimeline.java.core.jdk.foundational.control.switchcasestatement;
import java.util.Scanner;
/**
* 使用switch/case实现基于字符和字符串的小写字母转大写字母
* @author liuguanglei 18601767221@163.com
* @version 2020/11/10 4:27 下午
* @since JDK11
*/
public class SwitchCaseStatementLowerUpperExample6 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("请输入需要转换的小写字母:");
String lowercase = input.next();
String uppercase = "";
switch (lowercase) {
case "a":
case "b":
case "c":
case "d":
case "e":
case "f":
case "g":
case "h":
case "i":
case "j":
case "k":
case "l":
case "m":
case "n":
case "o":
case "p":
case "q":
case "r":
case "s":
case "t":
case "u":
case "v":
case "w":
case "x":
case "y":
case "z":
//直接使用String类封装的toUpperCase方法实现小写字母转大写字母
uppercase = lowercase.toUpperCase();
break;
}
//输出转换结果 这里的%s表示字符串
System.out.printf("基于字符串小写字母%s转换为大写字母的结果是%s\n", lowercase, uppercase);
//获取输入字符串中的第一个字符
Character ch = lowercase.charAt(0);
switch (ch) {
case 'a':
case 'b':
case 'c':
case 'd':
case 'e':
case 'f':
case 'g':
case 'h':
case 'i':
case 'j':
case 'k':
case 'l':
case 'm':
case 'n':
case 'o':
case 'p':
case 'q':
case 'r':
case 's':
case 't':
case 'u':
case 'v':
case 'w':
case 'x':
case 'y':
case 'z':
//小写字母的编码减去32就是大写字母的编码
int upperCaseNumber = (int) ch - 0x20;
//将数字转换为对应的字符
Character uppperCase = Character.valueOf((char) upperCaseNumber);
//输出转换结果，这里的%c表示字符
System.out.printf("基于字符 小写字母%c转换为大写字母的结果是%c\n", ch, uppperCase);
break;
}
}
}
switch/case和if/else语句的比较
凡是可以使用switch/case的结构，都可以使用if/else转换。反之不成立
选择结构中，即可以使用switch/case，又可以使用if/else时，优先使用switch case，因为switch/case执行效率稍高
switch case适合做等值判断，if/else适合做区间判断。
package net.ittimeline.java.core.jdk.foundational.control.switchcasestatement;
import java.util.Scanner;
/**
* switch/case和if/else语句的比较
* @author liuguanglei 18601767221@163.com
* @version 2020/11/10 4:29 下午
* @since JDK11
*/
public class SwitchCaseStatementCompareIfElseTest {
public static void main(String[] args) {
Scanner input= new Scanner(System.in);
System.out.println("请输入你的分数");
int score=input.nextInt();
String ifElseGrade=getGradeByScoreIfElse(score);
System.out.printf("if else结构实现 分数%d对应的等级是%s\n",score,ifElseGrade);
String switchCaseGrade=getGradeByScoreSwitchCase(score);
System.out.printf("switch case结构实现 分数%d对应的等级是%s\n",score,switchCaseGrade);
}
/**
* 使用if/else实现根据用户输入的分数获取等级
* @param score
* @return
*/
public static String getGradeByScoreIfElse(int score){
String grade="";
if(score>90){
grade="A";
}
else if(score>=70&&score<80){
grade="B";
}
else if(score>=60&&score<70){
grade="C";
}
else if((score<60)){
grade="D";
}
return grade;
}
/**
* 使用if/else实现根据用户输入的分数获取等级
* @param score
* @return
*/
public static String getGradeByScoreSwitchCase(int score){
String grade="";
int value=score/10;
switch (value){
case 9:
grade="A";
break;
case 8:
case 7:
grade="B";
break;
case 6:
grade="C";
break;
case 5:
case 4:
case 3:
case 2:
case 1:
grade="D";
break;
}
return grade;
}
}
循环结构
while循环
每个循环结构都有如下四个要素
1.初始化循环条件
2.判断循环条件 必须是boolean类型
3.循环体
4.迭代条件
而循环结构的执行流程是
1.初始化循环条件
2.判断循环条件
3.循环体
4.迭代条件
2.判断循环条件
3.循环体
4.迭代条件
2.判断循环条件
3.循环体
4.迭代条件
...
- while循环语句的语法结构
while(循环条件){
循环体
}- while循环语句的执行流程
当循环条件判断的结果为true,则会循环执行循环体的代码块，然后再判断循环条件，如果循环条件判断结果为true，则会再次循环执行循环体的代码块，直到遇到了break关键字或者是循环条件判断的结果为false才会中断循环。
while循环语句的的执行流程
在觉大多数场景下while循环和for循环是可以相互替换的，只不过它们各自有着不同的使用场景，其中while循环通常用于明确循环条件的前提，而循环次数不确定时。for循环用于明确循环次数，但是不明确循环条件时。
package net.ittimeline.java.core.jdk.foundational.control.whilestatement;
/**
* while循环
*
* 语法格式
* while(①循环条件表达式){
* ②循环体
* }
* 执行流程
* 先判断①循环条件表达式如果循环条件表达式结果为true,则执行循环体的语句
* 然后再判断①循环条件表达式，如果循环条件表达式结果为false,则会退出循环
*
* 仔细分析 while循环依然有四个要素
* 1.循环变量的初始化 例如int i=1;
* 2. 循环条件表达式判断 例如 i<100
* 3. 循环体语句 例如sum+=i;
* 4. 循环变量迭代表达式 例如 i++
*
*
* 使用for循环和while循环都实现了1-100之间的和证明了for循环和while循环是可以相互替换的，不过绝大多数场景都会使用for循环
*
* for循环的场景是明确循环次数，例如遍历数组等等
* while循环的场景是明确循环循环条件，而次数不太明确的应用场景
*
*
* @author liuguanglei 18601767221@163.com
* @version 2020/11/10 5:15 下午
* @since JDK11
*/
public class WhileStatementTest {
public static void main(String[] args) {
int sum=0;
int i=1;
while(i<=100){
sum+=i;
//如果没有i++ while循环会变成死循环 作用等价于for循环的循环变量迭代表达式
i++;
}
System.out.printf("1-100的和是%d\n",sum);
}
}
理解while循环的执行流程
package net.ittimeline.java.core.jdk.foundational.control.whilestatement;
/**
* 理解While循环的执行流程
* @author liuguanglei 18601767221@163.com
* @version 2020/11/11 9:30 上午
* @since JDK11
*/
public class WhileStatementCompareRandom {
/**
* 定义condition方法作为while循环的条件
* @return Math.random()是否小于0.99
*/
static boolean condition(){
boolean result=Math.random()<0.99;
System.out.println("result = "+result);
return result;
}
public static void main(String[] args) {
while (condition()){
System.out.println("Inside while");
}
System.out.println("outside while");
}
}
while循环语句案例1:使用while循环计算1-100以内的偶数和
借助该程序理解循环的四要素
在写while循环时特别容易忘记写迭代条件，如果while循环没有迭代条件，则会变成死循环，
在程序开发中应该尽量避免出现死循环。
package net.ittimeline.java.core.jdk.foundational.control.whilestatement;
/**
* 计算1-100以内的偶数
* @author liuguanglei 18601767221@163.com
* @version 2020/11/11 9:33 上午
* @since JDK11
*/
public class WhileStatementEvenNumberExample1 {
public static void main(String[] args) {
/**
* 循环四要素
*
* 1.初始化条件
* 2.循环条件 必须是boolean类型
* 3.循环体
* 4.迭代条件
*/
int sum=0;
//1.循环的初始条件
int i=1;
//2.循环条件
while (i<=100){
//3.循环体
if(i%2==0){
sum+=i;
}
//4.循环的迭代条件
i++;
}
System.out.println("1-100以内的偶数和是"+sum);
}
}
while循环和for循环可以相互替换,使用for循环实现1-100以内的偶数和
package net.ittimeline.java.core.jdk.foundational.control.forstatement;
/**
* 打印1-100之间的偶数
*
* @author liuguanglei 18601767221@163.com
* @version 2020/11/10 4:55 下午
* @since JDK11
*/
public class ForStatementEvenNumberExample2 {
public static void main(String[] args) {
//循环变量i的变化是1-100
for (int i = 1; i <= 100; i++) {
if(i%2==0){
System.out.print(i+",");
}
}
//换行
System.out.println();
System.out.println("楚河*********汉界*********");
//另外一种方法
for (int i = 2; i <=100 ; i+=2) {
System.out.print(i+",");
}
}
}
while循环语句案例2:猜数字游戏
package net.ittimeline.java.core.jdk.foundational.control.whilestatement;
import java.util.Scanner;
/**
* 猜数字游戏
* 随机生成1-100以内的整数
* 然后用户从键盘输入整数，如果大了提示大了，如果小了，提示小了，如果对了，就不再猜了，并统计猜了多少次
* @author liuguanglei 18601767221@163.com
* @version 2020/11/10 6:12 下午
* @since JDK11
*/
public class WhileStatementGuessNumberExample2 {
public static void main(String[] args) {
//产生一个1-100之间的随机数
int randNumber=(int)(Math.random()*90+10);
System.out.println("生成的随机数是"+randNumber);
Scanner input =new Scanner(System.in);
int inputNumber=0;
int count=0;
while(randNumber!=inputNumber){
System.out.println("请输入一个数字");
inputNumber=input.nextInt();
count++;
if(inputNumber>randNumber){
System.out.println("大了");
}else if(inputNumber<randNumber) {
System.out.println("小了");
}
}
System.out.printf("一共猜了%d次",count);
}
}
while循环语句3:输出所有的水仙花数
package net.ittimeline.java.core.jdk.foundational.control.whilestatement;
/**
*
* 输出所有的水仙花数
* 水仙花数是指的一个3位数，其各个位上数字立方和等于本身:例如153=1*1*1+5*5*5+3*3*3
* @author liuguanglei 18601767221@163.com
* @version 2020/11/10 5:28 下午
* @since JDK11
*/
public class WhileStatementNarcissisticNumberExample3 {
public static void main(String[] args) {
//水仙花数是一个三位数 因此循环的区间是[100-999]
int i=100;
while(i<=999){
int hundred=i/100;
int decade=i/10%10;
int unit=i%10;
if(hundred*hundred*hundred+decade*decade*decade+unit*unit*unit==i){
System.out.printf("%d是一个水仙花数\n",i);
}
i++;
}
}
}
do/while循环
- do/while循环语句的语法结构
do{
①循环体
}while(②循环条件表达式);- do/while循环的执行流程
首先执行循环体的代码块，然后判断循环条件表达式，如果循环条件表达式的结果为true,则会再次循环执行循环体的代码块，如果循环条件表达式的结果为false或者遇到了break关键字则会退出循环。
do/while循环在日常开发中几乎不怎么用，它和while循环的区别就是至少执行一次循环体的内容
使用do/while循环统计用户输入的正整数和负整数的个数
package net.ittimeline.java.core.jdk.foundational.control.dowhilestatement;
import java.util.Scanner;
/**
* do/while循环
* 语法结构
*
* do{
* ①循环体
* }while(②循环条件表达式);
*
* 执行过程
* 首先执行循环体
* 然后执行循环条件表达式，循环条件表达式结果为true时再次执行循环体，直到循环条件表达式的结果为false时结束循环
*
* do/while循环和while循环、for循环时的区别是do/while循环至少会执行一次循环体
*
* @author liuguanglei 18601767221@163.com
* @version 2020/11/10 5:51 下午
* @since JDK11
*/
public class DoWhileStatementTest {
public static void main(String[] args) {
//从键盘输入整数，输入0结束，统计输入的正数以及负数的个数
int positiveCount = 0;
int negativeCount = 0;
Scanner input = new Scanner(System.in);
int inputNumber = 0;
do {
System.out.println("请输入整数，0表示结束");
inputNumber = input.nextInt();
if (inputNumber > 0) {
positiveCount++;
} else if (inputNumber < 0) {
negativeCount++;
}
} while (inputNumber != 0);
System.out.printf("do/while循环 你输入正整数的个数是%d,你输入负整数的个数是%d\n", positiveCount, negativeCount);
}
}
do/while循环和while循环的对比
package net.ittimeline.java.core.jdk.foundational.control.dowhilestatement;
/**
* do/while和while循环的比较
*
* @author liuguanglei 18601767221@163.com
* @version 2020/11/11 9:36 上午
* @since JDK11
*/
public class DoWhileStatementCompareWhileStatementTest {
/**
* 测试while循环
* @param number
*/
public static void testWhile(int number){
while (number<10){
System.out.println(" while循环 number = "+number++);
}
}
public static void testDoWhile(int number){
do{
System.out.println(" do while循环 number = "+number++);
}while (number<10);
}
public static void main(String[] args) {
/**
* 当while循环和do/while循环都满足循环条件时，while循环和do/while循环是等价的
*/
int number=1;
testWhile(number);
testDoWhile(number);
/**
* 当while循环的循环条件不满足时,do...while循环会比while循环多执行一次
*/
number=10;
testWhile(number);
System.out.println();
testDoWhile(number);
}
}
do/while循环语句案例1:猜数字游戏
package net.ittimeline.java.core.jdk.foundational.control.dowhilestatement;
import java.util.Scanner;
/**
* 猜数字游戏
* 随机生成1-100以内的整数
* 然后用户从键盘输入整数，如果大了提示大了，如果小了，提示小了，如果对了，就不再猜了，并统计猜了多少次
*
* @author liuguanglei 18601767221@163.com
* @version 2020/11/10 6:12 下午
* @since JDK11
*/
public class DoWhileStatementGuessNumberExample1 {
public static void main(String[] args) {
//产生一个1-100之间的随机数
int randNumber = (int) (Math.random() * 90 + 10);
System.out.println("生成的随机数是" + randNumber);
Scanner input = new Scanner(System.in);
int inputNumber = 0;
int count=0;
do {
System.out.println("请输入一个数字");
inputNumber = input.nextInt();
count++;
if (inputNumber > randNumber) {
System.out.println("大了");
} else if (inputNumber < randNumber) {
System.out.println("小了");
}
} while (randNumber != inputNumber);
System.out.printf("一共猜了%d次",count);
}
}
for循环
for循环是日常开发程序中使用最多的循环结构，与while循环的不同之处在于for循环的循环初始条件(变量)只能在for循环内使用，而while循环的循环初始条件(变量)可以在whiel循环外部使用。for循环的循环结构也是由之前提到的循环结构四要素组成，执行顺序也和while一样
for循环语句语法结构1
其中初始化循环变量，循环条件判断和循环变量迭代表达式都是可选的，此时for(;;){} 就是for循环的死循环写法
for(;;){
循环体
}for循环的语法结构2
for(①循环变量初始化表达式;②循环条件表达式;④循环变量迭代表达式){
③循环体
}-
for循环语法结构2的执行过程
1.执行①循环变量初始化表达式
2. 执行②循环条件表达式
3. 如果②循环条件表达式结果为true 执行③循环体，如果②循环条件表达式结果为false结束整个for循环
4. 然后再执行④循环变量迭代表达式
5. 然后再循环执行②③④ 直到②循环条件表达式的结果为false时退出循环,或者是遇到了break关键字也会退出循环 -
for循环的执行流程
package net.ittimeline.java.core.jdk.foundational.control.forstatement;
/**
* for循环
* for循环的应用场景是需要重复执行的代码块可以放到for循环的循环体中
* 语法结构形式一
* for(;;){
* 循环体
* }
* for循环中的两个;是必不可少的,for(;;){} 是for循环的死循环写法
*
* 语法结构形式二
*
* for(①循环变量初始化表达式;②循环条件表达式;④循环变量迭代表达式){
* ③循环体
* }
*
* 语法结构形式二的执行过程
* 1.执行①循环变量初始化表达式
* 2. 执行②循环条件表达式
* 3. 如果②循环条件表达式结果为true 执行③循环体，如果②循环条件表达式结果为false结束整个for循环
* 4. 然后再执行④循环变量迭代表达式
* 5. 然后再循环执行②③④ 直到②循环条件表达式的结果为false时退出循环,或者是遇到了break关键字也会退出循环
*
*
*
*
*
*
*
* @author liuguanglei 18601767221@163.com
* @version 2020/11/10 4:41 下午
* @since JDK11
*/
public class ForStatementTest {
public static void main(String[] args) {
/*
//for循环的死循环
for (;;){
System.out.println("循环执行ing");
}
*/
/*
循环的执行流程
① int i=1;
② i<=3;
③ System.out.println("跟光磊学Java应用开发与架构设计");
④ i++
② i<=3;
③ System.out.println("跟光磊学Java应用开发与架构设计");
④ i++
② i<=3;
③ System.out.println("跟光磊学Java应用开发与架构设计");
④ i++
② i<=3; 不成立 结束循环
*/
for (int i = 1; i <=3 ; i++) {
System.out.println("跟光磊学Java应用开发与架构设计");
}
System.out.println("*******楚河*******汉界");
for (int i = 0; i <5 ; i+=2) {
System.out.println("跟光磊学Java应用开发与架构设计");
}
}
}
for循环语句案例1:求1-100的和
package net.ittimeline.java.core.jdk.foundational.control.forstatement;
/**
* 求1-100的和
*
* @author liuguanglei 18601767221@163.com
* @version 2020/11/10 4:55 下午
* @since JDK11
*/
public class ForStatementSumExample1 {
public static void main(String[] args) {
//定义变量保存累加和的结果
int sum = 0;
for (int i = 1; i <= 100; i++) {
//把每个i的值累加到sum中
sum += i;
}
//循环结束后打印输出累加的结果
System.out.printf("1-100的和是%d\n",sum);
}
}
for循环语句案例2:打印1-100之间的偶数
package net.ittimeline.java.core.jdk.foundational.control.forstatement;
/**
* 打印1-100之间的偶数
*
* @author liuguanglei 18601767221@163.com
* @version 2020/11/10 4:55 下午
* @since JDK11
*/
public class ForStatementEvenNumberExample2 {
public static void main(String[] args) {
//循环变量i的变化是1-100
for (int i = 1; i <= 100; i++) {
if(i%2==0){
System.out.print(i+",");
}
}
//换行
System.out.println();
System.out.println("楚河*********汉界*********");
//另外一种方法
for (int i = 2; i <=100 ; i+=2) {
System.out.print(i+",");
}
}
}
for循环语句案例3:输出所有的水仙花数
package net.ittimeline.java.core.jdk.foundational.control.forstatement;
/**
*
* 输出所有的水仙花数
* 水仙花数是指的一个3位数，其各个位上数字立方和等于本身:例如153=1*1*1+5*5*5+3*3*3
* @author liuguanglei 18601767221@163.com
* @version 2020/11/10 5:28 下午
* @since JDK11
*/
public class ForStatementNarcissisticNumberExample3 {
public static void main(String[] args) {
//水仙花数是一个三位数 因此循环的区间是[100-999]
for (int i = 100; i <=999 ; i++) {
//首先用取模运算获取三位数的百位，十位和个位
int hundred=i/100;
int decade=i/10%10;
int unit=i%10;
if(hundred*hundred*hundred+decade*decade*decade+unit*unit*unit==i){
System.out.printf("%d是一个水仙花数\n",i);
}
}
}
}
for循环语句案例4:打印指定的字符信息
package net.ittimeline.java.core.jdk.foundational.control.forstatement;
/**
* 从1循环到150 并每行打印一个值
* 另外在每个3的补上打印出foo
* 在每个5的倍数上打印出biz
* 在每个7的倍数上打印baz
* @author liuguanglei 18601767221@163.com
* @version 2020/11/10 5:41 下午
* @since JDK11
*/
public class ForStatementFooBizBazExample4 {
public static void main(String[] args) {
for (int i = 1; i <150 ; i++) {
System.out.print(i);
if(i%3==0){
System.out.print("foo");
}
if(i%5==0){
System.out.print("biz");
}
if(i%7==0){
System.out.print("baz");
}
System.out.println();
}
}
}
for循环语句案例5：打印1-100之间的数，其中3，5，7的倍数不打印
package net.ittimeline.java.core.jdk.foundational.control.forstatement;
/**
* 打印1-100之间的数，其中3，5，7的倍数不打印
*
* @author liuguanglei 18601767221@163.com
* @version 2020/11/10 6:39 下午
* @since JDK11
*/
public class ForStatementNumberExample5 {
public static void main(String[] args) {
//方法1
for (int i = 1; i <=100 ; i++) {
if(i%3!=0&&i%5!=0&&i%7!=0){
System.out.print(i+" ");
}
}
System.out.println();
System.out.println("楚河************汉界");
//方法2 使用continue
for (int i = 1; i <=100 ; i++) {
if(i%3==0||i%5==0||i%7==0){
continue;
}
System.out.print(i+" ");
}
}
}
for循环语句案例6:求用户输入两个整数的最大公约数和最小公倍数
最大公约数:两个数同时能被除尽的最大值
最小公倍数:同时是两个数的倍数的最小值
比如12和20的最大公约数是4，最小公倍数是60
package net.ittimeline.java.core.jdk.foundational.control.forstatement;
import java.util.Scanner;
/**
* 求用户输入两个整数的最大公约数和最小公倍数
*
* @author liuguanglei 18601767221@163.com
* @version 2020/11/10 6:48 下午
* @since JDK11
*/
public class ForStatementGCDLCMExample6 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int number1 = 0;
//首先读取用户输入的两个正整数
//循环部分用于判断是否正整数，如果不是直到用户输入正确为止
while (true) {
System.out.println("请输入第一个正整数number1的值");
number1 = input.nextInt();
if (number1 <= 0) {
System.out.println(number1 + "不是正整数，请重新输入");
} else {
break;
}
}
int number2 = 0;
while (true) {
System.out.println("请输入第二个正整数number2的值");
number2 = input.nextInt();
if (number2 <= 0) {
System.out.println(number2 + "不是正整数，请重新输入");
} else {
break;
}
}
//求number1和number2的最大公约数和最小公倍数
//公约数:能够把number1和number2都整除的，就是它们的公约数
// 例如 6,9 公约数1,3 9和18 公约数，1，3，9 5和13的公约数 1
//公倍数
// 例如6和9的公倍数 18，36.. 9和18的公倍数 18 5和13的公倍数 65..
//最大公约数
int max=number1>number2?number1:number2;
int min=number1<number2?number1:number2;
int GCD=0;
int LCM=0;
for (int i = min; i >=1 ; i--) {
//看 i是否能够同时把number1和number2整除
if(number1%i==0 && number2%i==0){
GCD=i;
break;
}
}
System.out.printf("%d和%d的最大公约数是%d\n",number1,number2,GCD);
//最小公倍数=number1*number2/最大公约数
LCM=number1*number2/GCD;
System.out.printf("%d和%d的最小公倍数是%d\n",number1,number2,LCM);
for (int i = max; i <number1*number2 ; i++) {
if(i%number1==0 && i%number2==0){
GCD=i;
break;
}
}
System.out.printf("%d和%d的最小公倍数是%d\n",number1,number2,LCM);
}
}
死循环
当某些业务场景不知道循环的次数时，可以使用死循环实现
while循环的死循环语法结构
while(true){
循环体
}for循环的死循环语法结构
for(;;){
//循环体
}for和while死循环应用场景:从键盘读取个数不确定的数，并判断读入的正数和负数的个数，输入0时结束程序
package net.ittimeline.java.core.jdk.foundational.control.endlessloop;
import java.util.Scanner;
/**
* for和while死循环应用场景
* 从键盘读取个数不确定的数，并判断读入的正数和负数的个数，输入0时结束程序
* @author liuguanglei 18601767221@163.com
* @version 2020/11/11 9:52 上午
* @since JDK11
*/
public class EndLessLoopTest {
public static void main(String[] args) {
//正数个数的数量
int positiveNumberCount=0;
//负数个数的数量
int negativeNumberCount=0;
Scanner input =new Scanner(System.in);
//使用while循环实现
while (true){
System.out.println("while循环 请输入数字");
int number=input.nextInt();
if(number>0){
positiveNumberCount++;
}
else if(number<0){
negativeNumberCount++;
}
if (number==0){
break;//中断并跳出循环
}
}
System.out.printf("while循环输入的正数数量是%d,输入的负数数量是%d\n",positiveNumberCount,negativeNumberCount);
//使用for循环实现
for (;;){
System.out.println("for循环 请输入数字");
int number=input.nextInt();
if(number>0){
positiveNumberCount++;
}
else if(number<0){
negativeNumberCount++;
}
if (number==0){
break;//中断并跳出循环
}
}
System.out.printf("for循环输入的正数数量是%d,输入的负数数量是%d\n",positiveNumberCount,negativeNumberCount);
}
}
循环中断-break和continue
break在循环中表示结束循环，如果是嵌套循环，continue表示结束本次循环，直接进入下一次循环。
break和continue关键字之后的语句都不会再被执行。
break关键字在while循环中的使用
package net.ittimeline.java.core.jdk.foundational.control.whilestatement;
import java.util.Scanner;
/**
* break关键字在while循环中的使用
*
* break关键字用于结束循环
*
* 循环结束的两种情况
* 1 循环条件不满足
* 2 遇到了break关键字
*
* @author liuguanglei 18601767221@163.com
* @version 2020/11/10 6:28 下午
* @since JDK11
*/
public class WhileBreakStatementTest {
public static void main(String[] args) {
//从键盘输入整数，输入0结束，统计输入的正数以及负数的个数
int positiveCount = 0;
int negativeCount = 0;
Scanner input = new Scanner(System.in);
int inputNumber = 0;
while(true){
System.out.println("请输入一个整数");
inputNumber=input.nextInt();
if (inputNumber > 0) {
positiveCount++;
} else if (inputNumber < 0) {
negativeCount++;
}else{
break;
}
}
System.out.printf("while循环结合break关键字 你输入正整数的个数是%d,你输入负整数的个数是%d\n", positiveCount, negativeCount);
}
}
JDK1.5新特性-foreach循环
foreach在C#语言中是一个关键字，而Java中的foreach循环是for循环实现的，它通常用于遍历Java中常用的数据结构，例如数组、集合等等。
foreach循环的语法结构
for(数据类型 变量名:数据结构){
循环体
}这里主要先演示使用foreach遍历数组,我这里编写了一个工具类，包含常用的关于生成整数数组的静态方法。
package net.ittimeline.java.core.jdk.util.lang;
/**
* 数组生成工具类
*
* @author liuguanglei 18601767221@163.com
* @version 2020/11/11 10:03 上午
* @since JDK11
*/
public class ArrayGeneratorUtils {
/**
* 创建一个指定大小的整数数组
*
* @param size
* @return
*/
public static int[] range(int size) {
int[] result = new int[size];
for (int i = 0; i < size; i++) {
result[i] = i;
}
return result;
}
/**
* 生成一个指定区间的整数数组
*
* @param start
* @param end
* @return
*/
public static int[] range(int start, int end) {
int size = end - start;
int[] result = new int[size];
for (int i = start; i < size; i++) {
result[i] = start + i;
}
return result;
}
/**
* 生成一个指定区间的整数数组
*
* @param start 循环的开始条件
* @param end
* @param step
* @return
*/
public static int[] range(int start, int end, int step) {
int size = (end - start) / step;
int[] result = new int[size];
for (int i = 0; i < size; i++) {
result[i] = start + (i * step);
}
return result;
}
}
使用foreach遍历整数数组
package net.ittimeline.java.core.jdk.foundational.control.foreachstatement;
//使用JDK1.5的静态导入特性导入 ArrayGeneratorUtils类的range()方法，然后在ForeachIntStatementTest类中可以直接使用
import static net.ittimeline.java.core.jdk.util.lang.ArrayGeneratorUtils.range;
/**
* foreach遍历整数数组
*
* @author liuguanglei 18601767221@163.com
* @version 2020/11/11 10:05 上午
* @since JDK11
*/
public class ForeachIntStatementTest {
public static void main(String[] args) {
//foreach遍历整数数组
for (int i:range(10)) {
System.out.print(i+" ");
}
}
}
使用foreach遍历字符串
package net.ittimeline.java.core.jdk.foundational.control.foreachstatement;
/**
* foreach遍历字符串
*
* @author liuguanglei 18601767221@163.com
* @version 2020/11/11 10:15 上午
* @since JDK11
*/
public class ForEachStringStatementTest {
public static void main(String[] args) {
String bookName = "Java编程思想第四版";
//字符串的本质是字符数组
//toCharArray()是将字符串转换为字符数组
for (char ch : bookName.toCharArray()) {
System.out.print(ch + " ");
}
}
}
使用foreach遍历浮点类型数组
package net.ittimeline.java.core.jdk.foundational.control.foreachstatement;
import java.util.Random;
/**
* foreach遍历浮点数组
*
* @author liuguanglei 18601767221@163.com
* @version 2020/11/11 10:15 上午
* @since JDK11
*/
public class ForEachFloatStatementTest {
public static void main(String[] args) {
Random random=new Random(88);
float[]floats=new float[10];
for (int i=0;i<floats.length;i++){
floats[i]=random.nextFloat();
}
for (float f:floats){
System.out.println("f = "+f);
}
}
}
循环嵌套
当把一个循环结构(循环B)声明在另外一个循环结构(循环A)的循环体中，此时就构成了循环的嵌套，此时循环A被称作为外层循环，循环B被称为内层循环。
嵌套循环的执行流程是外层循环执行一次，内层循环执行一遍。
假设外层循环循环m次，内层循环循环n次，那么内层循环的总次数是m*n次。
理解循环嵌套的执行流程
package net.ittimeline.java.core.jdk.foundational.control.forstatement;
/**
* 循环嵌套
*
* @author liuguanglei 18601767221@163.com
* @version 2020/11/11 8:23 上午
* @since JDK11
*/
public class ForNestStatementTest {
public static void main(String[] args) {
/*
执行流程
外层循环执行一次
内层循环执行一遍
*/
for (int i = 0; i < 5; i++) {
//每次打印5个*
for (int j = 0; j < 5; j++) {
//一共会执行25次
System.out.print("*");
}
//每次换行 一共执行5次
System.out.println();
}
}
}
循环嵌套语句案例1: 循环嵌套求水仙花数
package net.ittimeline.java.core.jdk.foundational.control.forstatement;
/**
* 循环嵌套求水仙花数
*
* @author liuguanglei 18601767221@163.com
* @version 2020/11/11 8:23 上午
* @since JDK11
*/
public class ForNestStatementExample1 {
public static void main(String[] args) {
/*
水仙花数 百位 1-9
十位 0-9
个位 0-9
*/
for (int hunderd = 1; hunderd <= 9; hunderd++) {
for (int decade = 0; decade <= 9; decade++) {
for (int unit = 0; unit <= 9; unit++) {
if(hunderd*hunderd*hunderd+decade*decade*decade+unit*unit*unit==hunderd*100+decade*10+unit){
System.out.println(hunderd*100+decade*10+unit);
}
}
}
}
}
}
循环嵌套语句案例2:循环嵌套求1000以内的完数
package net.ittimeline.java.core.jdk.foundational.control.forstatement;
/**
* 循环嵌套求1000以内的完数
* 完数:一个数如果恰好等于它的因子之和
* 例如 6的因子:1,2,3
* 1,2,3,6是6的约数，能够把6整除了
* 18的因子
* @author liuguanglei 18601767221@163.com
* @version 2020/11/11 8:23 上午
* @since JDK11
*/
public class ForNestStatementPerfectNumberExample2 {
public static void main(String[] args) {
for (int i = 1; i < 1000; i++) {
//判断i是否是完数，如果是就打印i
int divisorSum=0;
//首先找出i的所有因子，并且累加它的因子
for (int j = 1; j <i ; j++) {
if(i%j==0){
divisorSum+=j;
}
}
//判断它的因子之和与i是否相等，如果相等就是完数
if(i==divisorSum){
System.out.println("完数:"+i);
}
}
}
}
循环嵌套语句案例3:使用三种方式循环嵌套求100以内的质数
package net.ittimeline.java.core.jdk.foundational.control.forstatement;
/**
* 使用三种方式循环嵌套求100以内的质数
*
* @author liuguanglei 18601767221@163.com
* @version 2020/11/11 8:23 上午
* @since JDK11
*/
public class ForNestStatementPrimeNumberExample3 {
public static void main(String[] args) {
//方法1
for (int i = 1; i < 100; i++) {
int approximateNumberSum = 0;
//找出i所有的约数
for (int j = 1; j <= i; j++) {
if (i % j == 0) {
//累加它们的和
approximateNumberSum += j;
}
}
//约数和等于i+1 那么i就是素数
if (approximateNumberSum == i + 1) {
System.out.print(i + " ");
}
}
System.out.println();
System.out.println("楚河*******汉界******");
//方法2
for (int i = 2; i < 100; i++) {
int iCount = 0;
for (int j = 2; j < i; j++) {
if (i % j == 0) {
iCount++;
}
}
if (iCount == 0) {
System.out.print(i + " ");
}
}
System.out.println();
System.out.println("楚河*******汉界******");
//方法3
for (int i = 2; i < 100; i++) {
//假设i是素数
boolean flag = true;
for (int j = 2; j < i; j++) {
//
if (i % j == 0) {
flag = false;
//结束内层的for循环
break;
}
}
if (flag) {
System.out.print(i + " ");
}
}
}
}
for循环嵌套语句案例4:打印九九乘法表
package net.ittimeline.java.core.jdk.foundational.control.forstatement;
/**
* 循环嵌套
* 实现九九乘法口诀表
* 1 * 1 = 1
* 1 * 2 = 2 2 * 2 = 4
* 1 * 3 = 3 2 * 3 = 6 3 * 3 = 9
* 1 * 4 = 4 2 * 4 = 8 3 * 4 = 12 4 * 4 = 16
* 1 * 5 = 5 2 * 5 = 10 3 * 5 = 15 4 * 5 = 20 5 * 5 = 25
* 1 * 6 = 6 2 * 6 = 12 3 * 6 = 18 4 * 6 = 24 5 * 6 = 30 6 * 6 = 36
* 1 * 7 = 7 2 * 7 = 14 3 * 7 = 21 4 * 7 = 28 5 * 7 = 35 6 * 7 = 42 7 * 7 = 49
* 1 * 8 = 8 2 * 8 = 16 3 * 8 = 24 4 * 8 = 32 5 * 8 = 40 6 * 8 = 48 7 * 8 = 56 8 * 8 = 64
* 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
*
* @author liuguanglei 18601767221@163.com
* @version 2020/11/11 10:20 上午
* @since JDK11
*/
public class ForNestMultiplicationTableExample4 {
public static void main(String[] args) {
int number=9;
//外层循环控制行
for (int i=1;i<=number;i++){
//内层循环控制每行的列
for (int j=1;j<=i;j++){
System.out.print(j+ " * "+i+" = "+(i*j)+"\t");
}
//如果一行执行完则换行
System.out.println();
}
}
}
for循环语句嵌套案例5:打印菱形
package net.ittimeline.java.core.jdk.foundational.control.forstatement;
/**
* 打印菱形
*
* @author liuguanglei 18601767221@163.com
* @version 2020/11/11 10:22 上午
* @since JDK11
*/
public class ForNestRhombusExample5 {
public static void main(String[] args) {
/**
* 打印菱形实现步骤
* 首先将菱形拆解为两个等腰三角形
* 然后分别用两个嵌套循环打印
* 每个嵌套循环中，外层循环控制行数，内层循环控制输出的内容:即空格和*
*
*
*
*/
String star="* ";
/**
* 第一个for循环
* 外层控制循环次数 一共是五次,因为等边三角形占了5行
* 内层循环控制内容 内层循环的第一个循环先打4-i个空格，内层循环的第二个循环打印i
*
*
* * * *
* * *
* * * *
* * * * *
* * * * * *
*
*
*
*/
//第一个嵌套for循环
//外层循环控制行数
for (int i=0;i<5;i++){
//内层循环控制每行的内容
for (int j=0;j<4-i;j++){
System.out.print(" ");
}
for (int k=0;k<=i;k++){
System.out.print(star);
}
System.out.println();
}
/**
* * * * *
* * * *
* * *
* *
*/
//总共是9行，上一次循环是5行，这里外层循环就只需要四次
for (int i=4;i>0;i--){
//打印空格 空格的个数是4-i
for (int j=0;j<=4-i;j++){
System.out.print(" ");
}
//打印星星
for (int k=0;k<i;k++){
System.out.print("* ");
}
//换行
System.out.println("");
}
}
}
for循环嵌语句套案例6:统计100000以内的质数以及耗时
package net.ittimeline.java.core.jdk.foundational.control.forstatement;
/**
* 查找1-100000以内的质数
* 质数:只能被1和自身整除的数->从2开始，到这个数减1结束为止，都不能被这个数本身整除
* 最小的质数是2
* @author liuguanglei 18601767221@163.com
* @version 2020/11/11 10:28 上午
* @since JDK11
*/
public class ForNestFindPrimersFrom100000Example6 {
public static void main(String[] args) {
/**
* 从2开始，到这个数减1结束为止，都不能被这个数本身整除
*/
int count=0;
boolean isPrimer=true;
//返回当前时间的毫秒数
long startTime=System.currentTimeMillis();
int number=10_0000;
for (int i=2;i<=number;i++){
for (int j=2;j<i;j++){
if(i%j==0){
isPrimer=false;
}
}
if(isPrimer){
// System.out.println("i = "+i);
count++;
}
isPrimer=Boolean.TRUE;
}
long endTime=System.currentTimeMillis();
System.out.printf("计算%d以内所有的质数耗时毫秒数为%d,质数的数量为%d",number,(endTime-startTime),count);
// 程序输出结果 计算100000以内所有的质数耗时毫秒数为13259,质数的数量为9592
}
}
for循环嵌语句套案例7:优化算法:统计100000以内的质数以及耗时
package net.ittimeline.java.core.jdk.foundational.control.forstatement;
/**
* 查找1-100000以内的质数
* 质数:只能被1和自身整除的数->从2开始，到这个数减1结束为止，都不能被这个数本身整除
* 最小的质数是2
* @author liuguanglei 18601767221@163.com
* @version 2020/11/11 10:28 上午
* @since JDK11
*/
public class ForNestFindPrimersFrom100000Example7 {
public static void main(String[] args) {
/**
* 从2开始，到这个数减1结束为止，都不能被这个数本身整除
*/
boolean isPrimer=true;
int count =0;
long startTime=System.currentTimeMillis();
int number=10_0000;
for (int i=2;i<=number;i++){
for (int j=2;j<=Math.sqrt(i);j++){
if(i%j==0){
isPrimer=false;
break; //优化 支队本身非质数的自然数有效的
}
}
if(isPrimer){
count++;
}
isPrimer=Boolean.TRUE;
}
long endTime=System.currentTimeMillis();
System.out.printf("计算%d以内所有的质数耗时毫秒数为%d,质数的数量为%d",number,(endTime-startTime),count);
//程序输出结果:计算100000以内所有的质数耗时毫秒数为11,质数的数量为9592
}
}
循环结构-带标签的循环
在循环嵌套时，如果希望在内层循环中断到外层循环时，可以使用带标签的循环实现。
break和continue默认结束包含此关键字最近的循环，如果想要break和continue结束外层循环，可以使用带标签的循环实现。
带标签的循环结构如下所示
outer: for(){
inner:for(){
break outer;
}
}比较带标签的break、continue和不带标签的break、continue
package net.ittimeline.java.core.jdk.foundational.control.forstatement;
/**
* 带标签的for循环
* 结合break关键字可以结束指定标签循环
* @author liuguanglei 18601767221@163.com
* @version 2020/11/11 9:09 上午
* @since JDK11
*/
public class ForLabelBreakContinueStatementTest {
public static void main(String[] args) {
for (int i = 0; i <5 ; i++) {
for (int j = 0; j <5 ; j++) {
System.out.print("*");
if(i==j){
//默认情况下只能结束外层循环
break;
}
}
System.out.println();
}
System.out.println("楚河*******汉界******");
outer:for (int i = 0; i <5 ; i++) {
for (int j = 0; j <5 ; j++) {
System.out.print("*");
if(i==j){
//结束整个循环
break outer;
}
}
System.out.println();
}
System.out.println("楚河*******汉界******");
outer:for (int i = 0; i <5 ; i++) {
for (int j = 0; j <5 ; j++) {
System.out.print("* ");
if(i==j){
//结束整个循环
continue outer;
}
}
System.out.println();
}
}
}
带标签的for循环
package net.ittimeline.java.core.jdk.foundational.control.label;
import static java.lang.System.out;
/**
* 带标签的for循环
*
* @author liuguanglei 18601767221@163.com
* @version 2020/11/11 10:32 上午
* @since JDK11
*/
public class LabelForStatement {
public static void main(String[] args) {
int i = 0;
outer:
for (; true; ) {
inner:
for (; i < 10; i++) {
System.out.println(" i= " + i);
if (i == 2) {
out.println("continue");
continue;
}
if (i == 3) {
out.println("break");
break;
}
if (i == 7) {
out.println("continue outer");
i++;
//结束本次循环，调到外层循环
continue outer;
}
if (i == 8) {
out.println("break outer");
break outer;
}
for (int k = 0; k < 5; k++) {
if (k == 3) {
out.println("continue inner");
continue inner;
}
}
}
}
}
}
带标签的while循环
package net.ittimeline.java.core.jdk.foundational.control.label;
/**
* 带标签的while循环
*
* @author liuguanglei 18601767221@163.com
* @version 2020/11/11 10:35 上午
* @since JDK11
*/
public class LabelWhileStatementTest {
public static void main(String[] args) {
int i=0;
outer:
while(i<9){
int j=0;
inner:while (j<9){
if(j==6){
break outer;
}
System.out.println(" i = "+i+" j = "+j);
j++;
}
i++;
}
}
}
内容总结
以上是互联网集市为您收集整理的跟光磊学Java应用开发与系统架构-Java程序流程控制全部内容，希望文章能够帮你解决跟光磊学Java应用开发与系统架构-Java程序流程控制所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。
来源：【匿名】