for 与 while：重复做一件事

for 适合“次数已知”的重复：

for (初始化; 条件; 更新) {
    循环体;
}

执行顺序不是“初始化→条件→更新→循环体”，而是：

1. 初始化只做一次；
2. 判断条件，true 才进入循环体；
3. 循环体执行完，再做更新；
4. 回到第 2 步继续判断。

先预测：下面的程序会打印几次“第 N 次”？如果把 i <= 5 改成 i < 5，会打印几次？

建目录、写 ForCountDemo.java。同名文件存在时先备份，不覆盖你上次的内容：

$ source ~/java-practice/env.sh
$ java -version
$ javac -version
$ mkdir -p ~/java-practice/lesson05
$ cd ~/java-practice/lesson05
$ if [ -e ForCountDemo.java ]; then mv ForCountDemo.java "ForCountDemo.java.bak.$(date +%s)"; fi
$ nano ForCountDemo.java

把下面这个完整文件粘进 nano，按 Ctrl+O 回车保存，再按 Ctrl+X 退出：

public class ForCountDemo {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            System.out.println("第 " + i + " 次");
        }
        System.out.println("循环结束");
    }
}

$ ls -l ForCountDemo.java
$ javac -encoding UTF-8 ForCountDemo.java
$ java ForCountDemo

第 1 次
第 2 次
第 3 次
第 4 次
第 5 次
循环结束

i 从 1 开始，每次循环体结束后 i++，条件 i <= 5 在 1、2、3、4、5 时都为 true，所以循环体执行 5 次；i 变成 6 时条件为 false，循环结束，接着执行循环后面的“循环结束”。

i 是 for 里声明的变量，作用范围只在 for 的圆括号和花括号里；循环结束后再写 System.out.println(i); 会编译错误。现在不用记术语，先记住“i 出了循环就不能用”。

循环经常用来“累加”：先把结果变量初始化，再在循环体里一次次更新。比如求 1 到 100 的和：

int sum = 0;
for (...) {
    sum = sum + i;
}

sum = sum + i 先算右边的 sum + i，再把结果赋回左边的 sum。所以 sum 会保留上一次的值，越加越大。如果循环体里忘了写这行，sum 会一直是 0；如果把 int sum = 0; 写在循环体里面，每次循环都会把 sum 重置成 0，最后只剩最后一个数。

先预测：1 到 100 的和是多少？如果只加到 5，sum 最后是多少？

$ cd ~/java-practice/lesson05
$ if [ -e ForSumDemo.java ]; then mv ForSumDemo.java "ForSumDemo.java.bak.$(date +%s)"; fi
$ nano ForSumDemo.java

public class ForSumDemo {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            sum = sum + i;
        }
        System.out.println("1 到 100 的和是：" + sum);
    }
}

$ javac -encoding UTF-8 ForSumDemo.java
$ java ForSumDemo

1 到 100 的和是：5050

sum 在循环前是 0；第 1 次加 1 变 1，第 2 次加 2 变 3，第 3 次加 3 变 6……循环结束后 sum 就是 5050。循环体里没有打印，所以中间过程看不见，只有最后一行输出。

把 i <= 100 改成 i <= 5，和会变成 15（1+2+3+4+5），但打印文字还写着“1 到 100”，记得一起改。先在小范围核对，再推广到 100，是检查循环边界的常用方法。

while 也能重复，但三个部分不挤在一行：

初始化;
while (条件) {
    循环体;
    更新;
}

for 把三部分写在圆括号里，适合次数明确的循环；while 把更新写在循环体里，适合“条件满足就一直做”的循环。两者可以互相改写，但 while 更容易漏掉更新。

先预测：下面的程序会打印哪些数字？如果删掉 i--; 这一行，会发生什么？

$ cd ~/java-practice/lesson05
$ if [ -e WhileCountDemo.java ]; then mv WhileCountDemo.java "WhileCountDemo.java.bak.$(date +%s)"; fi
$ nano WhileCountDemo.java

public class WhileCountDemo {
    public static void main(String[] args) {
        int i = 5;
        while (i >= 1) {
            System.out.println(i);
            i--;
        }
        System.out.println("发射！");
    }
}

$ javac -encoding UTF-8 WhileCountDemo.java
$ java WhileCountDemo

5
4
3
2
1
发射！

i 从 5 开始，条件 i >= 1 为 true，打印 5，然后 i-- 变成 4；再判断、再打印……直到 i 变成 0，条件为 false，循环结束，打印“发射！”。

如果删掉 i--;，i 永远是 5，5 >= 1 永远为 true，程序会不停打印 5，这就是死循环。在终端按 Ctrl+C 可以停掉当前程序；不要用关闭服务器或杀其他进程的方式解决。

do-while 是“先执行循环体，再判断条件”：

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

注意 while (条件) 后面有分号。即使条件一开始就是 false，循环体也会执行一次；这是它和 while 的唯一区别。本阶段只要求认识它，不要求用它写复杂逻辑。

