【Java SE 基础学习打卡】25 循环结构 - for

目录

• 前言
• [一、先搞懂：for 循环的核心逻辑（为什么它更高效？）](#一、先搞懂：for 循环的核心逻辑（为什么它更高效？）)
• • [1.1 和 while 循环的核心区别（小白必记）](#1.1 和 while 循环的核心区别（小白必记）)
  • [1.2 for 循环的核心前提（必须记牢）](#1.2 for 循环的核心前提（必须记牢）)
• [二、吃透 for 循环语法](#二、吃透 for 循环语法)
• • [2.1 完整语法（死记硬背）](#2.1 完整语法（死记硬背）)
  • [2.2 逐部分拆解](#2.2 逐部分拆解)
  • • [（1）初始化表达式：循环的 "起点"](#（1）初始化表达式：循环的 “起点”)
    • [（2）循环条件：循环的 "终点判断"](#（2）循环条件：循环的 “终点判断”)
    • [（3）更新表达式：循环的 "步长"](#（3）更新表达式：循环的 “步长”)
    • [（4）循环体：重复执行的 "核心操作"](#（4）循环体：重复执行的 “核心操作”)
  • [2.3 执行顺序拆解（关键！搞懂顺序才不会错）](#2.3 执行顺序拆解（关键！搞懂顺序才不会错）)
• 三、实战例子：从基础到进阶，覆盖常见场景
• • [3.1 场景 1：打印 1 到 10 的数字（基础用法）](#3.1 场景 1：打印 1 到 10 的数字（基础用法）)
  • [3.2 场景 2：计算 1 到 100 的和（实用用法）](#3.2 场景 2：计算 1 到 100 的和（实用用法）)
  • [3.3 场景 3：打印 1 到 20 的奇数（自定义步长）](#3.3 场景 3：打印 1 到 20 的奇数（自定义步长）)
  • [3.4 场景 4：倒计时（更新表达式为减 1）](#3.4 场景 4：倒计时（更新表达式为减 1）)
• [四、for 循环的灵活用法（基础阶段了解即可）](#四、for 循环的灵活用法（基础阶段了解即可）)
• • [4.1 省略初始化表达式（已有循环变量）](#4.1 省略初始化表达式（已有循环变量）)
  • [4.2 省略更新表达式（循环体里更新）](#4.2 省略更新表达式（循环体里更新）)
  • [4.3 省略循环条件（死循环，需用 break 跳出）](#4.3 省略循环条件（死循环，需用 break 跳出）)
• [五、新手必避的 6 个 "致命坑"](#五、新手必避的 6 个 “致命坑”)
• • [5.1 坑 1：初始化表达式后加了分号](#5.1 坑 1：初始化表达式后加了分号)
  • [5.2 坑 2：循环条件写反，导致循环不执行](#5.2 坑 2：循环条件写反，导致循环不执行)
  • [5.3 坑 3：更新表达式错误，导致死循环](#5.3 坑 3：更新表达式错误，导致死循环)
  • [5.4 坑 4：循环体漏加大括号，导致只有第一行执行循环](#5.4 坑 4：循环体漏加大括号，导致只有第一行执行循环)
  • [5.5 坑 5：循环变量在循环外使用](#5.5 坑 5：循环变量在循环外使用)
• [六、for 和 while 怎么选？（新手决策指南）](#六、for 和 while 怎么选？（新手决策指南）)
• 总结

前言

上一节咱们学了 while 和 do-while 循环，能搞定 "重复做事" 的场景，但如果遇到 "明确知道循环次数" 的情况 ------ 比如 "打印 1 到 100 的数字""打卡 7 天""计算 5 门课的平均分"，用 while 写虽然能实现，但要单独定义初始值、更新值，代码不够紧凑。

这时候 for 循环就该登场了！它把 "初始值、循环条件、更新值" 三个核心要素整合在一行，写法简洁、逻辑清晰，是处理 "固定次数循环" 的首选。这一节咱们就把 for 循环讲透：先搞懂核心逻辑（和 while 的区别），再学语法模板、实战例子（包括基础用法和嵌套用法），最后避开新手常踩的坑 ------ 全程用生活化场景 + 超详细注释，保证刚学完 while 循环的你能快速上手！

一、先搞懂：for 循环的核心逻辑（为什么它更高效？）

for 循环的本质和 while 循环完全一致：满足条件就重复执行代码块，直到条件不满足停止。它的优势在于：把循环的 "初始值、条件、更新值" 集中放在一起，一眼就能看清循环的 "起点、终点、步长"，不用在代码里找来找去。

1.1 和 while 循环的核心区别（小白必记）

特点	for 循环	while 循环
核心要素位置	三要素（初始值、条件、更新）写在一行，紧凑清晰	三要素分散在代码中（初始值在循环前，更新值在循环体里）
适用场景	明确知道循环次数（比如 10 次、1 到 100）	不确定循环次数（比如找符合条件的数据、等待用户操作）
代码简洁度	固定次数循环时更简洁，减少冗余	不确定次数时更灵活，逻辑更直观

举个直观例子：打印 1 到 5 的数字

• 用 while 写（三要素分散）：

  int i = 1; // 初始值（循环前）
  while (i <= 5) { // 条件
      System.out.println(i);
      i++; // 更新值（循环体里）
  }

• 用 for 写（三要素集中）：

  for (int i = 1; i <= 5; i++) { // 初始值、条件、更新值一行搞定
      System.out.println(i);
  }

两者执行结果完全一样，但 for 循环的代码更紧凑，一眼就能看出 "从 1 开始，到 5 结束，每次加 1"。

1.2 for 循环的核心前提（必须记牢）

1. 三要素可以省略，但分号不能少：for (;;) { ... } 是合法的（死循环），但基础阶段不建议这么写；

2. 初始值可以定义循环变量（比如int i = 1），这个变量只在循环体内有效（循环结束后就不能用了）；

3. 更新值可以是 "加 1""减 1""加 2" 等（比如i++"i--""i+=2"），决定循环的 "步长"。

二、吃透 for 循环语法

2.1 完整语法（死记硬背）

for (初始化表达式; 循环条件; 更新表达式) {
    // 循环体：要重复执行的代码（1行或多行）
    执行语句;
}

2.2 逐部分拆解

（1）初始化表达式：循环的 "起点"

• 作用：定义循环变量并赋初始值（比如int i = 1），或初始化已有变量（比如i = 1）；

• 执行时机：整个循环只执行一次（循环开始前执行）；

• 合法写法：

  • 定义并初始化：int i = 1（推荐，变量作用域仅限循环体）；

  • 初始化已有变量：i = 1（需提前定义int i;）；

  • 多个变量初始化：int i = 1, j = 5（用逗号分隔，少见但合法）；

• 注意：不能在这里写判断或执行语句（比如int i = 1; i <=5是错的）。

（2）循环条件：循环的 "终点判断"

• 作用：判断是否继续循环，必须是布尔表达式（true/false）；

• 执行时机：每次循环体执行前都要判断（包括第一次执行循环体前）；

• 合法写法：i <= 10、j > 0、count < 5；

• 注意：和 while 循环一样，条件为true才执行循环体，为false则跳出循环。

（3）更新表达式：循环的 "步长"

• 作用：修改循环变量的值，让循环条件有机会变成false（避免死循环）；

• 执行时机：每次循环体执行完后执行（先执行循环体，再更新变量）；

• 合法写法：

  • 加 1：i++（最常用，等价于i = i + 1）；

  • 减 1：i--（比如倒计时场景）；

  • 自定义步长：i += 2（每次加 2，打印奇数）、i -= 3（每次减 3）；

• 注意：不能在这里写赋值语句以外的代码（比如i++ && j++是错的）。

（4）循环体：重复执行的 "核心操作"

• 作用：存放要重复执行的代码（比如打印、计算、赋值）；

• 注意事项：

  • 用{ }包裹，哪怕只有一行代码也建议加（避免逻辑失控）；

  • 循环体内可以使用循环变量（比如i），也可以修改其他变量（比如累加求和的sum）。

2.3 执行顺序拆解（关键！搞懂顺序才不会错）

以 "打印 1 到 5" 的 for 循环为例，执行顺序是：

for (int i = 1; i <= 5; i++) {
    System.out.println(i);
}

1. 初始化：int i = 1（只执行一次）；

2. 判断条件：1 <= 5→true，执行循环体（打印 1）；

3. 更新变量：i++→i=2；

4. 再次判断条件：2 <= 5→true，执行循环体（打印 2）；

5. 再次更新变量：i++→i=3；

6. 重复步骤 4-5，直到i=6；

7. 判断条件：6 <= 5→false，跳出循环。

一句话总结执行顺序：初始化 → 判断 → 循环体 → 更新 → 判断 → 循环体 → 更新 → ... → 判断为 false 跳出。

三、实战例子：从基础到进阶，覆盖常见场景

3.1 场景 1：打印 1 到 10 的数字（基础用法）

代码示例

public static void main(String[] args) {
    // for循环三要素：
    // 初始化：int i = 1（从1开始）
    // 条件：i <= 10（到10结束）
    // 更新：i++（每次加1）
    for (int i = 1; i <= 10; i++) {
        System.out.println("当前数字：" + i);
    }

    // 循环结束后，i不能再使用（因为i是循环内定义的变量）
    // System.out.println(i); // 报错：无法解析符号i
}

执行结果：

当前数字：1
当前数字：2
...
当前数字：10

3.2 场景 2：计算 1 到 100 的和（实用用法）

public static void main(String[] args) {
    int sum = 0; // 存储总和的变量（初始为0）

    // 循环1到100，每次把i加到sum里
    for (int i = 1; i <= 100; i++) {
        sum += i; // 等价于sum = sum + i（累加）
    }

    System.out.println("1到100的和：" + sum); // 输出5050
}

3.3 场景 3：打印 1 到 20 的奇数（自定义步长）

public static void main(String[] args) {
    // 更新表达式用i += 2（每次加2，步长为2）
    for (int i = 1; i <= 20; i += 2) {
        System.out.print(i + " "); // 用print不换行，空格分隔
    }
    // 执行结果：1 3 5 7 9 11 13 15 17 19
}

3.4 场景 4：倒计时（更新表达式为减 1）

public static void main(String[] args) {
    System.out.println("倒计时开始！");
    // 初始化：10（从10开始），条件：>=0（到0结束），更新：i--（每次减1）
    for (int i = 10; i >= 0; i--) {
        System.out.println("倒计时：" + i);
    }
    System.out.println("倒计时结束！");
}

四、for 循环的灵活用法（基础阶段了解即可）

for 循环的三要素都可以省略，但分号不能少，适合一些特殊场景（基础阶段先掌握标准写法，灵活用法了解即可）：

4.1 省略初始化表达式（已有循环变量）

public static void main(String[] args) {
    int i = 1; // 提前定义并初始化循环变量
    for (; i <= 5; i++) { // 省略初始化表达式，分号不能少
        System.out.println(i);
    }
}

4.2 省略更新表达式（循环体里更新）

public static void main(String[] args) {
    for (int i = 1; i <= 5; ) { // 省略更新表达式，分号不能少
        System.out.println(i);
        i++; // 在循环体里更新变量
    }
}

4.3 省略循环条件（死循环，需用 break 跳出）

public static void main(String[] args) {
    int count = 0;
    for (;;) { // 省略所有三要素，分号不能少（死循环）
        System.out.println("循环次数：" + (++count));
        if (count == 3) { // 条件满足时跳出循环
            break;
        }
    }
    // 执行结果：循环次数1、2、3
}

注意：灵活用法不推荐新手常用

基础阶段建议用 "标准写法"（三要素齐全），代码更清晰、不易出错。灵活用法只在特殊场景（比如循环变量需要在循环外使用）才考虑。

五、新手必避的 6 个 "致命坑"

5.1 坑 1：初始化表达式后加了分号

• 错误示例：

  for (int i = 1; i <= 5; i++); { // 循环条件后加了分号
      System.out.println(i);
  }

• 后果：分号表示 for 循环结束，循环体（大括号里的代码）不受循环控制，还会报错（i 是循环内变量，外部无法访问）；

• 正确示例：

  for (int i = 1; i <= 5; i++) { // 去掉分号
      System.out.println(i);
  }

5.2 坑 2：循环条件写反，导致循环不执行

• 错误示例：

  for (int i = 5; i <= 1; i++) { // 条件i<=1，初始i=5，一开始就不成立
      System.out.println(i); // 一次都不执行
  }

• 后果：循环体不执行，达不到预期效果；

• 正确示例：

  for (int i = 5; i >= 1; i--) { // 条件改为i>=1，更新为i--
      System.out.println(i); // 打印5、4、3、2、1
  }

5.3 坑 3：更新表达式错误，导致死循环

• 错误示例：

  for (int i = 1; i <= 5; i--) { // 更新表达式为i--，i越来越小
      System.out.println(i); // 死循环，一直打印1、0、-1...
  }

• 后果 ：循环条件永远为true（i 一直小于等于 5），陷入死循环；

• 正确示例：

  for (int i = 1; i <= 5; i++) { // 更新表达式为i++
      System.out.println(i);
  }

5.4 坑 4：循环体漏加大括号，导致只有第一行执行循环

• 错误示例：

  for (int i = 1; i <= 3; i++)
      System.out.println("循环中：" + i);
      System.out.println("循环外：" + i); // 不受循环控制，还报错（i未定义）

• 后果：第二行代码不受循环控制，且 i 是循环内变量，外部无法访问，编译报错；

• 正确示例：

  for (int i = 1; i <= 3; i++) {
      System.out.println("循环中：" + i);
      // 如需在循环外使用i，需提前定义
  }

5.5 坑 5：循环变量在循环外使用

• 错误示例：

  for (int i = 1; i <= 5; i++) {
      System.out.println(i);
  }
  System.out.println("循环最后一个数字：" + i); // 报错：无法解析符号i

• 后果：循环内定义的变量 i，作用域仅限循环体，循环结束后失效，编译报错；

• 正确示例：

  int i; // 提前在循环外定义
  for (i = 1; i <= 5; i++) { // 初始化表达式直接赋值
      System.out.println(i);
  }
  System.out.println("循环最后一个数字：" + i); // 输出6

六、for 和 while 怎么选？（新手决策指南）

记住两个简单原则，不用纠结：

1. 知道循环次数（比如 10 次、1 到 100、5 门课）→ 用 for 循环（代码简洁）；

2. 不知道循环次数（比如找符合条件的数据、等待用户输入正确密码）→ 用 while 循环（逻辑灵活）。

举个对比例子：

• 打印 1 到 100 → for 循环（知道次数 100）；

• 猜数字游戏（直到猜对为止）→ while 循环（不知道要猜几次）。

总结

这一节咱们学了 for 循环的核心用法，记住 3 个核心点：

1. 核心优势：固定次数循环更简洁，三要素（初始值、条件、更新值）集中一行；

2. 执行顺序：初始化（1 次）→ 判断→ 循环体→ 更新→ 重复判断；

3. 进阶用法：嵌套 for 循环（外层控行、内层控列），适合打印表格、乘法表等场景。

for 循环是 Java 里最常用的循环结构，掌握它后，处理固定次数的重复操作会非常高效。