标签：case Java int System 程序流程 循环 光磊学 public out
跟光磊学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++;
}
}
}
标签：case,Java,int,System,程序流程,循环,光磊学,public,out 来源： https://www.cnblogs.com/ittimeline/p/14020592.html
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。