22-Java的循环结构：for循环

最新推荐文章于 2024-01-18 11:14:59 发布
最新推荐文章于 2024-01-18 11:14:59 发布
阅读量799 收藏 1
点赞数
分类专栏： JavaSE基础入门篇 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yelitoudu/article/details/125288700
版权

一、for循环

  • 控制一段代码反复执行很多次
  • 举个例子：
    • 比如：你去淘宝搜索手机，是不是会显示上千上万部手机？那么不可能说一条一条去写这样的代码吧？肯定不会这么干，所以，就有了循环结构这个东西，将一段代码反复执行很多次。
格式：
for (初始化语句; 循环条件; 迭代语句) {
    循环体语句(重复执行的代码);
}

示例：
// 输出3次HelloWorld
for (int i = 0; i < 3; i++) {
    System.out.println("Hello World");
}

在这里插入图片描述

package com.app.loop;

public class ForDemo1 {
    public static void main(String[] args) {
        // 目标：学会使用for循环，并理解其流程
 /*
    需求：在控制台输出3次HelloWorld
    分析需求：
     思路1：如果要在控制台输出3次HelloWorld，按照正常来写的话，要写三个输出语句就可以实现这个需求
     思路2：使用for循环结构来实现：格式——> for (初始化语句; 循环条件; 迭代语句) { 循环体语句(重复执行的代码) }
      （1）初始化语句是啥？——> 如：int a = 0; int b = 1;等等，像这些定义变量并赋初始值的就称为初始化语句
      （2）循环条件是啥？——> 如 int a = 0; 想要让变量a循环3次 就是：a < 3; 因为计算机数数喜欢从 0 开始数：0, 1, 2（三次）
      （3）迭代语句是啥？——> 如 a++; 每循环一次就给变量a+1,
           如：int a = 0; a < 3; a++ ——>因为循环条件是 a<3;所以a要循环3次；
           a 循环第一次，就是 a=0 < 3，然后会将第一次赋给a；（0<3，判断为true，将继续循环）
           a 循环第二次，就是 a+1=0+1=1，然后会将第二次赋给a，此时a从a=0变为a=1；（1<3，判断为true，将继续循环）
           a 循环第三次，就是 a+1=1+1=2，然后会将第三次赋给a，此时a从a=1变为a=2；（2<3，判断为true，将继续循环）
           a 循环第四次，就是 a+1=2+1=3，此时a从a=2变为a=3；（3不小于3，判断为false，结束循环）
      （4）循环体语句是啥？——> 如：System.out.println("HelloWorld");，就是你想要执行多次的代码就称为循环体语句；
           假如你把这句语句放到for循环里，会根据你给的循环条件，重复执行
           如：for(int a = 0; a<3; a++) { System.out.println("HelloWorld"); }
              a 循环第一次，会将第一次循环赋给a，因为a=0，此时a<3，判断为true，继续循环；
              a 循环第二次，会将第二次循环赋给a，因为a++，所以a=1，此时a<3，判断为true，继续循环；
              a 循环第三次，会将第三次循环赋给a，因为a++，所以a=2，此时a<3，判断为true，继续循环；
              a 循环第四次，会将第四次循环赋给a，因为a++，所以a=3，此时a=3，不符合a<3，判断为false，结束循环
              最终将System.out.println("HelloWorld");这句代码的三次执行赋给a
              最终输出结果为: HelloWorld
                           HelloWorld
                           HelloWorld
         */
        // 思路1
        String s = "HelloWorld";
        System.out.println("-------------------思路1的输出结果-------------------");
        // 输出3次HelloWorld
        System.out.println(s);
        System.out.println(s);
        System.out.println(s);

        
        // 思路2
        System.out.println("-------------------思路2的输出结果-------------------");
        for (int a = 0; a < 3; a++) {
            System.out.println("HelloWorld");
        }
        
        
        /*
           思路3: int i = 1; i<=5; i+=2;
           解析:
                i 第一次循环，因为i=1，所以符合i<=5，为true，继续循环
                i 第二次循环，因为i=1，此时i+=2等价于i=i+2; 结果为3，所以i=3，符合i<=5，为true，继续循环
                i 第三次循环，因为i=3，此时i+=2等价于i=i+2; 结果为5，所以i=5，符合i<=5，为true，继续循环
                i 第四次循环，因为i=5，此时i+=2等价于i=i+2; 结果为7，所以i=7，不符合i<=5，为false，结束循环
        */
        System.out.println("-------------------思路3的输出结果-------------------");
        for (int i = 1; i<=5; i+=2) {
            System.out.println("HelloWorld");
        }
    }
}

