控制语句 - 循环结构

返回目录

while语句

• • while循环结构：当类循环，先判断后执行，当符合条件则执行循环，如果不符合条件则跳出循环。循环语句中应有使循环趋向于结束的语句，否则会出现无限循环–––"死"循环。

    // while格式
    while(布尔表达式){ //当满足条件执行循环
      循环语句;
    }
    
    // 求 1+2+3+4+5...+100 的和，使用暴力算法累加计算
    public class test {
      public static void main(String[] args) {
        int a = 1; //开始的值
        int sum = 0; //sum变量代表和
        while(a<=100) { //判断a<=100是否为true，符合执行循环
          sum = sum+a; //计算和，第一次sum=0+1; 第二次sum=1+2; 第三次sum=3+3.....加到100后求最终和
          a++; //a自增1，用来计数
        }
        System.out.println(sum);
      }
    }
      
    // 解读循环步骤
        //第一次循环
        while(a<=100) { //此时a=1，符合条件继续循环
          sum = sum+a; //此时sum=0 加上 a=1
          a++;
        }
        // 第二次循环
        while(a<=100) { //此时a=2，符合条件继续循环
          sum = sum+a; //此时sum=1 加上 a=2
          a++; //此时a=2然后自增为3
        }
        //第三次循环
        while(a<=100) { //此时a=3，符合条件继续循环
          sum = sum+a; //此时sum=3 加上 a=3
          a++; //此时a=3然后自增为4
        }
        //第四次循环
        while(a<=100) { //此时a=4，符合条件继续循环
          sum = sum+a; //此时sum=6 加上 a=4
          a++; //此时a=4然后自增为5
        }

  • do-while循环结构：当类循环，先执行后判断，先执行一次循环，当符合条件则继续执行循环，如果不符合条件则跳出循环。

    // do-while格式格式
    do{ //先执行一次循环
      循环语句;
    }while(布尔表达式); //再判断，符合条件则继续循环，否则跳出循环
    
    // 求 1+2+3+4+5...+100 的和，使用暴力算法累加计算
    public class test {
      public static void main(String[] args) {
        int a = 1; //开始的值
        int sum = 0; //sum变量代表和
        do { //先执行一次
          sum += a; //sum = sum+a
          a++;
        } while (a<=100); //再判断
        System.out.println(sum);
      }
    }
    

for语句

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

    // for循环格式
    for (初始化表达式,初始化表达式2; 布尔表达式; 迭代因子,迭代因子2){
      循环语句;
    }
     
    // 求 1+2+3+4+5...+100 的和，使用暴力算法累加计算
    public class test {
      public static void main(String[] args) {
        int sum = 0; //sum变量代表和
        // 先执行初始化表达式int a=1；执行后进行判断a<=100；判断后进行循环；循环后迭代因子自增计数
        for(int a=1; a<=100; a++) {
          sum += a; //计算和
        }
        System.out.println(a); // 报错，for循环中的变量，只能在for循环中使用
        System.out.println(sum);
      }
    }

嵌套循环

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

    // 输出99乘法表
    public class test {
      public static void main(String[] args) {
        for(int a=1; a<=9; a++) {
          for(int b=1; b<=a; b++) {
            System.out.print(b + "*" + a + "=" + b*a + "\t");
        }
        System.out.println();
        }
      }
    }
     
    // 解读循环步骤
        // 第一层for，第一次循环
        for(int a=1; a<=9; a++) { //a=1，a<=9符合条件，进行循环
          // 第二层for，第一次循环
          for(int b=1; b<=a; b++) { //b=1，(b=1)<=(a=1)符合条件，进行循环
            System.out.print(b + "*" + a + "=" + b*a + "\t"); //输出1*1=1+\t制表符
          } //b自增
          // 第二层for，第二次循环
          for(int b=1; b<=a; b++) { //b=2，(b=2)<=(a=1)不符合条件，跳出循环
            System.out.print(b + "*" + a + "=" + b*a + "\t"); //不执行
          } //跳出循环，b=1
          System.out.println(); //输出空行
        }
        
        // 第一层for，第二次循环
        for(int a=1; a<=9; a++) { //a=2，a<=9符合条件，进行循环
          // 第二层for，第一次循环
          for(int b=1; b<=a; b++) { //b=1，(b=1)<=(a=2)符合条件，进行循环
            System.out.print(b + "*" + a + "=" + b*a + "\t"); //输出1*2=2+\t制表符
          } //b自增
          // 第二层for，第二次循环
          for(int b=1; b<=a; b++) { //b=2，(b=2)<=(a=2)符合条件，进行循环
            System.out.print(b + "*" + a + "=" + b*a + "\t"); //输出2*2=4+\t制表符
          } //b自增
          // 第二层for，第三次循环
          for(int b=1; b<=a; b++) { //b=3，(b=3)<=(a=2)不符合条件，跳出循环
            System.out.print(b + "*" + a + "=" + b*a + "\t"); //不执行
          } //跳出循环，b=1
          System.out.println(); //输出空行
        }
    

break和continue语句

• • break语句：在任何循环语句的主体部分，均可用break控制循环的流程，break用于强行退出循环，不执行循环中剩余的语句。
  • continue语句：continue用在while，do-while中，continue 语句立刻跳到循环首部，越过了当前循环的其余部分；在for循环中，跳到for循环的迭代因子部分。

    public class test {
      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 + "\t");
          count++; //没输出一个数，计数器加1
          // 根据计数器判断每行是否已经输出了10个数
          if (count % 10 == 0) {
          	break; //输出达到10个数结束循环
          }
        }
      }
    }

  • 带标签的break语句：类似goto，强行退出循环，不执行循环中剩余的语句。
  • 带标签的continue语句：类似goto，跳过本次循环，跳到指定标签位置。

    public class test {
        public static void main(String args[]) {
            // 打印101-150之间所有的质数
        	outer: for (int i = 101; i < 150; i++) {
                for (int j = 2; j < i / 2; j++) {
                    if (i % j == 0){
                        continue outer; //跳过本次循环，跳到outer标签位置
                    }
                }
                System.out.print(i + "  ");
            }
        }
    }