美文网首页java互联网科技编程笔记
5-Java基础语法-流程控制之循环结构

5-Java基础语法-流程控制之循环结构

作者: 天涯明月笙 | 来源:发表于2018-07-31 20:23 被阅读97次

    循环结构

    顺序结构,从_上往下依次执行;选择结构,根据条件执行对应的内容

    为什么要使用循环结构?

    问题一:反复输入数字,判断输出对应是星期几。问题二:求1到100的累加和

    主要内容:

    while循环;do-while循环;for循环;循环嵌套;break语句;continue语句

    while 循环

    语法格式:

    while(循环条件){
  语句;
}

    如果循环体只有一条语句，大括号可以省略。为避免死循环,小括号后面不要加分号

    执行流程: 将小于5的整数打印输出。

    int n=1;
while(n<5){
  //輸出n的値
  n++;
}
    1. n的值必须先进行初始化
    2. 循环变量n的值必须被改变（死循环）

    执行流程分析:

    案例: 求1到5的累加和

    package cn.mtianyan.flow2;

public class PlusDemo {
    public static void main(String[] args) {
        // 求1到5的累加和
        // 1+2+3+4+5
        int n = 1;
        int sum = 0; //sum存放和变量
        while (n <=5 ){
            sum = sum +n;
            n++; // 这句不能少
        }
        System.out.println("sum="+sum);
    }
}

    执行过程:

    求1+3+5+7+...+15

    sum +=n;
n +=2; //替换n++ 可以实现跳值计算

    案例: 循环输出26个英文字母,分两行输出

    package cn.mtianyan.flow2;

public class CharDemo {
    public static void main(String[] args) {
        // 循环输出26个英文小写字母，分两行输出
        char ch = 'a';
        int count=1; // 13个字母时换行
        while (ch <= 'z'){
            System.out.print(ch+"");
            if(count%13 == 0){
                System.out.println();
            }
            count++;
            ch++;
        }
    }
}

    运行结果:

    编程练习

    使用while循环求1到5的平方和。效果图:

    任务

    1. 定义整型变量n作为循环变量，并初始化
    2. 定义整型变量sum存放和,并初始化
    3. 使用while循环求1到5的平方和
    4. 输出平方和
    package cn.mtianyan.flow2;

public class LoopDemo {
    public static void main(String[] args) {
        int n = 1;
        int sum = 0;
        while (n<=5){
            sum +=(n*n);
            n++;
        }
        System.out.println("1到5的平方和为:"+sum);
    }
}

    运行结果:

    do-while循环

    语法格式

    do{
语句;
} while(循环条件);

    注意事项: do-while循环至少执行一次；循环条件后的分号不能丢

    int n= 1;
do
{
  //輸出n的値
  n++;
} while(n< 5);

    局部变量使用前必须被初始化

    求1到5的累加和

    package cn.mtianyan.flow2;

public class DoWhileDemo {
    public static void main(String[] args) {
        // 求1到5的累加和
        int n=1;
        int sum=0;
        do {
            sum +=(n*n);
            n++;
        }while (n<=5);
        System.out.println("1到5的平方和为:"+sum);
    }
}

    运行结果:

    案例:猜字游戏

    猜字游戏。要求猜一个介于1到10之间的数字。然后将猜测的值与实际值进行比较,并给出提示,以便能更接近实际值,直到猜中为止。

    程序分析:

    1. 给定要猜测的数字
    2. 使用循环结构
    3. 循环进行的条件:猜测的数据和实际值不相等
    4. 循环体的内容:输入实际值,及进行判断
    5. 输出猜到的值
    package cn.mtianyan.flow2;

import java.util.Scanner;