输出结果：

-------------------思路1的输出结果-------------------
HelloWorld
HelloWorld
HelloWorld
-------------------思路2的输出结果-------------------
HelloWorld
HelloWorld
HelloWorld
-------------------思路3的输出结果-------------------
HelloWorld
HelloWorld
HelloWorld
  • 我们可以看到思路1和思路2都可以实现需求
  • 但是按照开发角度来看，咱们还是用思路2的for循环来解决这需求会更简便、更专业
  • 因为目前是需求你输出3次，要是需求你输出1万次呢？所以还是要用循环结构来解决这样的需求比较好！！

for循环总结

1、for循环格式和执行流程是什么样的？

  • 格式：
for (初始化语句; 循环条件; 迭代语句) {
    循环体语句(重复执行的代码);
}

  • 执行流程：
比如: 
for (int i = 1; i<=5; i+=2) {
    System.out.println("你好世界！");
}
流程解析:
      i 第一次循环，因为i=1，所以符合i<=5，为true，继续循环
      i 第二次循环，因为i=1，此时i+=2等价于i=i+2; 结果为3，所以i=3，符合i<=5，为true，继续循环
      i 第三次循环，因为i=3，此时i+=2等价于i=i+2; 结果为5，所以i=5，符合i<=5，为true，继续循环
      i 第四次循环，因为i=5，此时i+=2等价于i=i+2; 结果为7，所以i=7，不符合i<=5，为false，结束循环

最终输出结果：
你好世界！
你好世界！
你好世界！

二、for循环案例1：求和

  • 需求： 求1-5之间的数据和，并把求和结果在控制台输出。

    package com.app.loop;

public class ForTest2 {
    public static void main(String[] args) {
        // 目标：通过案例更深入理解和熟练for循环
        /*
            需求：求1-5之间的数据和，并把求和结果在控制台输出
            分析：
              (1) 提供思路：1到5之间的数据：1、2、3、4、5，和为：15
              (2) 定义变量sum，初始值为0，用于存放求和结果
              (3) 使用for循环，循环取出 1<=5 的数据，赋值给一个变量，然后求和
              (4) 将求和结果在控制台输出
         */
        // 1.定义变量sum，初始值为0，用于存放求和结果
        int sum = 0;
        // 2.使用for循环，定义变量，初始值为1，循环取出 1<=5 的数据，然后求和
        for (int i = 1; i <= 5; i++) {
            // 将1~5之间的数累加起来————求和
            sum += i;  // 等价于 sum = sum + i;
        }
        System.out.println("1~5之间的数之和为：" + sum);
    }
}

    输出结果：
1~5之间的数之和为：10


    // 此次求和案例详细解析：
      // 1.定义变量sum，初始值为0，用于存放求和结果
         int sum = 0;
         for (int i = 1; i<=5; i++) {
              // 将1~5之间的数累加起来————求和
              sum += i; // 等价于 sum = sum + i
         }
    // 首先进入for循环：
    // i 的第一次循环，i=1，符合i<5，sum += i 等价于 sum = sum + i 等价于 sum = 0 + 1，所以将 1 重新赋值给变量sum，继续循环；
    // i 的第二次循环，i=1+1 = 2，符合i<=5，sum += i 等价于 sum = 1 + 2，所以将 3 重新赋值给变量sum，继续循环；
    // i 的第三次循环，i=2+1 = 3，符合i<=5，sum += i 等价于 sum = 3 + 3，所以将 6 重新赋值给变量sum，继续循环；
    // i 的第四次循环，i=3+1 = 4，符合i<=5，sum += i 等价于 sum = 6 + 4，所以将 10 重新赋值给变量sum，继续循环；
    // i 的第五次循环，i=4+1 = 5，符合i<=5，sum += i 等价于 sum = 10 + 5，所以将 15 重新赋值给变量sum，继续循环；
    // i 的第六次循环，i=5+1 = 6，不符合i<=5，判断为false，结束循环。
    // 目前 sum 的值已经累加到了 15，所以此时 sum=15;
    // 所以最后在控制台输出sum的值就为15

