【JavaSE】-4-循环结构

news/2024/6/23 20:33:37

循环结构
循环结构是三大流程控制结构的最后一种,相比于顺序结构和分支结构,循环结构略复杂一些。
前面课程中已经说过,循环结构的特点是能够重复的执行某些代码。
循环结构的基本概念:
循环体:重复执行的代码称为循环体。可以是一条或者多条语句。
循环条件:循环体反复执行的判断条件。一般是关系表达式或者逻辑表达式。
循环结构的特征有2点:

  1. 重复执行某些代码。----具有循环体
  2. 有明确的开始和结束。----具有循环的初始状态、循环条件以及循环的控制语句
    循环的初始状态:即循环的起始状态,简单说就是循环开始的时候什么样?
    循环条件:循环体反复执行的判断条件。简单说就是判断循环是否能一直执行下去。
    循环控制语句:循环执行中每次变化的内容,简单说就是控制循环是否执行下去。
    为什么要使用循环?
  3. 需求:打印10遍"Hello World"。
  4. 代码:
    如果打印1000遍,打印1亿遍呢?代码怎么写?
  5. 需求:计算1+2+3+4+5的和。
  6. 代码:
public static void main(String[] args) {
System.out.println("Hello World");
System.out.println("Hello World");
System.out.println("Hello World");
System.out.println("Hello World");
System.out.println("Hello World");
System.out.println("Hello World");
System.out.println("Hello World");
System.out.println("Hello World");
System.out.println("Hello World");
System.out.println("Hello World");
}
public static void main(String[] args) {
int sum = 0;
sum = 1 + 2 + 3 + 4 + 5;
System.out.println(sum);
}