public class GuessDemo {
    public static void main(String[] args) {
        // 设置要猜的数
        int number = 6;
        int guess;
        System.out.println("猜一个介于1到10之间的数");
        do {
            System.out.println("请输入您猜测的数:");
            Scanner scanner = new Scanner(System.in);
            guess = scanner.nextInt();
            if(guess >number){
                System.out.println("您猜大了");
            }else{
                System.out.println("您猜小了");
            }
        }while (number != guess);
        System.out.println("您猜中了!答案为: "+number);
    }
}

    运行结果:

    将要猜的数设为随机数:

    Math.random()得到[0,1)之间的随机数

    
         // Math.random()*10+1 表示[0,10)+1:[1,11)之间的随机数。强制类型转换int之后就是1-10了
        int number = (int) (Math.random()*10+1);

    for循环应用及局部变量作用范围

    int n=1;
while(n<5)
  //輸出n的値
  n++;

    for循环语法格式:

    for(表达式1;表达式2;表达式3)
{
  语句;
}

    for(int n=1;n<5;n++)
{
  //输出语句;
}

    分号不可省略，可以省略表达式1,2,3。

    使用for循环,求1到5的累加和。

    package cn.mtianyan.flow2;

public class ForDemo {
    public static void main(String[] args) {
        int sum=0;
        for (int n=1;n<=5;n++){
            sum +=n;
        }
        // System.out.println(n); // 局部变量的作用范围
        System.out.println("sum="+sum);
    }
}

    运行结果:

    int n= 1;在循环体中只执行一次

    局部变量，主方法中定义的都是局部变量。局部变量只在定义它的大括号内有效!

    for循环的注意事项

    三个表达式都是可以省略

    for(表达式1;表达式2;表达式3)
{
 语句;  
}

    将10以下的整数打印输出:

    package cn.mtianyan.flow2;

public class ForDemo1 {
    public static void main(String[] args) {
        for (int i=0;i<=10;i++){
            System.out.print(i+" ");
            // 循环结束时i值为11
        }
    }
}

    运行结果:

    省略表达式:

    package cn.mtianyan.flow2;

public class ForDemo1 {
    public static void main(String[] args) {
        int i=0;
        // for(;;){
        while(true){
            System.out.print(i+" ");
            // 循环结束时i值为11
            if(i>=10){
                break;
            }
            i++;
        }
    }
}

    循环输入数字1-10并输出,如果输入0则跳出循环:

    package cn.mtianyan.flow2;

import java.util.Scanner;

public class InputZeroBreak {
    public static void main(String[] args) {
        System.out.println("请输入你需要打印的数字，输入0时退出");
        Scanner scanner = new Scanner(System.in);
        int n;
        while(true){
            n = scanner.nextInt();
            if(n==0){
                System.out.println("接收到0输入，已退出");
                break;
            }
            System.out.println("n="+n);
        }
    }
}

    运行结果:

    package cn.mtianyan.flow2;

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

    运行结果:

    请注意记住执行顺序如下:

    编程练习

    编写一个程序,求出200到300之间的数,且满足条件:它们三个数字之积为42 ,三个数字之和为12。

    效果图:

    任务

    1. 循环遍历 200到300之间的整数
    2. 分别取出个位、十位和百位上的数
    3. 求三个数字的和与积
    4. 判断三个数字的积是否为42 ,三个数字的和是否为12 ,如果满足条件则输出该数
    package cn.mtianyan.flow2;

public class LoopDemoExercise {
    public static void main(String[] args) {
        for (int i=200;i<=300;i++){
            // 个位 十位 百位
            int hundreds = i / 100;
            int ten = (i-hundreds*100)/ 10;
            int single = i-hundreds*100-ten*10;

            if(hundreds*ten*single == 42 && (hundreds+ten+single)==12){
                System.out.println(i);
            }
        }
    }
}

    运行结果:

    嵌套的while循环应用

    while(循环条件)
{
  while(循环条件){
  }
}

    一个循环内部还有另外一个循环，二重循环；允许多层循环嵌套; 外层循环和内层循环。循环嵌套可以混搭。

    do{
  ......
  while(循环条件){
    ......
  }
}while(循环条件);

    for(表达式1;表达式2;表达式3)
{
  ......
  for(表达式1;表达式2;表达式3){
    ......
  }
  ......
}

    例: 使用嵌套while循环输出4行4列的星号

    package cn.mtianyan.flow2;

