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);
        }

    }
}

下面的代码演示了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);
        }

    }
}

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;j<i/2;j++){
                if (i % j == 0){
                    continue outer;
                }
            }
            System.out.println(i+"");
        }

    }
}

改进的代码：

去掉标签：使用布尔变量 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();
        }

    }
}

🎉 感谢您的支持！ 🎉

如果您觉得我的内容有价值，或者对您有所帮助，希望您能给我一个小小的鼓励：