先预测：i = 10，条件 i < 3 一开始就是 false，循环体会执行几次？

$ cd ~/java-practice/lesson05
$ if [ -e DoWhileDemo.java ]; then mv DoWhileDemo.java "DoWhileDemo.java.bak.$(date +%s)"; fi
$ nano DoWhileDemo.java

public class DoWhileDemo {
    public static void main(String[] args) {
        int i = 10;
        do {
            System.out.println("执行一次，i = " + i);
            i++;
        } while (i < 3);
        System.out.println("结束，i = " + i);
    }
}

$ javac -encoding UTF-8 DoWhileDemo.java
$ java DoWhileDemo

执行一次，i = 10
结束，i = 11

循环体先执行，打印 i = 10，然后 i++ 变成 11；这时才判断 11 < 3，结果为 false，循环结束。虽然条件一开始就不成立，循环体还是执行了一次。把 do-while 改成 while，同样的 i = 10 一次都不会执行。

break 的作用是立刻跳出当前这一层循环，不再判断条件，也不执行循环体剩下的部分。常见用途：找到一个满足条件的数就停。

先预测：1 到 50 中，第一个 7 的倍数是多少？循环会执行多少次？

$ cd ~/java-practice/lesson05
$ if [ -e BreakDemo.java ]; then mv BreakDemo.java "BreakDemo.java.bak.$(date +%s)"; fi
$ nano BreakDemo.java

public class BreakDemo {
    public static void main(String[] args) {
        int target = -1;
        for (int i = 1; i <= 50; i++) {
            if (i % 7 == 0) {
                target = i;
                break;
            }
        }
        System.out.println("1 到 50 中第一个 7 的倍数是：" + target);
    }
}

$ javac -encoding UTF-8 BreakDemo.java
$ java BreakDemo

1 到 50 中第一个 7 的倍数是：7

i 从 1 开始，前 6 次 i % 7 == 0 都是 false；i 到 7 时条件为 true，把 target 设为 7，break 立刻跳出 for，后面的 8 到 50 不再检查。target 在循环前初始化为 -1，是为了让变量在循环结束后仍然有值可打印；如果循环一次都没进，-1 就是一个“没找到”的标记。

break 只跳出离它最近的一层循环；如果是在 switch 里，它跳出的是 switch。本节只讨论循环里的 break。如果后面写嵌套循环，内层 break 不会把外层也停掉；这一点在第 7 步之后要记住。

continue 不结束整个循环，它只跳过当前这一次循环体里剩下的语句，直接进入下一次的更新和条件判断。

先预测：1 到 10 中，把所有“能被 3 整除”的数跳过，剩下的数相加是多少？

$ cd ~/java-practice/lesson05
$ if [ -e ContinueDemo.java ]; then mv ContinueDemo.java "ContinueDemo.java.bak.$(date +%s)"; fi
$ nano ContinueDemo.java

public class ContinueDemo {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 1; i <= 10; i++) {
            if (i % 3 == 0) {
                continue;
            }
            sum = sum + i;
        }
        System.out.println("1 到 10 中不能被 3 整除的数的和：" + sum);
    }
}

$ javac -encoding UTF-8 ContinueDemo.java
$ java ContinueDemo

1 到 10 中不能被 3 整除的数的和：37

i 为 3、6、9 时，i % 3 == 0 成立，continue 跳过 sum = sum + i;，直接进入下一次 i++；其他数正常累加。1+2+4+5+7+8+10 = 37。

在 for 里，continue 之后仍会执行圆括号里的 i++，所以不会死循环。在 while 里要特别小心：如果更新写在 continue 后面，continue 会跳过更新，循环变量不变，可能变成死循环。初学阶段先把更新写在循环体最前面，或改用 for。

循环里再写一个循环叫嵌套。外层每走一次，内层都要从头到尾走一遍。下面用两层循环打印 3 行、每行 4 个星号：

$ cd ~/java-practice/lesson05
$ if [ -e NestedDemo.java ]; then mv NestedDemo.java "NestedDemo.java.bak.$(date +%s)"; fi
$ nano NestedDemo.java

public class NestedDemo {
    public static void main(String[] args) {
        String line = "";
        for (int row = 1; row <= 3; row++) {
            line = "";
            for (int col = 1; col <= 4; col++) {
                line = line + "*";
            }
            System.out.println(line);
        }
        System.out.println("共 3 行，每行 4 个星");
    }
}

$ javac -encoding UTF-8 NestedDemo.java
$ java NestedDemo

****
****
****
共 3 行，每行 4 个星

外层 row 从 1 到 3，共 3 次；每次外层循环体里，先把 line 清空，再让内层 col 从 1 到 4 走 4 次，每次往 line 后面接一个 *。内层结束后 line 是 "****"，打印出来并换行。所以总共打印 3 行，每行 4 个星，内层循环体一共执行 3 × 4 = 12 次。

先预测：如果把外层改成 row <= 2、内层改成 col <= 5，会打印几行、每行几个星？内层循环体总共执行多少次？