public class StarDemo {
    public static void main(String[] args) {
        int i=1; // 外重循环的循环变量
        int j=1; // 内重循环的循环变量
        System.out.println("输出4行4列的星号");
        while (i <= 4) {
            while (j <= 4) {
                System.out.print("*");
                j++;
            }
            System.out.println();
            i++;
        }
    }
}

    程序运行流程分析:

    可以看到内层的j执行完自己的第一轮之后，下次的i符合条件，j执行的轮中，i已经无法满足条件了。因此要在每一个大轮中重置内层的循环变量。

    package cn.mtianyan.flow2;

public class StarDemo {
    public static void main(String[] args) {
        int i=1; // 外重循环的循环变量
        int j; // 内重循环的循环变量
        System.out.println("输出4行10列的星号");
        // 外层控制有几行，内层控制每行有几列
        while (i <= 4) {
            j=1;
            while (j <= 10) {
                System.out.print("*");
                j++;
            }
            System.out.println();
            i++;
        }
    }
}

    运行结果:


    程序进阶: 输出三角形怎么处理?

    程序每行输出多少个是由内层控制的，因此对于内层进行改造。

    改为与外层联动n<=4 改为n<=m 第一次时输出一个星，输出两个星;

    while (j <= i)

    运行结果:

    package cn.mtianyan.flow2;

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

    运行结果:

    阶乘的累加和

    求1!+2!+3!+...+ 10!

    嵌套循环，外层循环进行和运算，内层进行阶乘运算。

    package cn.mtianyan.flow2;

public class FactorialDemo {
    public static void main(String[] args) {
        int s,sum=0;
        for (int i=1;i<=4;i++){
            s = 1; // s值每个循环内重新置1
            for (int j=1;j<=i;j++){
                 s = s*j; // s存放阶乘计算的结果
            }
            sum +=s;
        }
        System.out.println("1!+2!+3!+4!="+sum);
    }
}

    for (int i=1;i<=10;i++)

    for (int i=1;i<=50;i++)

    可以看到此时int已经装不下了，发生了溢出，因此我们该使用长整型。

     long s,sum=0;

    而长整型还无法容纳的数据。

    package cn.mtianyan.flow2;

import java.math.BigInteger;

public class FactorialDemo {
    public static void main(String[] args) {
        BigInteger sum = new BigInteger("1");
        BigInteger s;
        for (int i=1;i<=50;i++){
            s = new BigInteger("1"); // s值每个循环内重新置1
            for (int j=1;j<=i;j++){
                BigInteger num = new BigInteger(String.valueOf(j));
                s = s.multiply(num);
            }
            sum = sum.add(s);
        }
        System.out.println("1!+2!+3!+50!="+sum);
    }
}

    编程练习

    用星号输出一个梯形,如下图所示: ( 使用嵌套for循环完成)

    任务:

    1. 外重循环控制输出行数
    2. 第一个内重循环控制输出的空格数,依次递减

    注意:由于星号和空格在屏幕上所占的空间不同,所以可以适当调整空格的输出,比如毎次
    循环都输出两个空格.这样输出来的图形会更加接近梯形

    1. 第二个内重循环控制毎行输出的星号数
    2. 输出完一行的星号和空格后换行
    package cn.mtianyan.flow2;

