Java 控制语句-循环结构

Link_Zero

已于 2024-03-14 21:32:02 修改

阅读量1.7k

点赞数 39

分类专栏： Java入门文章标签： java 开发语言后端

于 2024-03-14 07:00:00 首次发布

本文链接：https://blog.csdn.net/m0_48205251/article/details/136690430

版权

Java入门专栏收录该内容

63 篇文章 0 订阅

订阅专栏

break 语句和 continue 语句

break 语句

continue 语句

带标签的 break 语句和 continue 语句

循环结构

循环结构分两大类，一类是当型，一类是直到型。

当型：
当布尔表达式条件为 true 时，反复执行某语句，当布尔表达式的值为 false 时才停止循环，比如：while 与 for 循环。
直到型：
先执行某语句，再判断布尔表达式，如果为 true，再执行某语句，如此反复，直到布尔表达式条件为 false 时才停止循环，比如 do-while 循环。

while 循环

语法结构：

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

在循环刚开始时，会计算一次“布尔表达式”的值，若条件为真，执行循环体。而对于后来每一次额外的循环，都会在开始前重新计算一次。

语句中应有使循环趋向于结束的语句，否则会出现无限循环–––"死"循环。

while 循环结构：求 1 到 100 之间的累加和

public class Test02 {
    public static void main(String[] args) {
        int i = 0;
        int sum = 0;
        // 1+2+3+…+100=?
        while (i <= 100) {
            sum += i;//相当于 sum = sum+i;
            i++;
        }
        System.out.println("Sum= " + sum);
    }
}

执行结果：

do-while 循环

语法结构：

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

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

do-while 循环结构：求 1-100 之间的累加和

public class Test02 {
    public static void main(String[] args) {
        int i = 0;
        int sum = 0;
        do {
            sum += i; // sum = sum + i
            i++;
        } while (i <= 100);//此处的；不能省略
        System.out.println("Sum= " + sum);
    }
}

while 与 do-while 的区别

public class Test02 {
    public static void main(String[] args) {
        //while 循环：先判断再执行
        int a = 0;
        while (a < 0) {
            System.out.println(a);
            a++;
        }
        System.out.println("-----");
        //do-while 循环：先执行再判断
        a = 0;
        do {
            System.out.println(a);
            a++;
        } while (a < 0);
    }
}

执行结果：

从运行效图中可以看出 do-while 总是保证循环体至少会被执行一次！

for 循环

语法结构：

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

for 循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构。for 循环在第一次反复之前要进行初始化，即执行初始表达式；随后，对布尔表达式进行判定，若判定结果为 true，则执行循环体，否则，终止循环；最后在每一次反复的时候，进行某种形式的“步进”，即执行迭代因子。

初始化部分设置循环变量的初值
条件判断部分为任意布尔表达式
迭代因子控制循环变量的增减

for 循环在执行条件判定后，先执行的循环体部分，再执行步进

public class Test02 {
    public static void main(String[] args) {
        int sum = 0;
        //1.求 1-100 之间的累加和
        for (int i = 0; i <= 100; i++) {
            sum += i;
        }
        System.out.println("Sum= " + sum);
        //2.循环输出 9-1 之间的数
        for(int i=9;i>0;i--){
            System.out.print(i+"、");
        }
        System.out.println();
        //3.输出 90-1 之间能被 3 整除的数
        for(int i=90;i>0;i-=3){
            System.out.print(i+"、");
        }
        System.out.println();
    }
}

执行结果：

Java 里能用到逗号运算符的地方屈指可数，其中一处就是 for 循环的控制表达式。在控制表达式的初始化和步进控制部分，我们可以使用一系列由逗号分隔的表达式，而且那些表达式均会独立执行。

逗号运算符

public class Test02 {
    public static void main(String[] args) {
        for(int i = 1, j = i + 10; i < 5; i++, j = i * 2) {
            System.out.println("i= " + i + " j= " + j);
        }
    }
}

执行结果：

无论在初始化还是在步进部分，语句都是顺序执行的。
尽管初始化部分可设置任意数量的定义，但都属于同一类型。
约定:只在 for 语句的控制表达式中写入与循环变量初始化，条件判断和迭代因子相关的表达式。