for循环案例——求和的总结

1、如何实现元素求1~5的和？

  • 定义一个盒子，int类型的变量sum，初始值为0，用于存放循环取出1~5之间的数据之和

    int sum = 0;

  • 使用循环控制输出1~5之间的数据

    int sum = 0;
for (int i = 1; i <=5; i++) {
    
}

  • 用盒子把 每次循环取出的1~5之间的数 装起来（叠加）

    int sum = 0;
for (int i = 1; i <= 5; i++) {
    sum += i;
}

  • 最后将盒子里已经累加好的数输出到控制台

    int sum = 0;
for (int i = 1; i <= 5; i++) {
    sum += i;
}
System.out.println("1~5之间的数之和为：" + sum);

三、for循环案例2：求奇数和

  • 需求： 求1~10之间的奇数和，并把求和结果在控制台输出

    • 方式一：
    package com.app.loop;

public class ForTest3 {
    public static void main(String[] args) {
        // 目标：通过案例更深入和熟练使用for循环，并理解其流程
        /*
            需求：求1~10之间的奇数和，并把求和结果在控制台输出
            分析：
               (1) 提供思路：1~10之间的奇数，1、3、5、7、9，将这些奇数通过使用for循环找出来，并累加起来求和
               (2) 定义个盒子：int类型的变量sum，初始值为0，用于把for循环找出来的奇数装起来，并累加
               (3) 使用for循环：
                   (3-1) 定义初始化语句：int i = 1;
                   (3-2) 定义循环条件：i <= 10;
                   (3-3) 定义迭代语句：i++
                   (3-4) 在for循环里使用if判断来筛选：
                      (3-4-1) if判断条件：使用除二取余法来判断是不是奇数，除二余数为1的是奇数
                          (3-4-1-1) 是奇数，则定义循环体语句：sum += i;————>将每次循环取到的奇数累加给盒子变量sum
               (4) 将求和结果在控制台输出
         */
        System.out.println("---------------------------方式一---------------------------");
        // 1.定义个盒子：int类型的变量sum，初始值为0，用于把for循环找出来的奇数装起来，并累加
        int sum = 0;
        // 2.使用for循环：
        /*
            (2-1) 定义初始化语句：int i = 1;
            (2-2) 定义循环条件：i <= 10;
            (2-3) 定义迭代语句：i++
         */
        for (int i = 1; i <= 10; i++) {
            // (2-4) 在for循环里使用if判断：
            // i % 2 == 1：i 除以 2 是否 余 1
            if (i % 2 == 1) {     // (2-4-1) if判断条件：使用除二取余法来判断是不是奇数，除二余数为1的是奇数
                // (2-4-1-1) 是奇数，则定义循环体语句：sum += i;————>将每次循环取到的奇数累加给盒子变量sum
                sum += i;
            }
        }
        // 3.将求和结果在控制台输出
        System.out.println("1~10之间的奇数和为：" + sum);



        /*
           此次奇数求和案例方式一的执行流程的详细解析：
               1.定义好装奇数累加和的盒子之后
               2.进入for循环：
                 i 的第一次循环，i=1，符合i <= 10，然后进行if判断：1 % 2 是 余 1，所以i=1是奇数，
                   则sum+=i等价于sum = sum + i 等价于 sum = 0 + 1，因此将1重新赋值给sum，继续循环

                 i 的第二次循环，i=1+1 = 2，符合i <= 10，if判断：2 % 2 是 余 0，所以i=2不是奇数，
                   则sum的值不进行累加，继续循环

                 i 的第三次循环，i=2+1 = 3，符合i <= 10，if判断：3 % 2 是 余 1，所以i=3是奇数，
                   则sum+=i等价于sum = 1 + 3，因此将4重新赋值给sum，继续循环

                 i 的第四次循环，i=3+1 = 4，符合i <= 10，if判断：4 % 2 是 余 0，所以i=4不是奇数，
                   则sum的值不进行累加，继续循环

                 i 的第五次循环，i=4+1 = 5，符合i <= 10，if判断：5 % 2 是 余 1，所以i=5是奇数，
                   则sum+=i等价于sum = 4 + 5，因此将9重新赋值给sum，继续循环

                 i 的第六次循环，i=5+1 = 6，符合i <= 10，if判断：6 % 2 是 余 0，所以i=6不是奇数，
                   则sum的值不进行累加，继续循环

                 i 的第七次循环，i=6+1 = 7，符合i <= 10，if判断：7 % 2 是 余 1，所以i=7是奇数，
                   则sum+=i等价于sum = 9 + 7，因此将16重新赋值给sum，继续循环

                 i 的第八次循环，i=7+1 = 8，符合i <= 10，if判断：8 % 2 是 余 0，所以i=8不是奇数，
                   则sum的值不进行累加，继续循环

                 i 的第九次循环，i=8+1 = 9，符合i <= 10，if判断：9 % 2 是 余 1，所以i=9是奇数，
                   则sum+=i等价于sum = 16 + 9，因此将25重新赋值给sum，继续循环

                 i 的第十次循环，i=9+1 = 10，符合i <= 10，if判断：10 % 2 是 余 0，所以i=10不是奇数，
                   则sum的值不进行累加，继续循环

                 i 的第十一次循环，i=10+1 = 11，不符合i <= 10，判断：false，结束循环

                 因此sum的值最终累加到25，最终在控制台输出的1~10奇数和是25
        */
    }
}

    输出结果：
