09.Java while循环/do...while 循环/for 循环/嵌套循环/break/continue/标签 Label

while循环

先判断，后执行。

while 语法结构

while (布尔表达式){
  循环体;
}

while 流程图

代码示例：使用 while 循环计算 1+2+3...+100 的累加的和

public class TestWhile {
    public static void main(String[] args) {
        // 计算 1+2+3...+100 的累加的和：5050
        int i = 1;
        int scount = 0;
        while(i <= 100){
            scount += i;
            i++;  // 或者 i+=1;
        }
        System.out.println("scount的最终结果是:"+scount); // 结果为 5050
    }
}

do...while 循环

先执行，后判断。

do...while 语法结构

do-while 循环结构会先执行循环体，再判断布尔表达式的值，若条件为真，执行循环体，当条件为假，结束循环。
do...while 循环的循环体至少执行一次。

do {
    循环体;
}while(布尔表达式);

流程图

代码示例：使用 do...while 循环结构：1-100之间的累加和

public class TestDoWhile {
    public static void main(String[] args) {
        // 使用 do...while 循环结构：1-100之间的累加和
        int i = 0;
        int sum = 0;
        do {
            sum += i;
            i++;
        }while(i <= 100); // 此处不能省略，
        System.out.println("结果为："+sum);
    }
}

for 循环

for 语法结构

for (初始表达式; 布尔表达式; 迭代因子){
    循环体;
}

循环流程图

代码示例：使用for循环累加1-100之间的数

public class TestFor {
    public static void main(String[] args) {
        // 使用for循环累加1-100之间的数
        int sum = 0;
        for (int i = 1;i <= 100;i++){
            sum += i;
        }
        System.out.println("运算结果为：" + sum);

        // 逗号运算符:> 帮助初始化定义多个变量以及相关运算
        for(int k = 1, j = 2;k < 5;k++,j = k * 2){
            System.out.println("k="+ k + ","+ "j=" + j);
        }
        // for(;;) 无限循环，相当于 while(true)
        for(;;){
            System.out.println("这里会无限循环打印");
        }
    }
}

小知识：

  1. 逗号运算符：帮助初始化定义多个变量以及相关运算。
  2. 无限循环： for( ;; ) 无限循环，相当于 while(true)。：无限循环 ; ) 符号在 markdown 语法中的小彩蛋：;）
  3. 在 for 循环中定义的变量，作用域仅限于 for 循环体以内，不作用于循环体外部。
  4. 意外小彩蛋：无限循环某两个符号在 markdown 语法中的表情包：😉

嵌套循环

在一个循环语句内部再嵌套一个或多个循环，称之为嵌套循环。

代码示例：打印数字矩阵

public class TestXunH {
    public static void main(String[] args) {
        for (int i = 1;i <= 5;i++){
            for (int j = 1;j <= 5;j++){
                // 这里不用 println，使用print。没有 ln 则代表打印不换行
                System.out.print(i + "  ");
            }
            // 当内层循环结束以后，下一次外层循环开始时换行
            System.out.println();
        }
    }
}

打印结果

代码示例：使用循环嵌套打印九九乘法表

public class Test99 {
    public static void main(String[] args) {
        for (int i=1;i < 10;i++){
            for (int j = 1; j <= i;j++){
                System.out.print( j + " * " + i  + " = " + i*j + "\t");  // \t 制表符隔开循环打印的语句，\t 相当于 table 按键
            }
            // 下一次外层循环开始之前，打印空换行
            System.out.println();
        }
    }
}

打印结果

代码示例：用 while 循环分别计算 100 以内的奇数以及偶数的和，并输出。

// 用 while 循环分别计算 100 以内的奇数以及偶数的和，并输出。
public class TestWhile2 {
    public static void main(String[] args) {
        int sount01 = 0;
        int sount02 = 0;
        for (int i = 1; i <= 100;i++){
            if ( i % 2 == 1){
                sount01 += i;
            }else{
                sount02 += i;
            }
        }
        System.out.println("奇数和：" + sount01);
        System.out.println("偶数和：" + sount02);
    }
}

代码示例：用 while 循环或其他循环输出 1-1000 之间能被 5 整除的数，且每行输出 5 个。

// 用 while 循环或其他循环输出 1-1000 之间能被 5 整除的数，并且每行输出 5 个。
public class TestWhile2 {
    public static void main(String[] args) {
        int k = 0;
        for (int i = 1; i <= 1000;i++){
            if (i % 5 == 0){
                System.out.print(i + "\t");
                k++;
            }
            if (k == 5){
                System.out.println();
                k = 0;
            }
        }
    }
}

break 与 continue

  1. break 用于强行退出整个循环，不执行循环中剩余的语句。
  2. continue 用于退出某次循环，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。

代码示例：把 100-150 之间不能被 3 整除的数输出，并且每行输出 5 个

// 把 100-150 之间不能被 3 整除的数输出，并且每行输出 5 个
public class TestContinue {
    public static void main(String[] args) {
        int count = 0;// 定义计数器
        for (int i = 100;i < 150; i++){
            // 如果是 3 的倍数，则跳过本次循环，继续进行下一次循环
            if ( i % 3 == 0){
                continue;
            }
            // 否则（不是 3 的倍数），输出打印
            System.out.print(i + "、");
            count++;
            // 根据计数器判断每行是否已经输出 5 个数
            if (count % 5 == 0){
                System.out.println();
                count = 0;
            }
        }
    }
}

注意点

  1. continue 用在 while，do-while 中，continue 语句立即跳到循环首部，越过了当前循环的其余部分。
  2. continue 用在 for 循环中，跳到 for 循环的迭代因子部分。

带标签的 break 和 continue

  1. “标签” 是指后面跟一个冒号的标识符，例如：“ label: ” 。对于 Java 来说唯一用到标签的地方是在循环语句之前。
  2. 在循环之前设置标签的唯一理由：
  • 希望在其中嵌套另一个循环，由于 break 和 continue 关键字只中断当前循环，但若随同标签使用，它们就会中断到存在标签的地方。
  1. goto 关键字（太强大，易造成代码混乱）：goto 是 Java 的一个保留字，但并未得到正式使用，java 中没有 goto 语句。比如 goto B （可以直接跳到 B 代码块，goto A 同理）
  2. 当需要从内循环跳到外循环的情况时，就可用 标签 进行跳跃。

“标签”代码示例：打印 101-150 之间所有的质数

// 测试带标签的 break 和 continue
public class TestLabel {
    public static void main(String[] args) {
        // 打印 101-150 之间所有的质数
        // 设定名称为 outer 的标签
        outer:for (int i = 101;i < 150;i++){
            for (int j = 2;j < i/2;j++){
                if (i % j == 0){
                    // 如果能够被整除，就跳到上层的 outer 标签，继续执行下一次循环
                    continue outer;
                }
            }
            System.out.print(i + " ");
        }
    }
}

Java 流程控制语句至此结束

posted @ 2021-11-01 11:47  阿jun  阅读(340)  评论(0)    收藏  举报