初始化部分、条件判断部分和迭代因子可以为空语句，但必须以“;”分开

无限循环

public class Test02 {
    public static void main(String[] args) {
        for ( ; ; ) { // 无限循环: 相当于 while(true)
            System.out.println("北京尚学堂");
        }
    }
}

编译器将 while(true)与 for(;;)看作同一回事，都指的是无限循环。

在 for 语句的初始化部分声明的变量，其作用域为整个 for 循环体，不能在循环外部使用该变量

初始化变量的作用域

public class Test02 {
    public static void main(String[] args) {
        for(int i = 1; i < 10; i++) {
            System.out.println(i+"、");
        }
        //编译错误，无法访问在 for 循环中定义的变量 i
        System.out.println(i);
    }
}

嵌套循环

在一个循环语句内部再嵌套一个或多个循环，称为嵌套循环。while、do-while 与 for 循环可以任意嵌套多层。

public class Test02 {
    public static void main(String[] args) {
        for (int i=1; i <=5; i++) {
            for(int j=1; j<=5; j++){
                System.out.print(i+" ");
            }
            System.out.println();
        }
    }
}

执行结果：

使用嵌套循环实现九九乘法表

public class Test02 {
    public static void main(String[] args) {
        for (int i = 1; i < 10; i++) { // i 是一个乘数
            for (int j = 1; j <= i; j++) { // j 是另一个乘数
                System.out.print(j + "*" + i + "=" + (i * j < 10 ? (" " + i * j) : i * j) + " ");
            }
            System.out.println();
        }
    }
}

break 语句和 continue 语句

在任何循环语句的主体部分，均可用 break 控制循环的流程。break 用于强行退出循环，不执行循环中剩余的语句。

break 语句

//产生 100 以内的随机数，直到随机数为 88 时终止循环
public class Test02 {
    public static void main(String[] args) {
        int total = 0;//定义计数器
        System.out.println("Begin");
        while (true) {
            total++;//每循环一次计数器加 1
            int i = (int) Math.round(100 * Math.random());
            //当 i 等于 88 时，退出循环
            if (i == 88) {
                break;
            }
        }
        //输出循环的次数
        System.out.println("Game over， used " + total + " times.");
    }
}

continue 语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。

continue 用在 while，do-while 中，continue 语句立刻跳到循环首部，越过了当前循环的其余部分。

continue 用在 for 循环中，跳到 for 循环的迭代因子部分。

continue 语句

//把 100~150 之间不能被 3 整除的数输出，并且每行输出 5 个
public class Test02 {
    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++;//没输出一个数，计数器加 1
            //根据计数器判断每行是否已经输出了 5 个数
            if (count % 5 == 0) {
                System.out.println();
            }
        }
    }
}

带标签的 break 语句和 continue 语句

goto 关键字很早就在程序设计语言中出现。尽管 goto 仍是 Java 的一个保留字，但并未在 Java 语言中得到正式使用；Java 没有 goto 语句。然而，在 break 和 continue 这两个关键字的身上，我们仍然能看出一些 goto 的影子---带标签的 break 和 continue。

“标签”是指后面跟一个冒号的标识符，例如：“label:”。对 Java 来说唯一用到标签的地方是在循环语句之前。而在循环之前设置标签的唯一理由是：我们希望在其中嵌套另一个循环，由于 break 和 continue 关键字通常只中断当前循环，但若随同标签使用，它们就会中断到存在标签的地方。

在 “goto 有害”论中，最有问题的就是标签，而非 goto，随着标签在一个程序里数量的增多，产生错误的机会也越来越多。但 Java 标签不会造成这方面的问题，因为它们的活动场所已被限死，不可通过特别的方式到处传递程序的控制权。由此也引出了一个有趣的问题：通过限制语句的能力，反而能使一项语言特性更加有用。

//控制嵌套循环跳转(打印 101-150 之间所有的质数)
public class Test02 {
    public static void main(String[] args) {
        outer: for (int i = 101; i < 150; i++) {
            for (int j = 2; j < i / 2; j++) {
                if (i % j == 0) {
                    continue outer;
                }
            }
                System.out.print(i + " ");
            }
    }
}