---------------------------方式一---------------------------
1~10之间的奇数和为：25
    • 方式二：
    package com.app.loop;

public class ForTest3 {
    public static void main(String[] args) {
        // 目标：通过案例更深入和熟练使用for循环，并理解其流程
        /*
            需求：求1~10之间的奇数和，并把求和结果在控制台输出
            分析：
               (1) 提供思路：1~10之间的奇数，1、3、5、7、9，将这些奇数通过使用for循环找出来，并累加起来求和
               (2) 定义个盒子：int类型的变量sum，初始值为0，用于把for循环找出来的奇数装起来，并累加
               (3) 使用for循环：
                   (3-1) 定义初始化语句：int i = 1;
                   (3-2) 定义循环条件：i <= 10;
                   (3-3) 定义迭代语句：i++
                   (3-4) 在for循环里使用if判断来筛选：
                      (3-4-1) if判断条件：使用除二取余法来判断是不是奇数，除二余数为1的是奇数
                          (3-4-1-1) 是奇数，则定义循环体语句：sum += i;————>将每次循环取到的奇数累加给盒子变量sum
               (4) 将求和结果在控制台输出
         */
        System.out.println("---------------------------方式二---------------------------");
        // 1.定义盒子变量sum2，初始值为0，用于存放奇数累加值
        int sum2 = 0;
        // 2.使用for循环，利用 (变量) += 2 依次取出1~10的奇数
        for (int i = 1; i <= 10; i+=2) {
            // 3.将每次循环取出的奇数累加求和
            sum2 += i;
        }
        // 4.将奇数之和输出在控制台
        System.out.println("1~10之间的奇数和为：" + sum2);



        /*
           此次奇数求和案例方式二的执行流程的详细解析：
              1.定义盒子变量sum2，用于存放奇数累加值
              2.进入for循环：
                i 的第一次循环，i=1，符合 i <= 10，sum2+=i 等价于 sum2 = sum2 + i 等价于 sum2 = 0 + 1，
                  则将1重新赋值给sum2

                i 的第二次循环，i=1+2 = 3，符合i<=10，sum2+=i 等价于 sum2 = 1 + 3，
                  则将4重新赋值给sum2

                i 的第三次循环，i=3+2 = 5，符合i<=10，sum2+=i 等价于 sum2 = 4 + 5，
                  则将9重新赋值给sum2

                i 的第四次循环，i=5+2 = 7，符合i<=10，sum2+=i 等价于 sum2 = 9 + 7，
                  则将16重新赋值给sum2

                i 的第五次循环，i=7+2 = 9，符合i<=10，sum2+=i 等价于 sum2 = 16 + 9，
                  则将25重新赋值给sum2

                i 的第六次循环，i=9+2 = 11，不符合i<=10，判断为false，结束循环。

                因此最终sum2的值累加到25，最终控制台输出的1~10奇数和是25
         */
    }
}

    输出结果：
