Java零基础入门笔记：(3)程序控制
前言
本笔记是学习狂神的java教程，建议配合视频，学习体验更佳。
【狂神说Java】Java零基础学习视频通俗易懂_哔哩哔哩_bilibili
Scanner对象
之前我们学的基本语法中我们并没有实现程序和人的交互，但是Java给我们提供了这样一个工具类，我们可以获取用户的输入。
Scanner 类是 Java 中的一个实用工具类，位于 java.util 包中，主要用于从用户输入、文件或其他输入源中读取数据。它提供了一种简单且灵活的方式来解析不同类型的数据，例如字符串、整数、浮点数等。
-
scanner.hasNext()
scanner.hasNext() 是 Scanner 类的一个方法，用于检查输入源中是否还有下一个输入项。它是一个布尔方法，返回 true 表示输入源中还有下一个输入项，返回 false 表示没有更多输入项。
通过Scanner类的next()与nextLine()方法获取输入的字符串，在读取前我们一般需要使用hasNext() 与hasNextLine()判断是否还有输入的数据。
-
scanner.next()
scanner.next() 是 Java 中 Scanner 类的一个方法，用于从输入源中读取下一个单词（token）。它会根据默认的分隔符（通常是空白字符，包括空格、制表符和换行符）来分隔输入内容，并返回下一个单词。
- 一定要读取到有效字符后才可以结束输入。
- 对输入有效字符之前遇到的空白，next()方法会自动将其去掉。
- 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
- next()不能得到带有空格的字符串。
-
下面这段代码使用hasNext()判断有无字符串输入，然后使用.next()接收字符串输入。
-
创建了一个
Scanner对象，命名为scanner。System.in是Java标准输入流，通常指向键盘输入。通过Scanner类，可以方便地从键盘读取用户输入的数据。 -
调用了
scanner.hasNext()方法。hasNext()方法用于检查Scanner对象是否还有下一个输入项（即用户是否输入了内容）。如果用户输入了内容，hasNext()返回true；否则返回false。 -
如果
scanner.hasNext()返回true，程序会进入if语句块。这行代码调用了scanner.next()方法，用于读取用户输入的下一个字符串。next()方法会读取用户输入的内容，直到遇到空白符（如空格、换行符等）为止，并将读取到的内容存储到变量str中。
package scanner;
import java.util.Scanner;
public class demo1 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in); // 创建一个scanner对象，用于接收键盘数据
System.out.println("接收：");
if (scanner.hasNext()){ // 判断有无输入字符串
String str = scanner.next(); // 使用next方法接收
System.out.println("内容为"+str);
}
scanner.close();
}
}
输出示例
接收：
hello world
内容为hello-
scanner.hasNextLine()
scanner.hasNextLine() 是 Java 中 Scanner 类的一个方法，用于检查输入源（如键盘输入或文件输入）中是否还有下一行数据。它的返回值是一个布尔值（boolean）
通过Scanner类的next()与nextLine()方法获取输入的字符串，在读取前我们一般需要使用hasNext() 与hasNextLine()判断是否还有输入的数据。
-
scanner.nextLine()
-
作用：读取输入中的整行内容，直到遇到换行符为止。
-
行为：从当前位置开始读取，直到遇到换行符（
\n或\r\n），并将换行符之前的全部内容作为结果返回。 -
特点：会读取整行内容，包括空格和制表符，但不会读取换行符本身。
下面这段代码使用hasNextLine()判断有无字符串输入，然后使用.nextline()接收字符串输入。
-
创建了一个
Scanner对象，命名为scanner。System.in是Java标准输入流，通常指向键盘输入。通过Scanner类，可以方便地从键盘读取用户输入的数据。 -
调用了
scanner.hasNextLine()方法。hasNextLine()方法用于检查Scanner对象是否还有下一行（即用户是否输入了内容）。如果用户输入了内容，hasNextLine()返回true；否则返回false。 -
如果
scanner.hasNextLine()返回true，程序会进入if语句块。这行代码调用了scanner.nextline()方法，用于读取用户输入的下一个字符串。nextline()方法会读取用户输入的内容，直到遇到换行符（\n或\r\n）为止，并将读取到的内容存储到变量str中。
package scanner;
import java.util.Scanner;
public class demo1 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in); // 创建一个scanner对象，用于接收键盘数据
System.out.println("接收：");
if (scanner.hasNextLine()){ // 判断有无输入字符串
String str = scanner.nextLine(); // 使用next方法接收
System.out.println("内容为"+str);
}
scanner.close();
}
}
输出结果示例
接收：
hello world
内容为hello world-
其他
scanner.hasNextInt()
-
作用：检查输入源中是否下一个数据项是整数。
-
返回值：布尔值（
boolean）。如果下一个数据项可以被解析为整数（int类型），则返回true；否则返回false。 -
特点：
-
会跳过前面的空白符（空格、制表符、换行符等）。
-
如果输入不符合整数格式（如包含字母或小数点），则返回
false。
-
scanner.nextInt()
-
作用：读取输入源中的下一个整数。
-
返回值：整数（
int类型）。 -
特点：
-
会跳过前面的空白符。
-
如果输入不符合整数格式，会抛出
InputMismatchException异常。 -
只读取一个整数，不会读取换行符。
-
scanner.hasNextFloat()
-
作用：检查输入源中是否下一个数据项是浮点数。
-
返回值：布尔值（
boolean）。如果下一个数据项可以被解析为浮点数（float类型），则返回true；否则返回false。 -
特点：
-
会跳过前面的空白符。
-
浮点数可以包含小数点和科学计数法（如
3.14或1.23e-10）。 -
如果输入不符合浮点数格式（如包含字母或多余的符号），则返回
false
-
scanner.nextFloat()
-
作用：读取输入源中的下一个浮点数。
-
返回值：浮点数（
float类型）。 -
特点：
-
会跳过前面的空白符。
-
如果输入不符合浮点数格式，会抛出
InputMismatchException异常。 -
只读取一个浮点数，不会读取换行符
-
package scanner;
import java.util.Scanner;
public class demo1 {
public static void main(String[] args) {
// 创建一个scanner对象，用于接收键盘数据
Scanner scanner = new Scanner(System.in);
int i = 0;
float f = 0.0f;
System.out.println("请输入整数：");
if (scanner.hasNextInt()){
i = scanner.nextInt();
System.out.println("整数："+i);
}else {
System.out.println("输入的不是整数！");
}
System.out.println("请输入小数：");
if (scanner.hasNextFloat()){
f = scanner.nextFloat();
System.out.println("小数："+f);
}else {
System.out.println("输入的不是小数！");
}
scanner.close();
}
}
输入和输出示意：
请输入整数:
10
整数数据:10
请输入小数:
1.1
小数数据:1.1
请输入整数:
10.1
输入的不是整数数据! // 这里会直接跳过小数部分的输入，直接把10.1赋值给f
请输入小数:
10.1
小数数据:10.1
-
package scanner;
import java.util.Scanner;
public class demo1 {
public static void main(String[] args) { // 求和和求平均
// 创建一个scanner对象，用于接收键盘数据
Scanner scanner = new Scanner(System.in);
double sum = 0;
int m = 0;
while (scanner.hasNextDouble()){
double x = scanner.nextDouble();
System.out.println("你输入了"+x);
m++;
sum += x;
}
System.out.println("sum:"+sum);
System.out.println("mean:"+(sum/m));
scanner.close();
}
}
输入输出示例：
请输入浮点数（输入非数字结束）：
3.5
2.5
4.0
abc
你输入了：3.5
你输入了：2.5
你输入了：4.0
总和：10.0
平均值：3.3333333333333335-
-
顺序结构
JAVA的基本结构就是顺序结构，除非特别指明，否则就按照顺序一句一句执行。
顺序结构是最简单的算法结构。
语句与语句之间，框与框之间是按从上到下的顺序进行的，它是由若干个依次执行的处理步骤组成的，它是任何一个算法都离不开的一种基本算法结构。
package com. kuang.struct;
public class shunXuDemo {
public static void main(String[] args) {
System.out.println("hello1");
System.out.println("hello2");
System.out.println("hello3");
System.out.println("he1lo4");
System.out.println("he11o5");
}
}
输出
hello1
hello2
hello3
hello4
hello5
-
-
选择结构
if单选择结构
if单循环的流程如下：
-
条件判断：检查
if语句中的条件是否为true。 -
执行代码块：如果条件为
true，则执行if代码块中的语句；如果条件为false，则跳过代码块，继续执行后续代码。
if(布尔表达式){
//如果布尔表达式为true将执行的语句
}
下面的代码演示了if单循环和字符串判等的流程：
-
读取用户输入：使用
scanner.nextLine()读取用户输入的一整行内容，并存储到变量s中。 -
判断输入内容：
-
如果用户输入的内容是
"He11o"，则打印变量s的内容。 -
如果输入不是
"He11o"，则跳过打印。
-
package scanner;
import java.util.Scanner;
public class demo1 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入内容:");
String s = scanner.nextLine();
if (s.equals("He11o")){ //equals:判断字符串是否相等
System.out.println(s);
}
System.out.println("End");
scanner.close();
}
}
输出示例：
请输入内容:
hello
End
请输入内容:
He11o
He11o
End-
if双选择结构
现在有个需求，公司要收购一个软件，成功了，给人支付100万元，失败了，自己找人开发。这样的需求用一个if就搞不定了，我们需要有两个判断，需要一个双选择结构，所以就有了if-else结构。
if-else 双分支结构的流程可以概括为以下几步：
-
条件判断：
检查if语句中的条件是否为true。 -
执行分支：
-
如果条件为
true，执行if代码块中的语句。 -
如果条件为
false，跳过if代码块，执行else代码块中的语句。
-
-
结束：
执行完if或else代码块后，程序继续执行后续代码。
if(布尔表达式){
//如果布尔表达式的值为true
}else{
//如果布尔表达式的值为false
}
以下代码演示了if双选择的使用方法：
-
读取用户输入的成绩：使用
scanner.nextInt()读取用户输入的整数，并存储到变量score中。 -
判断成绩是否及格：
-
如果
score > 60，打印"及格"。 -
否则，打印
"不及格"。
-
package scanner;
import java.util.Scanner;
public class demo1 {
public static void main(String[] args) {
//考试分数大于60就是及格，小于60分就不及格。
Scanner scanner = new Scanner(System.in);
System.out.println("请输入成绩：");
int score = scanner.nextInt();
if (score>60){
System.out.println("及格");
}else {
System.out.println("不及格");
}
scanner.close();
}
}
输出示例：
请输入成绩：
77
及格
请输入成绩：
44
不及格-
if多选择结构
我们发现刚才的代码不符合实际情况，真实的情况还可能存在ABCD，存在区间多级判断。比如90-100就是A，80-90就是B..等等，在生活中我们很多时候的选择也不仅仅只有两个，所以我们需要一个多选择结构来处理这类问题！
if多选择的流程如下：
-
条件判断：
-
从第一个
if条件开始判断。 -
如果
if条件为true，执行if代码块中的语句，然后跳到步骤5。 -
如果
if条件为false，继续判断下一个else if条件。
-
-
依次判断
else if条件：-
按顺序判断每个
else if条件。 -
如果某个
else if条件为true，执行对应的代码块，然后跳到步骤5。 -
如果所有
else if条件都为false，执行步骤3。
-
-
执行
else代码块：-
如果所有
if和else if条件都不成立，执行else代码块。
-
注意事项：
- if 语句至多有1个 else 语句，else 语句在所有的 else if 语句之后。
- if 语句可以有若干个 else if 语句，它们必须在 else 语句之前。
- 一旦其中一个 else if 语句检测为true，其他的 else if 以及 etse 语句都将跳过执行。
if(布尔表达式 1){
//如果布尔表达式 1的值为true执行代码
}else if(布尔表达式 2){
//如果布尔表达式 2的值为true执行代码
}else if(布尔表达式 3){
//如果布尔表达式 3的值为true执行代码
}else {
//如果以上布尔表达式都不为true执行代码
}
package scanner;
import java.util.Scanner;
public class demo1 {
public static void main(String[] args) {
//考试分数大于60就是及格，小于60分就不及格。
Scanner scanner = new Scanner(System.in);
/*
if 语句至多有1个 else 语句，else 语句在所有的 else if 语句之后。
if 语句可以有若干个 else if 语句，它们必须在 else 语句之前。
一旦其中一个 else if 语句检测为true，其他的 else if 以及 etse 语句都将跳过执行。
*/
System.out.println("请输入成绩：");
int score = scanner.nextInt();
if ( score==100){
System.out.println("恭喜满分");
}else if (score<100 && score>=90){
System.out.println("A级");
}else if (score<90 && score>=80){
System.out.println("B级");
}else if (score<80 && score>=70){
System.out.println("c级");
}else if (score<70 && score>=60){
System.out.println("D级");
}else if (score<60 && score>=0){
System.out.println("不及格");
}else {
System.out.println("成绩不合法");
}
scanner.close();
}
}
-
嵌套的if结构
使用嵌套的if..else语句是合法的。也就是说你可以在另一个if或者else if语句中使用if 或者else if 语句。你可以像if 语句一样嵌套else if...else。
if(布尔表达式 1){
如果布尔表达式 1的值为true执行代码
if(布尔表达式 2){
如果布尔表达式 2的值为true执行代码
}
}
列如下面的代码示例中，用户输入一个1-100的数字，我们使用Java通过二分查找，找到对应的数字（二分查找属于超纲内容，可以先不理解其思想）
- 在下面的代码中，我们在第一个if中嵌套了一个while（见循环结构），然后又在其中嵌套了一个if
package scanner;
import java.util.Scanner;
public class demo_sc {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入一个1-100的数字：");
if (scanner.hasNextInt()){
int x = scanner.nextInt();
int left = 1, right=100;
int mid = (left+right)/2;
while(mid != x){
if (x>mid){
left = mid+1;
mid = (left+right)/2;
}else{
right = mid - 1;
mid = (left+right)/2;
}
}
System.out.println(mid);
}
}
}
-
switch多选择结构
多选择结构还有一个实现方式就是switch case语句。
switch流程如下：
-
计算表达式的值：计算
switch语句中表达式的值。 -
匹配
case标签：将表达式的值与每个case标签的值进行比较，直到找到匹配的case。 -
执行匹配的代码块：从匹配的
case标签开始执行代码，直到遇到break语句或switch语句结束。 -
执行
default分支（可选）：如果没有任何case标签与表达式的值匹配，且存在default分支，则执行default分支的代码。
switch(expression){
case value :
//语句
break; //可选
case value :
//语句
break; //可选
//你可以有任意数量的case语句
default : //可选
//语句
}
- switch case语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。
- switch语句中的变量类型可以是:byte、short、int或者char、string。
- 从Java SE7开始，switch支持字符串String 类型了，同时case标签必须为字符串常量或字面量。
-
下面的代码演示了case穿透：在 switch 语句中，如果某个 case 分支没有以 break 语句结束，程序会继续执行下一个 case 分支，直到遇到 break 或 switch 结束。这种现象称为 case 穿透 或 case 跌落。
-
当
grade的值为'c'时，程序会匹配到case 'c'。 -
在
case 'c'中，程序打印"及格"，但没有遇到break语句。 -
由于没有
break，程序会继续执行下一个case分支（case 'D'），打印"再接再厉"。 -
同样，
case 'D'也没有break，程序继续执行case 'E'，打印"挂科"。
package com.kuang.struct;
public class switchDemo01 {
public static void main( String[] args) {
//case穿透
char grade = 'c';
switch (grade){
case 'A':
System.out.println("优秀");
break;
case 'B':
System.out.println("良好");
case 'c':
System.out.println("及格");
case 'D':
System.out.println("再接再厉");
case 'E':
System.out.println("挂科");
}
}
}
如果是A，输出：
优秀
如果是C，输出：（因为没有break，它会接着输出CDE的内容）
及格
再接再厉
挂科解决case穿透的方法也很简单：加上break
switch (grade) {
case 'A':
System.out.println("优秀");
break;
case 'B':
System.out.println("良好");
break;
case 'c':
System.out.println("及格");
break;
case 'D':
System.out.println("再接再厉");
break;
case 'E':
System.out.println("挂科");
break;
}-
下面的代码演示了default，即默认值，如果没有选项命中，便会执行default的内容
package com.kuang.struct;
public class switchDemo01 {
public static void main( String[] args) {
//case穿透 //switch 匹配一个具体的值
char grade = 'F';
switch (grade){
case 'A':
System.out.println("优秀");
break; //可选
case 'B':
System.out.println("良好");
case 'c':
System.out.println("及格");
case 'D':
System.out.println("再接再厉");
case 'E':
System.out.println("挂科");
default:
System.out.println("未知等级");
}
}
}未知等级-
下面的代码演示了switch判断字符串的流程：
从 Java 7 开始，switch 语句支持字符串作为判断条件。其原理基于字符串的 hashCode() 方法和 equals() 方法。
-
hashCode()方法：
每个字符串都有一个哈希值，通过hashCode()方法计算得到。switch语句首先会计算字符串的哈希值，然后根据哈希值来确定匹配的case分支。 -
equals()方法：
如果有多个case分支的字符串哈希值相同（即发生哈希冲突），switch语句会进一步使用equals()方法来比较字符串是否完全相等。
package scanner;
public class demo1 {
public static void main(String[] args) {
String name ="狂神";
//JDK7的新特性，表达式结果可以是字符串! ! !
//字符的本质还是数字
//反编译 java---class (字节码文件) ----反编译 (IDEA)
switch (name){ // 通过hash进行判断
case "秦疆":
System.out.println("秦疆");
break;
case "狂神":
System.out.println("狂神");
break;
default:
System.out.println("弄啥呦!");
}
}
}
-
-
循环结构
while循环
while 循环的流程可以概括为以下几步：
-
条件判断：在循环开始之前，先判断循环条件是否为
true。 -
执行循环体：如果条件为
true，则执行循环体中的代码。 -
重复判断条件：执行完循环体后，再次判断循环条件是否为
true。 -
循环结束：如果条件为
false，则退出循环，继续执行循环之后的代码。
while(布尔表达式) {
//循环内容
}
注意事项：
- 只要布尔表达式为true，循环就会一直执行下去。
- 我们大多数情况是会让循环停止下来的，我们需要一个让表达式失效的方式来结束循环。
- 少部分情况需要循环一直执行，比如服务器的请求响应监听等
- 循环条件一直为true就会造成无限循环【死循环】，我们正常的业务编程中应该尽量避免死循环。会影响程序性能或者造成程序卡死奔溃!
-
下面的代码演示了使用while循环遍历5次“Hello world！”，步骤如下：
-
初始化变量
i的值为0。 -
判断循环条件
i < 5是否成立。-
如果条件为
true，执行循环体：-
打印 "Hello world"。
-
将
i的值加1（i++）。
-
-
如果条件为
false，退出循环。
-
-
重复步骤2，直到
i的值不再小于5。
package scanner;
public class demo1 {
public static void main(String[] args) {
int i = 0;
while (i < 5){
System.out.println("Hello world");
i++;
}
}
}
Hello world
Hello world
Hello world
Hello world
Hello world-
下面的代码演示了：计算1+2+3+...+100=?，步骤如下：
-
初始化变量：
-
i = 0：用于控制循环的计数器。 -
sum = 0：用于存储累加的结果。
-
-
进入
while循环：-
判断条件
i <= 100是否成立。 -
如果条件为
true，执行循环体：-
将当前的
i值加到sum中（sum += i）。 -
将
i的值加1（i++）。
-
-
如果条件为
false，退出循环。
-
package scanner;
public class demo1 {
public static void main(String[] args) {
//计算1+2+3+...+100=?
int i = 0;
int sum = 0;
while (i<=100){
sum += i;
i++;
}
System.out.println(sum);
}
}
-
do...while循环
对于while语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。
do...while循环和while循环相似，不同的是，do...while循环至少会执行一次。
do {
//代码语句
}while(布尔表达式);
While和do-While的区别:
- while先判断后执行。dowhile是先执行后判断!
- Do...while总是保证循环体会被至少执行一次!这是他们的主要差别。
下面的代码演示了while和do-while循环的区别，可见do-while一定会至少执行一次
package scanner;
public class demo1 {
public static void main(String[] args) {
int a = 0;
while(a < 0){
System.out.println(a);
a++;
}
System.out.println("================");
do{
System.out.println(a);
a++;
}while(a<0);
}
}
================
0
-
for循环
虽然所有循环结构都可以用while或者do... while表示，但Java提供了另一种语句——for循环，使一些循环结构变得更加简单。for循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构。
for循环执行的次数是在执行前就确定的。
整体流程：
- 最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。
- 然后，检测布尔表达式的值。如果为true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。
- 执行一次循环后，更新循环控制变量(迭代因子控制循环变量的增减)。
- 再次检测布尔表达式。循环执行上面的过程。
语法格式如下:
for(初始化语句;布尔表达式;更新语句){
//代码语句
}
-
下面的两段代码演示了计算0到100之间的奇数和偶数的和，具体步骤如下：
-
初始化变量：
-
sum1用于存储偶数之和，初始值为0。 -
sum2用于存储奇数之和，初始值为0。
-
-
计算偶数之和：
-
使用
for循环，从0开始，步长为2（i += 2），循环条件为i < 101。 -
每次循环将当前的
i（偶数）加到sum1中。 -
循环结束后，
sum1包含了从0到100的所有偶数之和。
-
-
计算奇数之和：
-
使用另一个
for循环，从1开始，步长为2（i += 2），循环条件为i < 101。 -
每次循环将当前的
i（奇数）加到sum2中。 -
循环结束后，
sum2包含了从1到100的所有奇数之和。
-
package scanner;
public class demo1 {
public static void main(String[] args) {
int sum1 = 0, sum2 = 0;
for (int i = 0; i < 101; i+=2){
sum1 += i;
}
System.out.println(sum1);
for (int i = 1; i < 101; i+=2){
sum2 += i;
}
System.out.println(sum2);
}
}
第二段代码如下：
package scanner;
public class demo1 {
public static void main(String[] args) {
int sum1 = 0, sum2 = 0;
for (int i = 0; i < 101; i+=1){
if (i % 2 == 0)
sum1 += i;
}
System.out.println(sum1);
for (int i = 1; i < 101; i+=2){
if (i % 2 == 1)
sum2 += i;
}
System.out.println(sum2);
}
}
-
这段代码演示了如何用for循环输出1-1000之间能被5整除的数，并且每行输出3个
-
print：输出内容后不换行。 -
println：输出内容后自动换行。
package scanner;
public class demo1 {
public static void main(String[] args) {
for (int i = 0, j = 0; i < 1000; i+=1){
if (i % 5 == 0) {
System.out.print(i + "\t"); // print输出完不会换行
j++;
if (j % 3 == 0) {
System.out.println(""); // println输出完会换行
}
}
}
}
}
-
下面的代码演示了如何使用for循环嵌套打印九九乘法表：
package scanner;
public class demo1 {
public static void main(String[] args) {
for (int i = 1; i < 10; i+=1){
for (int j = 1; j <= i; j+=1){
System.out.print(i+"*"+j+"="+i*j+"\t");
}
System.out.println();
}
}
}
-
增强for循环
Java5 引入了一种主要用于数组或集合的增强型for循环。
Java 增强for循环语法格式如下:
- 声明语句:声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。
- 表达式:表达式是要访问的数组名，或者是返回值为数组的方法。
for(声明语句∶表达式){
//代码句子
}
下面的代码演示了如何使用for循环遍历数组（超纲内容，会在数组章节详细学习，可先跳过）
package scanner;
public class demo1 {
public static void main(String[] args) {
int[] numbers = {10,20,30,40,50};//定义了一个数组
for (int i = 0;i<5;i++){
System.out.println(numbers[i]);
}
System.out.println("====================");
// 方法二：遍历数组的元素
for (int x: numbers){
System.out.println(x);
}
}
}
输出结果
10
20
30
40
50
====================
10
20
30
40
50
-
break & continue
break在任何循环语句的主体部分，均可用break控制循环的流程。break用于强行退出循环，不执行循环中剩余的语句。(break语句也在switch语句中使用)
continue语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。
-
下面的代码演示了break的使用，一旦触发，终止循环
package scanner;
public class demo1 {
public static void main(String[] args) {
int i=0;
while(i<100){
i++;
if (i % 5 == 0){
break;
}
System.out.println(i);
}
}
}
1
2
3
4
-
下面的代码演示了continue的使用，一旦触发，跳过本轮循环，进入下一轮循环
package scanner;
public class demo1 {
public static void main(String[] args) {
int i=0;
while(i<10){
i++;
if (i % 5 == 0){
continue;
}
System.out.println(i);
}
}
}
1
2
3
4
6
7
8
9
-
goto
关于goto关键字
- goto关键字很早就在程序设计语言中出现。尽管goto仍是Java的一个保留字，但并未在语言中得到正式使用;Java没有goto。然而，在break和continue这两个关键字的身上，我们仍然能看出一些goto的影子---带标签的break和continue。
- “标签”是指后面跟一个冒号的标识符，例如: label:
- 对Java来说唯一用到标签的地方是在循环语句之前。而在循环之前设置标签的唯一理由是:我们希望在其中嵌套另一个循环，由于break和continue关键字通常只中断当前循环，但若随同标签使用，它们就会中断到存在标签的地方。
下面的代码演示了如何使用标签
-
如果
i % j == 0，说明i能被j整除，因此i不是质数。使用continue outer;跳出外层循环，继续检查下一个i。但标签（如outer）在 Java 中不推荐使用，因为它会使代码难以阅读和维护。可以使用布尔变量或其他逻辑来替代。
package scanner;
public class demo1 {
public static void main(String[] args) {
// 打印100-150之间的质数
outer: for (int i=101;i<150;i++){ // 不建议使用
for (int j=2;j101
103
107
109
113
127
131
137
139
149
改进的代码：
-
去掉标签：使用布尔变量
isPrime来标记是否为质数，避免使用标签。 -
优化内层循环：将内层循环的条件改为
j * j <= i，减少不必要的计算。
package scanner;
public class demo1 {
public static void main(String[] args) {
for (int i = 101; i < 150; i++) {
boolean isPrime = true;
for (int j = 2; j * j <= i; j++) { // 只检查到 sqrt(i)
if (i % j == 0) {
isPrime = false;
break; // 不需要继续检查
}
}
if (isPrime) {
System.out.println(i);
}
}
}
}-
练习
打印如下所示的三角形（固定5行）
*
***
*****
*******
*********
答案：
package scanner;
public class demo1 {
public static void main(String[] args) {
//打印三角形 5行
for (int i = 1; i <= 5; i++) {
for (int j = 5; j >=i ; j--) {
System.out.print(" ");
}
for (int j = 1; j <=i ; j++) {
System.out.print("*");
}
for (int j = 1; j < i; j++) {
System.out.print("*");
}
System.out.println();
}
}
}
然后可以试试设置行数的打印：
答案：
package scanner;
public class demo1 {
public static void main(String[] args) {
int len = 7;
for (int i = 1; i <= len; i++) {
for (int i1 = len; i1 >= i; i1--) {
System.out.print(" ");
}
for (int i1 = 0; i1 < 2 * i - 1; i1++) {
System.out.print("*");
}
System.out.println();
}
}
}
-
-
感谢您的支持！
如果您觉得我的内容有价值，或者对您有所帮助，希望您能给我一个小小的鼓励：
-
点赞：让我知道您喜欢我的内容！
-
关注：第一时间获取更多有趣、有用的信息！
-
⭐️ 收藏：方便您随时回顾，也方便分享给更多需要的人！
您的支持是我不断进步的动力！感谢您抽出宝贵的时间阅读，祝您生活愉快，万事顺心！✨