如果计算1+2+3+…+99+100的和,代码怎么写?
如果计算1+2+3+…+100000000的和,代码又该怎么写?

  1. 需求:100以内的质数有几个?分别是谁?
  2. 代码怎么写?

    循环结构特别适合解决这种大规模计算或执行代码雷同的场景。
    Java中一共提供了3种实现循环的语法,分别是:
  3. for循环
  4. while循环
  5. do…while循环
    for循环
    for循环是Java中最常用的循环。适用于知道循环次数的场景。
    for循环的语法格式
    for循环的执行流程
  6. 首先执行表达式1,表达式1通常写循环的初始化内容,即循环的初始状态。表达式1只会执行一
    次。
  7. 判断表达式2的真假。表达式2是循环的判断条件,表达式2的值为true,执行循环体,如果表达式2
    的值为false,则结束循环,执行循环之外的代码。
    for(表达式1;表达式2;表达式3){
    循环体;
    }
  8. 循环体执行完毕之后,执行表达式3。表达式3是循环的控制条件,这个条件可以影响循环的次数。
  9. 表达式3执行完毕之后,回到步骤2继续判断。
    表达式2的结果为false时,循环会结束。
    for循环的示例
    for循环示例1
  10. 需求:通过for循环打印10遍"Hello World"
  11. 代码:
    for循环的循环体一般来说比较容易理解,也比较容易找出来。在我们这个题中,循环体就是
    System.out.println(“Hello World”);
    for循环的表达式1,表达式2,表达式3是配合使用的。三者共同控制循环的执行次数。表达式1用
    于指定初始条件,表达式2是一个boolean值,用于判断循环是否继续进行,表达式3往往是循环的
    增量,用于逼近判断条件。
    一定要深入理解循环的执行流程,理解表达式1、表达式2、表达式3的关系,如何让3个表达式配
    合达到我们的目的。—打印10遍Hello World的变种写法。
    断点调试
    断点调试是开发中常用的调试技巧之一。
    所谓的断点调试,指的是在程序的某个位置打上断点,程序在运行的过程中就会停在断点处,等待我们
    进行下一步的操作。
    添加断点、移除断点
    在代码行号的左侧,双击鼠标左键,即可添加上断点;再次双击鼠标左键,即可移除断点。
    可以添加多少断点?
    理论上来讲,每一行都可以添加断点。实际上我们只在关键代码处添加断点。
    何为关键代码处?
    1.复杂业务逻辑代码的开头位置
    2.for循环的开始处
    3.容易出现错误的代码处。
    public static void main(String[] args) {
    //需求:通过for循环打印10遍"Hello World"
    //分析:
    // 1.由题意可知循环次数是10次。
    // 2.循环体是 打印 Hello World
    for(int i = 0; i < 10; i++) {
    System.out.println(“Hello World”);
    }
    }
    如何调试代码
    Step Over:执行一行代码。
    Step Into:进入代码内部(如果当前行是一个函数,会跳入到函数内部,如果只是一行普通代码,功能
    和step over一样)。
    Step Return:与Step Into配套使用,用于跳出Step Into进入的函数。
    Resume:结束当前断点,跳到下个断点位置。
    断点调试有什么用?
    断点调试就像电影的慢镜头一样,能让你看到每一步是怎么执行的。能看到每一步执行后,程序中的数
    据发生了什么样的变化。例如:变量值的更新。
    断点调试总结
    断点调试是开发项目必须具备的技能。
    一定要学会添加、删除断点,学会看断点下各个变量的变化。
    for循环示例2:
  12. 需求:打印1~100之间(含1和100)所有的整数。
  13. 代码:
    或者
    或者
    public static void main(String[] args) {
    //需求:打印1~100之间(含1和100)所有的整数。
    //分析:
    // 1.循环次数101次。
    // 2.循环体:打印一个整数(1~100之间)。
    for(int i = 1; i <= 100; i++) {
    System.out.println(i);
    }
    }
    public static void main(String[] args) {
    //需求:打印1~100之间(含1和100)所有的整数。
    //分析:
    // 1.循环次数101次。
    // 2.循环体:打印一个整数(1~100之间)。
    for(int i = 16; i <= 115; i++) {
    System.out.println(i-15);
    }
    }
    通过上述的案例,你会发现同样的需求,可以使用不同的方法来实现。
    在这个案例中,你要学会表达式1、表达式2、表达式3如何配合使用。—本质上是控制循环次数。
    for循环示例3:
  14. 需求:打印出来100以内所有的奇数。
  15. 代码:
    虽然打印的是奇数,但是循环的次数是101次。只不过对于每个数做了一次判断,是奇数才打印。
    整体的循环次数并没有减少。
    或者
    通过这个案例你会发现:表达式1,表达式2,表达式3是配合使用的,为的是控制循环次数。
    如何打印100以内所有的偶数?
    public static void main(String[] args) {
    //需求:打印1~100之间(含1和100)所有的整数。
    //分析:
    // 1.循环次数101次。
    // 2.循环体:打印一个整数(1~100之间)。
    for(int i = 100; i >= 1; i–) {
    System.out.println(101 - i);
    }
    }
    public static void main(String[] args) {
    //需求:打印出来100以内所有的奇数。
    //分析:
    // 1.循环次数101次。
    // 2.循环体:打印一个奇数。—需要判断当前数是不是奇数,是就打印,不是就不打印。
    for(int i = 0; i <= 100; i++) {
    if(i % 2 == 1) {
    System.out.println(i);
    }
    }
    }
    public static void main(String[] args) {
    //需求:打印出来100以内所有的奇数。
    //分析:
    // 1.循环次数50次。
    // 2.循环体:打印一个奇数。—起始值设置为1,增量设置为2。
    for(int i = 1; i < 100; i += 2) {
    System.out.println(i);
    }
    }
    for循环示例4:
  16. 需求:求1+2+3+…+9+10的和。
  17. 代码:
    打印1~100的和怎么写?
    打印1~1000000的和怎么写?
    for循环示例5:
  18. 需求:求100以内所有奇数的和。
  19. 代码:
    或者
    求100以内偶数的和怎么写?
    public static void main(String[] args) {
    //需求:求1+2+3+…+9+10的和。
    //分析:
    // 1.要有一个变量保存和。假定是sum
    // 2.循环次数11次。
    // 3.循环体:把数加到sum中去。
    int sum = 0;
    for(int i = 1; i <= 10; i++) {
    sum += i;
    }
    System.out.println(sum);
    }
    public static void main(String[] args) {
    //需求:求100以内所有奇数的和。
    int sum = 0;
    for(int i = 1; i < 100; i++) {
    if(i % 2 == 1) {
    sum += i;
    }
    }
    System.out.println(sum);
    }
    public static void main(String[] args) {
    //需求:求100以内所有奇数的和。
    int sum = 0;
    for(int i = 1; i < 100; i+=2) {
    sum += i;
    }
    System.out.println(sum);
    }
    for循环示例6:
  20. 需求:在控制台打印出所有的水仙花数。水仙花数:是一个三位数,水仙花数的个位、十位、百位
    数字的立方之和等于原数。
  21. 代码:
    for循环示例7:
  22. 需求:统计水仙花一共有多少个。水仙花数:是一个三位数,水仙花数的个位、十位、百位数字的
    立方之和等于原数。
  23. 代码:
    for循环示例8:
  24. 需求:数7游戏。从1到100(不含100),如果数是7的倍数或者包含7输出“过”,否则输出数字本
    身。
  25. 代码:
    public static void main(String[] args) {
    //需求:在控制台打印出所有的水仙花数。水仙花数:是一个三位数,水仙花数的个位、十
    位、百位数字的立方之和等于原数。
    //判断从 100到999哪个是水仙花数,所以循环从100到999。
    //找出数字的 个位、十位、百位分别是什么,再判断立方和是不是等于原数。
    for(int i = 100; i < 1000; i++) {
    int gw = i % 10;
    int sw = i / 10 % 10;
    int bw = i / 100;
    if(gw * gw * gw + sw * sw * sw + bw * bw * bw == i) {
    System.out.println(i);
    }
    }
    }
    public static void main(String[] args) {
    //需求:统计水仙花一共有多少个。水仙花数:是一个三位数,水仙花数的个位、十位、百位
    数字的立方之和等于原数。
    //定义一个变量count记录水仙花的个数。判断从 100到999哪个是水仙花数,所以循环从
    100到999。
    //找出数字的 个位、十位、百位分别是什么,再判断立方和是不是等于原数。
    //一旦某个数是水仙花数,就让count++.
    int count = 0;
    for(int i = 100; i < 1000; i++) {
    int gw = i % 10;
    int sw = i / 10 % 10;
    int bw = i / 100;
    if(gw * gw * gw + sw * sw * sw + bw * bw * bw == i) {
    System.out.println(i);
    count++;
    }
    }
    System.out.println(“一共有” + count + “个水仙花数。”);
    }
    随机数
    在Java中使用Random类来产生随机数。具体使用步骤如下:
  26. 导包。----import java.util.Random;//快捷键:Ctrl + Shift + O
  27. 创建Random对象。Random random = new Random();
  28. 获取随机数。int num = random.nextInt(10);-----[0,10)
    随机数案例:
  29. 需求:产生1个取值范围在[0,50)的随机数。
  30. 代码:
  31. 需求:产生1个取值范围在[5,18)的随机数。
  32. 代码:
  33. 需求:产生1个取值范围在[23,41]的随机数。
  34. 代码:
    public static void main(String[] args) {
    //需求:数7游戏。从1到100(不含100),如果数是7的倍数或者包含7输出“过”,否则输
    出数字本身。
    for(int i = 1; i < 100; i++) {
    if(i % 7 == 0 || (i % 10 == 7 || i / 10 == 7)) {
    System.out.print("过 ");
    }else {
    System.out.print(i + " ");
    }
    }
    }
    public static void main(String[] args) {
    //需求:产生1个取值范围在[0,50)的随机数。
    Random random = new Random();
    int num = random.nextInt(50);
    System.out.println(num);
    }
    public static void main(String[] args) {
    //需求:产生1个取值范围在[5,18)的随机数。
    //思路:
    //1.产生一个[0,13)的随机数
    //2.在上述记过的基础上+5
    Random random = new Random();
    int num = random.nextInt(13) + 5;
    System.out.println(num);
    }
    随机数的规律:要想产生一个[min, max]之间的随机数。
    int num = random.nextInt(max - min + 1) + min;
    for循环案例9:
  35. 需求:产生5个[10, 80]之间的随机数,并输出产生的数。
  36. 代码:
    for循环案例10:
  37. 需求:产生5个[10, 80]之间的随机数,输出产生的数,并求出最大的随机数。
  38. 代码:
    public static void main(String[] args) {
    //需求:产生1个取值范围在[23,41]的随机数。
    //思路:
    //1.产生一个[0,19)的随机数
    //2.在上述记过的基础上+23
    Random random = new Random();
    int num = random.nextInt(19) + 23;
    System.out.println(num);
    }
    public static void main(String[] args) {
    //需求:产生5个[10, 80]之间的随机数,并输出产生的数。
    //思路:循环5次,每次产生一个随机数并打印随机数。
    //先创建Random对象
    Random random = new Random();
    for(int i = 0; i < 5; i++) {
    int num = random.nextInt(80 - 10 + 1) + 10;
    System.out.print(num + " ");
    }
    }
    public static void main(String[] args) {
    //需求:产生5个[10, 80]之间的随机数,输出产生的数,并求出最大的随机数。
    //思路:
    //1.定义一个变量max保存最大的数。
    //2.循环5次,每次产生一个随机数并打印随机数。
    //3.在每次循环中,判断随机产生的数和max谁大,如果随机产生的数大,把max的值更新为
    随机产生的数。
    //先创建Random对象
    Random random = new Random();
    //定义一个变量保存最大的数
    int max = 0;
    for(int i = 0; i < 5; i++) {
    int num = random.nextInt(80 - 10 + 1) + 10;
    System.out.print(num + " ");
    if(num > max) {
    max = num;
    }
    }
    System.out.println("max = " + max);
    for循环案例11:
  39. 需求:随机产生5个[10, 80]之间的随机数,输出产生的数,并求出最小的数。
  40. 代码:
    for循环案例12:
  41. 需求:产生5个[10, 80]之间的随机数,输出产生的数,并求出最大的随机数以及最大随机数的下标
    (即:第几个数最大,假定下标从0开始)。
  42. 代码:
    }
    public static void main(String[] args) {
    //需求:随机产生5个[10, 80]之间的随机数,输出产生的数,并求出最小的数。
    //思路:
    //1.定义一个变量min保存最小的数。
    //2.循环5次,每次产生一个随机数并打印随机数。
    //3.在每次循环中,判断随机产生的数和min谁小,如果随机产生的数小,把min的值更新为
    随机产生的数。
    //先创建Random对象
    Random random = new Random();
    //定义一个变量保存最小的数
    int min = 80;
    for(int i = 0; i < 5; i++) {
    int num = random.nextInt(80 - 10 + 1) + 10;
    System.out.print(num + " ");
    if(num < min) {
    min = num;
    }
    }
    System.out.println("min = " + min);
    }
    public static void main(String[] args) {
    //需求:产生5个[10, 80]之间的随机数,输出产生的数,并求出最大的随机数以及最大随
    机数的下标(即:第几个数最大,假定下标从0开始)。
    //思路:
    //1.定义一个变量max保存最大的数。
    //2.定义一个变量index保存最大随机数的下标。
    //3.循环5次,每次产生一个随机数并打印随机数。
    //4.在每次循环中,判断随机产生的数和max谁大,如果随机产生的数大,把max的值更新为
    随机产生的数,同时更新index的值。
    //先创建Random对象
    Random random = new Random();
    //定义一个变量保存最大的数
    int max = 0;
    //定义一个变量保存最大数的下标
    int index = 0;
    for(int i = 0; i < 5; i++) {
    int num = random.nextInt(80 - 10 + 1) + 10;
    System.out.print(num + " ");
    if(num > max) {
    for循环案例13:
  43. 需求:产生5个[10,20]之间的随机数,输出产生的数,并计算随机数的和以及平均值。
  44. 代码:
    for循环总结
    for循环是最常用的循环,开发中几乎90%左右的循环都是for循环,for使用场景是明确知道循环次数的
    情形。
    while循环
    while是Java中第二常用的循环。while循环能实现for循环全部的功能,即:while循环可以替代for循
    环。除此以外,while循环还适用于不知道具体循环次数的循环(只知道循环结束条件,但不清楚循环
    多少次结束。)。
    while循环最大的特点:适用于不知道循环次数的循环。
    在开发中,如果知道循环次数,往往使用for循环(因为for循环的格式比较简洁,书写比较方
    便),只有不知道循环次数的时候,才使用while循环。
    max = num;
    index = i;
    }
    }
    System.out.println("max = " + max + ", index = " + index);
    }
    public static void main(String[] args) {
    //需求:产生5个[10, 20]之间的随机数,输出产生的数,并计算随机数的和以及平均值。
    //思路:
    //1.定义一个变量sum保存随机数的和。
    //2.定义一个变量avg保存随机数的平均数。
    //3.循环5次,每次产生一个随机数并打印随机数,将随机数的值加到sum中。
    //4.通过sum求avg
    //先创建Random对象
    Random random = new Random();
    //定义一个变量保存随机数的和。
    int sum = 0;
    //定义一个变量保存随机数的平均值。
    double avg = 0;
    for(int i = 0; i < 5; i++) {
    int num = random.nextInt(20 - 10 + 1) + 10;
    System.out.print(num + " ");
    sum += num;
    }
    avg = 1.0 * sum / 5;
    System.out.println("sum = " + sum + ", avg = " + avg);
    }
    while循环的语法格式
    while循环的执行流程
  45. 计算条件表达式的值。
  46. 如果条件表达式的值为true,执行循环体。
  47. 执行完循环体以后,回到步骤1。
  48. 如果条件表达式的值为false,结束循环的执行。
    while循环的示例
    while循环替代for循环
    while循环示例1:
  49. 需求:通过while循环打印10遍"Hello World"
  50. 代码:
    while(条件表达式){
    循环体;
    }
    public static void main(String[] args) {
    //需求:通过while循环打印10遍"Hello World"
    //分析:
    //1.循环体是 打印"Hello World"
    //2.循环结束的条件是打印10遍"Hello World"
    //—因此需要有一个计数器(变量),帮我们记录打印了几次(每打印一次,count就自增
    1)
    //—循环执行的条件:计数器不够十次。
    int count = 0;
    while(count < 10) {
    System.out.println(“Hello World”);
    count++;//每打印一次,count就自增1
    }
    }
    while循环示例2:
  51. 需求:打印1~100之间(含1和100)所有的整数。
  52. 代码:
    while循环示例3:
  53. 需求:打印出来100以内所有的偶数。
  54. 代码:
    while循环示例4:
  55. 需求:求100以内所有奇数的和。
  56. 代码:
    public static void main(String[] args) {
    //需求:打印1~100之间(含1和100)所有的整数。
    //分析:
    //1.循环体是打印整数
    //2.循环结束的条件是打印完1~100之间所有的整数。
    //—因此,需要有一个变量来表示当前正在打印的整数,当前数打印完之后要换下一个数。
    //—循环条件:当前打印的整数没有超出[1, 100]范围
    int num = 1;
    while(num <= 100) {
    System.out.println(num);//打印当前的数
    num++;//换下一个数
    }
    }
    public static void main(String[] args) {
    //需求:打印出来100以内所有的偶数。
    //分析:
    //1.循环体:打印偶数
    //2.循环结束条件是打印完100以内所有的偶数。
    //—因此,需要有一个数表示当前数字(可能是偶数,可能是奇数)。判断数字的奇偶,如
    果是偶数就打印,如果是奇数不做任何处理。无论这个数字是否是偶数,判断完之后要换下一个数字。
    //—循环执行条件:尚未检查完100以内所有的数字
    int num = 0;
    while(num <= 100) {
    if(num % 2 == 0) {
    System.out.println(num + " ");
    }
    num++;
    }
    }
    public static void main(String[] args) {
    //需求:求100以内所有奇数的和。
    //分析:
    //1.循环体:把奇数加到sum中去。—定义一个表示和的变量sum,在循环体中把奇数加到
    sum中去
    //2.循环结束的条件:100以内的数字全判断完毕。
    while循环示例5:
  57. 需求:在控制台打印出所有的水仙花数。水仙花数:是一个三位数,水仙花数的个位、十位、百位
    数字的立方之和等于原数。
  58. 代码:
    while循环示例6:
  59. 需求:产生5个[10, 80]之间的随机数,输出产生的数,并求出最大的随机数。
  60. 代码:
    //—因此,需要有一个数表示当前数字。对这个数字判断奇偶,如果是奇数,加到sum中
    去,如果是偶数,不做处理。判断完毕之后,无论奇偶都要换下一个数字。
    //—循环执行的条件,100以内的数据尚未检查完毕。
    int sum = 0;
    int num = 0;
    while(num < 100) {
    if(num % 2 == 1) {
    sum += num;
    }
    num++;
    }
    System.out.println(sum);
    }
    public static void main(String[] args) {
    //需求:在控制台打印出所有的水仙花数。水仙花数:是一个三位数,水仙花数的个位、十
    位、百位数字的立方之和等于原数。
    //分析:
    //1.循环体:判断数字是不是数显花数
    //2.循环结束条件:100~1000(不含1000)之间,所有的数都判断了一遍。
    //—因此,需要定义一个变量表示当前数字。判断这个数字是不是水仙花数,是的话打印这
    个数。判断完后,无论是否是水仙花数,都要换下一个数。
    //—循环执行的条件,100~1000之间的数尚未判断完毕。
    int num = 100;
    while(num < 1000) {
    int gw = num % 10;
    int sw = num / 10 % 10;
    int bw = num / 100;
    if(gw * gw * gw + sw * sw * sw + bw * bw * bw == num) {
    System.out.print(num + " ");
    }
    num++;
    }
    }
    public static void main(String[] args) {
    //需求:产生5个[10, 80]之间的随机数,输出产生的数,并求出最大的随机数。
    //分析:
    //1.定义一个变量max保存最大的随机数。
    //2.定义一个变量count记录随机数的个数。
    //3.循环体:产生随机数,输出随机数,判断随机数和max的大小,如果随机数大,把max更
    新为随机数的值,coun自增1
    while循环替代for循环总结
    通过上述种种示例,不难发现while确实可以替代for循环。而且可以发现for循环中的表达式1,表达式
    2,表达式3以及循环体,在while循环中都有出现。
    for循环的表达式1对应的是while循环之前的循环初始条件。
    for循环的表达式2对应的是while循环的条件表达式。
    for循环的表达式3对应的是while循环中的 变量自增。
    for循环的循环体对应的是while循环中除了变量自增之外的全部内容。
    while循环的完整语法格式是:
    开发中,如果知道循环次数,一般使用for循环,不使用while循环。–因为for简单。
    while循环自身特长:不知道循环次数
    while循环示例1:
  61. 需求:限定用户输入内容。提示用户输入1~7(含1和7)之间的数字。如果用户输入的数字范围不
    在1~7之内,让用户重新输入,直到用户输入的数字符合要求。
  62. 代码:
//4.循环执行的条件:尚未产生5个随机数
int count = 0;
int max = 0;
Random random = new Random();
while(count < 5) {
int num = random.nextInt(80 - 10 + 1) + 10;
System.out.print(num + " ");
if(num > max) {
max = num;
}
count++;
}
System.out.println("max = " + max);
}
循环的初始条件;//对应for循环的 表达式1
while(条件表达式){//对应for循环的 表达式2
循环体;//对应for循环的 循环体
循环增量;//对应for循环的表达式3
}
while循环示例21. 需求:输入一个整数,判断是几位数。
2. 代码:
while循环示例31. 需求:世界上最高山峰是珠穆朗玛峰(8844.43=8844430毫米),假如有一张足够大的纸,它的
厚度是0.1毫米。请问折叠多少次,可以折成珠穆朗玛峰的高度?
2. 代码:
public static void main(String[] args) {
//需求:限定用户输入内容。提示用户输入1~7(含1和7)之间的数字。
//如果用户输入的数字范围不在1~7之内,让用户重新输入,直到用户输入的数字符合要求。
int num = 0;
Scanner scanner = new Scanner(System.in);
while(num > 7 || num < 1) {
System.out.print("请输入1~7(含1和7)之间的数字:");
num = scanner.nextInt();
}
System.out.println("您输入的数字是:" + num);
}
public static void main(String[] args) {
//需求:输入一个整数,判断是几位数。
//分析:
//1.对于一个数而言,除以10,相当于抹掉了1位(个位)。再除以10,相当于又抹掉了一
位。也就是说判断一个数是几位数,就看能除以10几次(除后商不为0//2.循环体:将整数更新为除以10以后的数。计数器自增1.
//3.循环执行的条件:整数不为0。
int count = 0;
Scanner scanner = new Scanner(System.in);
System.out.print("请输入一个整数:");
int num = scanner.nextInt();
while(num != 0) {
num = num / 10;
count++;
}
System.out.println("你输入的是一个" + count + "位数!");
}
public static void main(String[] args) {
//需求:世界上最高山峰是珠穆朗玛峰(8844.43米=8844430毫米),假如有一张足够大的
纸,它的厚度是0.1毫米。
//请问折叠多少次,可以折成珠穆朗玛峰的高度?
//分析:
//1.纸每折叠一次,都是上一次厚度的2倍。
//2.循环体:更新当前厚度,更新折叠次数。
//3.循环执行条件:厚度小于珠穆朗玛峰的高度。
double thickness = 0.1;
int count = 0;
while(thickness <= 8844430) {
thickness *= 2;
while循环示例41. 需求:生成2[10, 20]之间的随机数,如果生成的2个数不相等,再重新生成,直到2个数相等。
2. 代码:
while循环示例51. 需求:如果你是一个富二代,你有10亿元(1000000000),每天花一半,多天可以花完。
2. 代码:
while循环总结---不知道循环次数
while循环最大的用途就是处理不知道循环次数的循环,这一点是for无法做到的。在开发中,凡是用到
while的地方,都是因为需要循环,但不知道具体要循环几次。
while总结
1. while可以实现for循环的全部功能
2. while循环善于处理不知道循环次数的循环。
3. 开发中使用的是while的第二种功能。
count++;
}
System.out.println("达到珠穆朗玛峰的高度,需要折叠" + count + "次,此时纸的
厚度是" + thickness + "毫米");
}
public static void main(String[] args) {
//需求:生成2个[10, 20]之间的随机数,如果生成的2个数不相等,再重新生成,直到2个
数相等。
Random random = new Random();
int num1 = random.nextInt(20 - 10 + 1) + 10;
int num2 = random.nextInt(20 - 10 + 1) + 10;
System.out.println("num1 = " + num1 + ", num2 = " + num2);
while(num1 != num2) {
num1 = random.nextInt(20 - 10 + 1) + 10;
num2 = random.nextInt(20 - 10 + 1) + 10;
System.out.println("num1 = " + num1 + ", num2 = " + num2);
}
}
public static void main(String[] args) {
// 需求:如果你是一个富二代,你有10亿元(1000000000),每天花一半,多天可以花
完。
int money = 1000000000;
int day = 0;
while (money != 0) {
money /= 2;
day++;
}
System.out.println("10亿元可以花" + day + "天!");
}

do…while循环
do…while是Java中第三种循环结构,是使用频率最低的循环结构。do…while循环能实现while循环全部
的功能,do…while循环和while循环的唯一区别是,do…while循环会至少执行一次循环。
do…while循环的语法格式
注意:上述格式中,while(表达式)后面有一个分号。
do…while循环的执行流程

  1. 执行循环体语句。
  2. 判断表达式的值是否为true。如果为true,执行步骤1。
  3. 如果表达式的值为false,结束循环。
    while循环是先判断条件在决定是否执行循环体
    do…while是先执行循环体再判断条件。即:至少执行一次循环体。
    do…while循环的示例
    do…while循环示例1:
  4. 需求:打印1~100之间(含1和100)所有的整数。
  5. 代码:
do{
循环体;
}while(表达式);
public static void main(String[] args) {
//需求:打印1~100之间(含1和100)所有的整数。
//分析:
//1.循环体:打印一个整数。
//2.循环次数:100次。
//3.起始条件:从数字1开始
//4.循环控制:数字增1
//4.循环条件:数字小于等于100

do…while循环示例2:

  1. 需求:在控制台打印出所有的水仙花数。水仙花数:是一个三位数,水仙花数的个位、十位、百位
    数字的立方之和等于原数。
  2. 代码:
    do…while循环示例3:
  3. 需求:输入一个整数,判断是几位数。
  4. 代码:
int i = 1;
do {
System.out.println(i);
i++;
}while(i <= 100);
}
public static void main(String[] args) {
//需求:在控制台打印出所有的水仙花数。水仙花数:是一个三位数,水仙花数的个位、十
位、百位数字的立方之和等于原数。
//分析:
//1.循环的起始状态:从数字100开始
//2.循环控制:数字每次加1
//3.循环执行条件:数字小于1000
//4.循环体:判断数字是不是水仙花数。
int num = 100;
do {
int gw = num % 10;
int sw = num / 10 % 10;
int bw = num / 100;
if(gw * gw * gw + sw * sw * sw + bw * bw * bw == num) {
System.out.println(num);
}
num++;
}while(num < 1000);
}
public static void main(String[] args) {
//需求:输入一个整数,判断是几位数。
//分析:
//1.定义变量接收输入的整数
//2.创建Scanner对象
//3.提示用户输入
//4.接收用户输入的数据
//5.定义一个计数器,记录位数
//5.判断数字的位数
// 循环体:1.让数字位数减少1位,(数字 /= 10) 2.计数器加1
// 循环执行条件:数字不等于0
int num = 0;
Scanner scanner = new Scanner(System.in);
System.out.print("请输入一个整数:");
num = scanner.nextInt();

do…while示例4:

  1. 需求:生成2个[10, 20]之间的随机数,如果生成的2个数不相等,再重新生成,直到2个数相等。
  2. 代码:
    do…while总结
    do…while本质上和while差不多,既能胜任知道循环次数的情形,也能胜任不知道循环次数的情形。与
    while的不同点是先执行循环体,再判断条件是否成立。
    开发中do…while的使用频率比较低。因为while循环可以替代do…while,只需要在while循环之前,先把
    循环体的代码写一遍即可。
    for、while、do…while区别
    上述代码执行完毕后,会打印什么结果?
int count = 0;
do {
num /= 10;
count++;
}while(num != 0);
System.out.println("您输入了一个" + count + "位数。");
}
//需求:生成2个[10, 20]之间的随机数,如果生成的2个数不相等,再重新生成,直到2个数相等。
Random random = new Random();
int num1 = 0;
int num2 = 0;
do {
num1 = random.nextInt(20 - 10 + 1) + 10;
num2 = random.nextInt(20 - 10 + 1) + 10;
System.out.println(num1 + " " + num2);
}while(num1 != num2);
System.out.println("两个数相等了。这两个数是:" + num1 + " " + num2);
public static void main(String[] args) {
for(int i = 5; i < 5; i++) {
System.out.println("for循环");
}
int j = 5;
while(j < 5) {
System.out.println("while循环");
j++;
}
int k = 5;
do {
System.out.println("do..while循环");
k++;
}while(k < 5);
}

do…while至少执行一次循环体。
for循环中定义的变量i,只能在for循环里用,出了for循环就不能使用了。
对于while循环的 j 以及do…while循环的k来说,他们定义在了循环的外面,因此可以在循环结束后
使用。
死循环
死循环,即无限循环。循环一旦开始就永远不会停止。在开发过程中,应当避免死循环。
死循环示例:
死循环示例-for循环
代码:
上面的示例,没有任何语句控制循环的结束。所以会无限打印hello world,导致循环后面的代码
永远执行不到。
注意:如果程序中出现死循环,Eclipse会报错,不允许你执行。
代码:

public static void main(String[] args) {
for(int i = 1; i < 3; i++) {
System.out.println(i);
}
//System.out.println(i);
System.out.println("---华丽的分割线---");
int j = 1;
while(j < 3) {
System.out.println(j);
j++;
}
System.out.println(j);
System.out.println("---华丽的分割线---");
int k = 1;
do {
System.out.println(k);
k++;
}while(k < 3);
System.out.println(k);
}
public static void main(String[] args) {
for( ; ; ) {
System.out.println("hello world");
}
System.out.println("end");//这行代码永远执行不到
}
上面的示例,虽然表达式完整,但是 i != 10会永远为真,因此也是一个死循环。导致for循环后面
的代码无法执行
死循环示例-while
代码:
上面的示例,也是一个死循环,i 初始值是0,在循环体里没有任何操作去改变 i 的值,因此 i <
100永远为真,循环会无限执行,while循环后面的代码永远不会被执行到。很多新手,在写while
循环的时候容易漏写i++。
正数因为这个原因,通常使用for循环不使用while循环。
代码:
这也是一个死循环。循环条件永远是true。
死循环示例-do..while
代码:
上面的示例,和while死循环的案例一样,也是因为 缺少 i++public static void main(String[] args) {
for(int i = 0 ; i != 10 ; i += 3 ) {
System.out.println("hello world");
}
System.out.println("end");//这行代码永远执行不到
}
public static void main(String[] args) {
int i = 0;
while(i < 100) {
System.out.println(i);
}
System.out.println("end");
}
public static void main(String[] args) {
while(true) {
System.out.println("hello world");
}
}
public static void main(String[] args) {
int i = 0;
do {
System.out.println(i);
}while(i < 100);
System.out.println("end");
}

这也是一个死循环。循环条件永远是true。
如何避免死循环

  1. 对于知道循环次数的情形,使用for循环。----for循环的语法格式,表达式3处写循环控制语句,不
    容易忘记。while和do…while容易忘记。
  2. 写完代码以后,找临界值试试验证代码的正确性。
  3. 借助break结束循环。
    break、continue关键字
    结束循环
    结束循环的方式一共有2种:
  4. 循环正常结束,即循环条件不再满足时,循环正常结束。
  5. 强行结束循环,即break关键字。
    在开发中无论是循环的正常结束还是通过break让循环结束,都是非常非常常见的。
    break关键字
    break关键字一共2个用途:
  6. 用在switch…case语句中的每个case里,用于结束switch语句。
  7. 用在循环结构的循环体中,用于结束当前循环的执行。—即:break写在哪个循环里,就结束哪个
    循环。
    如果break出现在循环体里,break用于结束当前循环。
    如果循环体内,break后面还有别的代码,break后面的代码不会执行。----仅限循环体内的代码。
    循环体外的代码可以正常执行。
    如果循环次数尚未用完,执行到了循环体中的break语句,也是直接结束循环,未执行的循环次数
    不再执行。
    break可以出现在for循环里,可以出现在while循环里,也可以出现在do…while循环里。
    break示例1:
  8. 需求:产生10个[10, 20]之间的随机数,产生随机数的过程中,如果某个随机数的值是16,结束循
    环。
  9. 代码:
public static void main(String[] args) {
do {
System.out.println("hello world");
}while(true);
}

break示例2:

  1. 需求:用户可以在控制台输入任意字符串,当用户输出字符串是"exit"的时候,认为是结束输出,
    用户将不能再输入任何内容。
  2. 代码:
    break示例3:
  3. 需求:猜数字。产生1个[10, 30]的随机数,从键盘上输入你的猜测结果,如果猜测的数比随机数
    大,提示"你猜的数据大了",如果猜测的数比随机数小,提示"你猜测的数据小了",如果猜测的数
    和随机数一样大,提示"恭喜你猜对了",计算出猜了几次才猜对。
  4. 代码:
    public static void main(String[] args) {
    //需求:产生10个[10, 20]之间的随机数,产生随机数的过程中,如果某个随机数的值是
    16,结束循环。
Random random = new Random();
for(int i = 0; i < 10; i++) {
int num = random.nextInt(20 - 10 + 1) + 10;
System.out.print(num + " ");
if(num == 16) {
break;
}
}
}
public static void main(String[] args) {
//需求:用户可以在控制台输入任意字符串,当用户输出字符串是"exit"的时候,认为是结
束输出,用户将不能再输入任何内容。
System.out.println("请随意输入内容,想结束的时候输出exit并按回车。");
Scanner scanner = new Scanner(System.in);
while(true) {
//获取用户输入的内容
String str = scanner.nextLine();
if(str.equals("exit")) {
break;
}
}
}

public static void main(String[] args) {
//需求:猜数字。产生1个[10, 30]的随机数,从键盘上输入你的猜测结果,
//如果猜测的数比随机数大,提示"你猜的数据大了",如果猜测的数比随机数小,提示"你猜
测的数据小了",
//如果猜测的数和随机数一样大,提示"恭喜你猜对了",并计算出猜了几次才猜对。
//生成一个[10, 30]的随机数。
Random random = new Random();
int num = random.nextInt(30 - 10 + 1) + 10;
//定义变量,记录猜测的次数。
int count = 0;
//创建Scanner对象
Scanner scanner = new Scanner(System.in);
break示例4:

  1. 需求:限定用户输入内容。提示用户输入17之间(含1和7)的数字。如果用户输入的不是17之
    间的数字,让用户继续输入,如果输入是1~7之间的数,则结束循环。
  2. 代码:
    break的使用场景举例:
  3. 从数组中查找某个数据,一旦找到,就结束循环。—数组是后面要学习的内容。
  4. 用在死循环里,用于结束死循环(通常是达到了某个条件)。
  5. 游戏里,将游戏中的怪物随机刷新在游戏地图里,如果怪物被刷新到了障碍物里(例如:
    河、山、树等),重新随机怪物的位置。
    break关键字通常情况下和if语句搭配使用。
    continue关键字
    continue关键字的作用是用于结束本次循环。例如:循环体里一共有10行代码,第5行出现了
    continue,当执行完continue以后,本次循环中第6行到第10行代码将不再执行。
    continue只是结束本次循环,而不是结束整个循环。continue通常情况下也是与if语句搭配使用。
//开始猜测
while(true) {
System.out.print("请输入猜测的数字:");
int yourAnswer = scanner.nextInt();
count++;//每次1次,计数器加1。
if(yourAnswer > num) {
System.out.println("你猜测的数据大了。");
}else if(yourAnswer < num) {
System.out.println("你猜测的数据小了。");
}else {
System.out.println("恭喜你猜对了。" + "随机产生的数是:" + num +
", 你猜了" + count + "次猜对了!");
break;
}
}
}
public static void main(String[] args) {
//需求:限定用户输入内容。提示用户输入1~7之间(含1和7)的数字。
//如果用户输入的不是1~7之间的数字,让用户继续输入,如果输入是1~7之间的数,则结束
循环。
Scanner scanner = new Scanner(System.in);
while(true) {
System.out.print("请输入1~7之间的数字:");
int num = scanner.nextInt();
if(num >= 1 && num <= 7) {
break;
}else {
System.out.println("输入的数据有误!");
}
}
}

continue示例1:

  1. 需求:打印100以内所有的奇数。
  2. 代码:
    continue示例2:
  3. 需求:打印100以内的整数,遇到7的倍数或者含7的数字跳过。
  4. 代码:
    break、continue总结
  5. break用于结束当前循环。
  6. continue用于结束本次循环。
  7. break、contine通常是与if语句连用。即某种条件满足时才break或continue。
  8. break使用比较频繁,经常用在死循环里结束循环。或者用在for循环里提前结束循环。
  9. continue很少使用。
public static void main(String[] args) {
//需求:打印100以内所有的奇数。
for(int i = 1; i < 100; i++) {
if(i % 2 == 0) {
continue;
}
System.out.println(i);
}
}
public static void main(String[] args) {
//需求:打印100以内的整数,遇到7的倍数或者含7的数字跳过。
for(int i = 1; i < 100; i++) {
if(i % 7 == 0 || (i % 10 == 7 || i / 10 == 7)) {
continue;
}
System.out.print(i + " ");
}
}

https://www.xjx100.cn/news/3092684.html

相关文章

详解python淘宝秒杀抢购脚本程序实现

文章目录 前言一、官网下载火狐浏览器二、下载geckodriver&#xff0c;并解压到火狐浏览器文件夹根目录三、添加火狐浏览器根目录到系统环境变量四、下载并安装python及pycharm开发工具五、进入淘宝六、使用Pycharm运行脚本&#xff0c;新建python文件&#xff0c;将代码复制到…

LeetCode热题100——动态规划

动态规划 1. 爬楼梯2. 杨辉三角3. 打家劫舍 1. 爬楼梯 假设你正在爬楼梯。需要 n 阶你才能到达楼顶。 每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢&#xff1f; // 题解&#xff1a;每次都有两种选择&#xff0c;1或者2 int climbStairs(int n) {if (n …

模电 01

一.半导体基本知识 1.优点&#xff1a;体积小、重量轻、使用寿命长、输入功率小、功率转换效率高。 2.性能介于导体与绝缘体 3.常用半导体材料&#xff1a;硅&#xff08;SI&#xff09; 镉&#xff08;Ge&#xff09;,化合物半导体&#xff1a;砷化镓&#xff08;GaAs&…

linux上安装qt creator

linux上安装Qt Creator 1 Qt Creator 的下载 下载地址为&#xff1a;http://download.qt.io/archive/qt/ 根据自己的需求选择Qt Creator版本&#xff0c;这里我下载的是5.12.9&#xff0c;如下图所示&#xff1a; 在ubuntu上可以使用wget命令下载安装包&#xff1a; wget h…

微信小程序记住密码,让登录解放双手

密码是用户最重要的数据&#xff0c;也是系统最需要保护的数据&#xff0c;我们在登录的时候需要用账号密码请求登录接口&#xff0c;如果用户勾选记住密码&#xff0c;那么下一次登录时&#xff0c;我们需要将账号密码回填到输入框&#xff0c;用户可以直接登录系统。我们分别…

前端CSS实现响应式TimeLine效果(附源码)

文章目录 纯CSS搭建&#xff0c;先上效果图&#xff08;附有源码&#xff09;视图层 index.htmlindex.css 公用样式文件Main.css 主要的样式文件 纯CSS搭建&#xff0c;先上效果图&#xff08;附有源码&#xff09; 本效果为纯CSS搭建&#xff0c;适配移动端和PC端&#xff01…

2023年【T电梯修理】考试题及T电梯修理考试报名

题库来源&#xff1a;安全生产模拟考试一点通公众号小程序 T电梯修理考试题是安全生产模拟考试一点通总题库中生成的一套T电梯修理考试报名&#xff0c;安全生产模拟考试一点通上T电梯修理作业手机同步练习。2023年【T电梯修理】考试题及T电梯修理考试报名 1、【多选题】GB/T1…

Continuity” of stochastic integral wrt Brownian motion

See https://imathworks.com/math/math-continuity-of-stochastic-integral-wrt-brownian-motion/