---------------------------方式二---------------------------
1~10之间的奇数和为：25

for循环案例——求奇数和的总结

1、如何实现求奇数和？

  • 方式一：在for循环中，通过使用if判断筛选出奇数（除二取余法），再累加奇数和

    int sum = 0;
for (int i = 1; i <= 10; i++) {
	if (i % 2 == 1) {
		sum += i;
	}
}

  • 方式二：直接使用for循环找出奇数

    int sum = 0;
for (int i = 1; i <= 10; i+=2) {
	sum += i;
}

四、for循环案例3：水仙花数

  • 需求： 在控制台输出所有“水仙花数”，并且把水仙花数的个数的和也输出，水仙花数必须满足如下2个要求：

    • 水仙花数是一个三位数
    • 水仙花数的个位、十位、百位的数字立方和等于原数
    package com.app.loop;

public class ForTest4 {
    public static void main(String[] args) {
        // 目标：通过案例更深入和熟练使用for循环，并理解其执行流程
        /*
            需求：在控制台输出所有“水仙花数”，并且把水仙花数的个数和也输出，水仙花数必须满足如下2个要求：
              (1) 水仙花数是一个三位数
              (2) 水仙花数的个位、十位、百位的数字立方和等于原数
            需求分析：
              (1) 定义一个计数器变量，用于每输出一个水仙花数就累加它的个数
              (2) 找出所有三位数：100~999——使用for循环来循环取出
              (3) 每次循环取到一个三位数，就提取该三位数的：个位、十位、百位数字(需要变量分别接收个位、十位、百位)
              (4) 使用if判断：个位、十位、百位的数字立方和是否等于原数，等于就是水仙花数，则输出到控制台
        */

        // 1.定义一个计数器变量，用于每输出一个水仙花数就累加它的个数
        int count = 0;
        // 2.找出所有三位数：100~999——使用for循环来循环取出
        for (int i = 100; i < 1000; i++) {
            // 3.每次循环取到一个三位数，就提取该三位数的：个位、十位、百位数字(需要变量分别接收个位、十位、百位)
            // 个位
            int ge = i % 10;  // 假如 i = 153，153 / 10 = 15.3，余3，这样取到个位：3
            // 十位
            // 假如 i = 153 / 10 = 15.3，int类型保留整数，所以=15，15 % 10 = 15 / 10 = 1 余5，这样取到十位：5
            int shi = i / 10 % 10;  
            // 百位
            int bai = i /100;   // 假如 i = 153 / 100 = 1.57，int类型保留整数，所以就=1，这样取到百位
            // 4.使用if判断：个位、十位、百位的数字立方和是否 等于 原数，等于就是水仙花数
            // 假如153是水仙花数，1的3立方 + 5的三立方 + 3的三立方 的总和 是否等于 每次循环找出的三位数 i（原数）
            if (ge*ge*ge + shi*shi*shi + bai*bai*bai == i) {
                // 则输出到控制台并且用一个空格隔开
                System.out.print(i+"\t");
                // 每输出一个水仙花数就累计个数
                count++;
            }
        }
        System.out.println("\n水仙花数共有：" + count + "个");
    }
}

    输出结果：