public class StarDemoExercise {
    public static void main(String[] args) {
        // 输出五行
        for(int i=1;i<=5;i++){

            for (int j=4;i<=j;j--){
                System.out.print("-");
            }
            for (int j=1;j<=i+1;j++){
                System.out.print("*");
            }
            for (int j=1;j<=i;j++){
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

    这里分为三部分画出。

    package cn.mtianyan.flow2;

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

    分两部分画出，则需要看出行号和该行星星之间的关系。

    break语句

    break语句可以结束当前循环的执行

    执行完break语句后,循环体中位于break语句后面的语句就不会被执行

    在多重循环中, break语句只向外跳一层

    public static void main(String[]args){
  Scanner sc=new Scanner(System.in);
  int n;
  while(true){
      n= sc.nextInt();
      if(n == 0)break;
      System.out.println(n);
  }
}

    多重循环:

    public static void main(String[] args){
    int k = 0;
    for(int i=1;i<5;i++){
        for(int j=1;j<5;j++){
            k=i+j;
            if(j==3)break;
        }
    }
    System.out.println("k="+k);
}

    注意写表查看值得变化情况，脑补脑力不足很费劲。

    break语句的使用;break语句的作用:跳出当前循环结构;break语句一旦被执行, 循环体中break语句后面的代码将不再被执行

    注意: break语句是跳出当前循环.只跳出了内层循环，不会影响到外层循环的继续执行

    continue语句

    continue语句只能用在循环里

    continue语句可以结束当前循环的执行,但是要继续下一次循环的执行

    求1+3+5+7+9

    public static void main(String[] args){
    int sum=0;
    for(int i=1;i<=9;i++){
        if( i%2 == 0)continue;
        sum =sum+i;
    }
    System.out.println("sum="+sum);
}

    循环变量每次加2就可以实现。使用continue语句的情况如下

    public static void main(String[] args){
    int sum=0;
    for(int i=1;i<=9;i++){
        if(i%2 == 0)continue; // 偶数不加进sum
        sum=sum+i;
    }
    System.out.println("sum="+sum);
}

    双重循环问题:

        public static void main(String[] args){
        int k=0;
        for(int i=1;i<=5;i++){
            for(int j=1; j<5; j++){
                if(j%2 == 0)continue;
                k=k+j;
            }
        }
        System.out.println("k="+k);
    }

    自己分析输出结果:

    只能在循环体内和switch语句体内使用break；

    程序Debug

    调试的作用:
    让程序员能看清程序每一步的效果,在需要查看结果的时候,使用debug查看实际结果是否与预期结果一致。

    阶乘中s=1;的重置操作很容易遗漏。调试例子(1到5的累加和)

    package cn.mtianyan.flow2;

public class ForDemo {
    public static void main(String[] args) {
        int sum=0;
        for (int n=1;n<=5;n++){
            sum +=n;
        }
        System.out.println("sum="+sum);
    }
}

    断点，让程序停到这

    设置断点，让程序停在这。此时开始运行调试。

    右键点debug，而不是run。

    然后我们开始单步调试。

    step over 是单步调试， Step into 是进入函数内部，使用step over可以看到sum 和 n 一直在变化。

    Debug多断点调试

    多个断点时从当前断点之间执行完，跳到下个断点停住。注意: 对于for循环来说，一个断点可以当做循环次数个断点，直到循环结束，才会到下一个断点。

    快捷键，各个平台不一样，自己根据英文名来找自己的快捷键。

    流程控制总结

    流程控制语句:顺序、选择、循环

    选择语句

    • if语句
    • if-else语句
    • 多重if-else语句
    • 嵌套if-else语句
    • switch语句(常量表达式，整型字符型)

    循环结构

    • while循环
    • do-while循环
    • for循环
    • 嵌套循环（任意的组）
    • break语句和continue语句(break使用在switch和循环结构当中，continue语句只能使用在循环结构当中)

    break是结束当前循环的执行，continue是结束当前循环的执行，会继续下一次循环执行。多重循环这两个都只跳出一层。

    如何进行调试? 单步 继续执行到下个断点

    如何存储相同数据类型的多个数据呢?数组将为我们解决这个问题。
    在下集中,将为大家带来一维数组的使用,增强型for循环,以及冒泡排序!

    相关文章

      网友评论

      • 知识学者:循环，递归是最不好理解的。。
        天涯明月笙:@东风冷雪 😂循环还行吧，总说递归符合人的思维，但是我也觉得他不如递推好理解

      本文标题：5-Java基础语法-流程控制之循环结构

      本文链接：https://www.haomeiwen.com/subject/dazxvftx.html

      延伸阅读

      深度阅读

      • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

      栏目导航

      热点阅读

      java

      互联网科技

      编程笔记

      程序员

      关于我们|服务条款|联系我们|5-Java基础语法-流程控制之循环结构|投稿指南|网站地图|RSS订阅|排版工具|手机版

      提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

      Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

      备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

      本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

      所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！