153	370	371	407	
水仙花数共有：4个

for循环案例——找出水仙花数总结

1、如何找出水仙花数？

  • 先了解什么是水仙花数，然后使用for循环来取出所有三位数：从100开始到999结束

    // 1.使用for循环来取出所有三位数：从100开始到999结束
for (int i = 100; i < 1000) {
    
}

  • 提取出三位数的：个位、十位、百位，用变量存放起来

    // 1.使用for循环来取出所有三位数：从100开始到999结束
for (int i = 100; i < 1000) {
    // 2.提取出三位数的：个位、十位、百位，用变量存放起来
    // 个位
    int ge = i % 10;
    // 十位
    int shi = i / 10 % 10;
    // 百位
    int bai = i / 100;
}

  • 用if判断三位数的：个位、十位、百位的立方和 是否 等于 原数（i：每次循环找出的三位数）

    // 1.使用for循环来取出所有三位数：从100开始到999结束
for (int i = 100; i < 1000) {
    // 2.提取出三位数的：个位、十位、百位，用变量存放起来
    // 个位
    int ge = i % 10;
    // 十位
    int shi = i / 10 % 10;
    // 百位
    int bai = i / 100;
    
    // 3.用if判断三位数的：个位、十位、百位的立方和 是否 等于 原数（i：每次循环找出的三位数）
    if (ge*ge*ge + shi*shi*shi + bai*bai*bai == i) {
        
    }
}

  • 找出水仙花数后，平坦输出，用空格隔开

    // 1.使用for循环来取出所有三位数：从100开始到999结束
for (int i = 100; i < 1000) {
    // 2.提取出三位数的：个位、十位、百位，用变量存放起来
    // 个位
    int ge = i % 10;
    // 十位
    int shi = i / 10 % 10;
    // 百位
    int bai = i / 100;
    
    // 3.用if判断三位数的：个位、十位、百位的立方和 是否 等于 原数（i：每次循环找出的三位数）
    if (ge*ge*ge + shi*shi*shi + bai*bai*bai == i) {
        // 4.找出水仙花数后，平坦输出，用空格隔开
        System.out.print(i + "\t");	// 不加 ln 就是不换行的意思，"\t"是空格
    }
}

2、如何计算出水仙花数的总数？

  • 在未进入循环之前，定义计数器变量，用于存放每循环找出一个水仙花数，就累加个数

    // 5.在未进入循环之前，定义计数器变量，用于存放每循环找出一个水仙花数，就累加个数
int count = 0;
// 1.使用for循环来取出所有三位数：从100开始到999结束
for (int i = 100; i < 1000) {
    // 2.提取出三位数的：个位、十位、百位，用变量存放起来
    // 个位
    int ge = i % 10;
    // 十位
    int shi = i / 10 % 10;
    // 百位
    int bai = i / 100;
    
    // 3.用if判断三位数的：个位、十位、百位的立方和 是否 等于 原数（i：每次循环找出的三位数）
    if (ge*ge*ge + shi*shi*shi + bai*bai*bai == i) {
        // 4.找出水仙花数后，平坦输出，用空格隔开
        System.out.print(i + "\t");	// 不加 ln 就是不换行的意思，"\t"是空格
    }
}

  • 在每循环找出一个水仙花数后，将个数累加

    // 5.在未进入循环之前，定义计数器变量，用于存放每循环找出一个水仙花数，就累加个数
int count = 0;
// 1.使用for循环来取出所有三位数：从100开始到999结束
for (int i = 100; i < 1000) {
    // 2.提取出三位数的：个位、十位、百位，用变量存放起来
    // 个位
    int ge = i % 10;
    // 十位
    int shi = i / 10 % 10;
    // 百位
    int bai = i / 100;
    
    // 3.用if判断三位数的：个位、十位、百位的立方和 是否 等于 原数（i：每次循环找出的三位数）
    if (ge*ge*ge + shi*shi*shi + bai*bai*bai == i) {
        // 4.找出水仙花数后，平坦输出，用空格隔开
        System.out.print(i + "\t");	// 不加 ln 就是不换行的意思，"\t"是空格
        // 6.在每循环找出一个水仙花数后，将个数累加
        count++;
    }
}

  • 在控制台输出水仙花数总个数，用换行转义符隔开

    // 5.在未进入循环之前，定义计数器变量，用于存放每循环找出一个水仙花数，就累加个数
int count = 0;
// 1.使用for循环来取出所有三位数：从100开始到999结束
for (int i = 100; i < 1000) {
    // 2.提取出三位数的：个位、十位、百位，用变量存放起来
    // 个位
    int ge = i % 10;
    // 十位
    int shi = i / 10 % 10;
    // 百位
    int bai = i / 100;
    
    // 3.用if判断三位数的：个位、十位、百位的立方和 是否 等于 原数（i：每次循环找出的三位数）
    if (ge*ge*ge + shi*shi*shi + bai*bai*bai == i) {
        // 4.找出水仙花数后，平坦输出，用空格隔开
        System.out.print(i + "\t");	// 不加 ln 就是不换行的意思，"\t"是空格
        // 6.在每循环找出一个水仙花数后，将个数累加
        count++;
    }
}
// 7.在控制台输出水仙花数总个数，用换行转义符隔开
System.out.println("\n水仙花数的总共有：" + count + "个"); // "\n"：换行的意思
学不会is dog
关注
专栏目录
Java循环结构之for循环
weixin_43873578的博客
03-28 530
for循环结构: 语法结构： for（初始表达式；布尔表达式，迭代因子）{ 循环体； } for循环语句是支持迭代的一种通用结构，是最有效，最灵活的循环结构。for循环在第一次反复之前要进行初始化，即执行表达式；随后，对布尔表达式进行判断，若判断结果为true，则执行循环体，否则，终止循环；最后每一次反复的时候，进行某种形式的“步进”，即执行迭代因子。 初始化部分设置循环变量的初值 条件判断部分为任意布尔表达式 迭代因子控制循环变量的递增 for循环在执行条件判断后，先...
java中For循环结构
lv121218的博客
11-01 1435
java中For循环结构
Java：for循环结构
weixin_44695358的博客
06-18 152
循环结构 有一些代码需要重复执行。如果没有循环结构，这段代码就要重复编写。 把需要反复执行的代码片段放在循环体里，再联合计数器，共同控制需要反复执行的代码。 支持的循环有三种： for循环 while循环 do···while循环 for循环语法结构： for(初始化表达式；布尔表达式；更新表达式){ //需要循环执行的代码 } for的执行过程、执行原理（非常重要） 1.初始化表达式，布尔表达式，更新表达式都不是必须的，但是分号必须要写 2.初始化表达式最先执行，并且在整个for循环中只执行一次
java for循环结构_Java循环结构
weixin_31140599的博客
02-24 176
Java循环结构-for，while和do...while顺序结构的程序语句只能被执行一次。如果您想要同样的操作执行多次，就需要使用循环结构。while循环do...while循环for循环在Java5中引入了一种主要用于数组的增强型for循环(for-each循环？三目运算符？)Java增强for循环Java增强for循环语法格式如下：for(声明语句：表达式){//代码句子}声明语句：声明新的...
Java增强for循环
暖心~的博客
03-09 2230
Java5引入了一种主要用于数组的增强型for循环。 格式如下： 声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。 表达式：表达式是要访问的数组名，或者是返回值为数组的方法。public class Test{ public static void main(String args[]){ int []
Java循环结构for语句while语句详解-Java教程
11-22
在Java中，有两种主要的循环结构：for循环和while循环，这两种循环在编写控制流程、处理数组、迭代集合等场景时非常常见。 **一、for循环** for循环是一种预定义迭代的循环结构，适用于已知循环次数的情况。基本...
java源码嵌套for循环-fortress-lang:要塞长
06-05
在Java编程语言中，"嵌套for循环"是一种常见的编程结构，它允许在现有的for循环内部再嵌套一个或多个for循环。这种技术通常用于处理二维数组、矩阵运算、图遍历、查找算法等复杂逻辑。`fortress-lang:要塞长`可能是...
java源码嵌套for循环-cs-wikipedia-philosophy-lab-codeU:cs-wikipedia-philosophy
06-05
循环的java源码压缩cs-wikipedia-philosophy-lab 目标 为应用程序选择数据结构。 使用Java数据结构编写一个简单的网络爬虫。 概述 本实验室的目标是编写一个网络爬虫来测试我们在上一个实验室中提出的“Getting to ...
java源码嵌套for循环-edi-json:将EDI序列化为JSON
06-05
循环的java源码压缩| | | | | | | EDI ...事务中的段循环结构 版本意识； 例如，4010 与 5010 增强对 X12 HIPAA 医疗保健交易的支持 270, 271, 276, 277, 278, 834, 835, 837 JSON 反映循环限定符；
Java-forloop:使用for循环显示结果
05-20
Java的for循环是编程中最基本且常用的控制流程结构之一，它在处理迭代和重复执行的任务时非常有效。在这个场景中，我们关注的是如何利用for循环在Java中显示特定的结果。让我们深入探讨Java for循环的工作原理、语法...
【Java语言】— 循环结构 ：for循环
衍生星球的博客
01-01 1354
求1-10之间的奇数和，并把求和结果在控制台输出。 求1-5之间的数据和，并把求和结果在控制台输出。 如何知道水仙花数的个数呢？
Java中常用的for循环语法格式
最新发布
weixin_40031087的博客
01-18 1454
对Iterator进行迭代的案例。对Hashtable进行迭代的案例。
java中for循环
qq_42073385的博客
07-31 729
循环语句-for循环 循环： 循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复 执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形 成死循环。 for循环格式： for (初始化语句;条件判断语句;条件控制语句) { 循环体语句; } 格式解释： 初始化语句： 用于表示循环开启时的起始状态，简单说就是循环开始的时候什么样 条件判断语句：用于表示循环反复执行的条件，简单说就是判断
java里面的for循环的格式
流氓兔-程序猿博客
11-07 1205
for(String s : arr)： 其实本质上和for(int i=0;i
Java for循环格式及案例
weixin_48553717的博客
04-29 365
Java for循环格式及案例 for循环语句格式： for(初始化语句;判断条件语句;控制条件语句) { 循环体语句; } 执行流程： A:执行初始化语句 B:执行判断条件语句，看其结果是true还是false 如果是false，循环结束。 如果是true，继续执行。 C:执行循环体语句 D:执行控制条件语句 E:回到B继续 for循环的执行流程图： 代码案例： public class ForDemo { public static ...
Java——循环语句
CSDN_Acjun的博客
01-03 2485
Java的循环语句
Java循环结构：for循环
weixin_58618735的博客
10-26 847
Java循环结构：for循环
Java—for循环的格式，紧急注意，基础例题：1到100的和，易上手
weixin_52168253的博客
02-09 2086
for循环for循环基础格式深入了解for循环for循环例题 for循环基础格式 下面展示一些 for循环的四种格式 for循环一般格式 for（初始化表达式；布尔表达式；步进表达式）{ 循环体 } 这种for循环格式省略了初始化表达式，那么就需要在循环前声明循环变量 for（；布尔表达式；步进表达式）{ 循环体 } 这种for循环格式省略了布尔表达式，意味着该循环进入了死循环 for（初始化表达式；；步进
Java中最常用的循环--for循环
程序员大腾的博客
01-12 7324
记述Java中最常用的循环--for循环
Java循环结构详解：for, while, do-while示例
以下是基于给定文件信息中的各个部分解析出的Java循环结构知识点： 1. **While循环**： - `while`循环在条件满足时执行循环体内的代码。例如，2.1部分展示了如何输出1到5的数字，通过初始化`n=1`，然后在每次循环...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值