Java中的循环

编程语言中的循环是一种有助于在某些条件评估为真时重复执行一组指令/函数的功能。
Java提供了三种执行循环的方法。虽然所有方法都提供了类似的基本功能，但它们的语法和条件检查时间不同。

while 循环： while 循环是一种控制流语句，它允许根据给定的布尔条件重复执行代码。 while 循环可以被认为是一个重复的 if 语句。
句法：
```
while (boolean condition)
{
   loop statements...
}
```
流程图：
- While 循环从检查条件开始。如果它评估为真，则执行循环体语句，否则执行循环后面的第一条语句。出于这个原因，它也被称为入口控制循环
- 一旦条件被评估为真，循环体中的语句就会被执行。通常，这些语句包含正在为下一次迭代处理的变量的更新值。
- 当条件变为假时，循环终止，这标志着其生命周期的结束。
```
// Java program to illustrate while loop
class whileLoopDemo
{
    public static void main(String args[])
    {
        int x = 1;
  
        // Exit when x becomes greater than 4
        while (x <= 4)
        {
            System.out.println("Value of x:" + x);
  
            // Increment the value of x for
            // next iteration
            x++;
        }
    }
}
```
输出：
```
Value of x:1
Value of x:2
Value of x:3
Value of x:4
```
for 循环： for 循环提供了一种简洁的方式来编写循环结构。与 while 循环不同，for 语句在一行中使用初始化、条件和递增/递减，从而提供更短、易于调试的循环结构。
句法：
```
for (initialization condition; testing condition; 
                              increment/decrement)
{
    statement(s)
}
```
流程图：
1. 初始化条件：这里，我们初始化正在使用的变量。它标志着一个 for 循环的开始。可以使用已经声明的变量，也可以声明变量，仅局部循环。
2. 测试条件：用于测试循环的退出条件。它必须返回一个布尔值。它也是一个入口控制循环，因为在执行循环语句之前检查了条件。
3. 语句执行：一旦条件被评估为真，循环体中的语句就会被执行。
4. 增量/减量：用于为下一次迭代更新变量。
5. 循环终止：当条件变为假时，循环终止，标志着其生命周期的结束。
```
// Java program to illustrate for loop.
class forLoopDemo
{
    public static void main(String args[])
    {
        // for loop begins when x=2
        // and runs till x <=4
        for (int x = 2; x <= 4; x++)
            System.out.println("Value of x:" + x);
    }
}
```
输出：
```
Value of x:2
Value of x:3
Value of x:4
```
增强的 For 循环
Java还包括在Java 5 中引入的另一个版本的 for 循环。增强的 for 循环提供了一种更简单的方法来遍历集合或数组的元素。它不灵活，只有在需要以顺序方式遍历元素而不知道当前处理的元素的索引时才应该使用它。
另请注意，当使用增强的 for 循环时，对象/变量是不可变的，即它确保数组中的值不能被修改，因此可以说是只读循环，您不能像相反的那样更新值可以修改值的其他循环。
我们建议尽可能使用这种形式的 for 语句而不是一般形式。（根据Java文档。）
句法：
```
for (T element:Collection obj/array)
{
    statement(s)
}
```
让我们举一个例子来演示如何使用增强的 for 循环来简化工作。假设有一个名称数组，我们想要打印该数组中的所有名称。让我们看看这两个例子之间的区别
增强的 for 循环简化了如下工作 -
```
// Java program to illustrate enhanced for loop
public class enhancedforloop
{
    public static void main(String args[])
    {
        String array[] = {"Ron", "Harry", "Hermoine"};
  
        //enhanced for loop
        for (String x:array)
        {
            System.out.println(x);
        }
  
        /* for loop for same function
        for (int i = 0; i < array.length; i++)
        {
            System.out.println(array[i]);
        }
        */
    }
}
```
输出：
```
Ron
Harry
Hermoine
```
do while： do while循环与while循环类似，不同之处在于它在执行语句后检查条件，因此是退出控制循环的一个例子。
句法：
```
do
{
    statements..
}
while (condition);
```
流程图：
1. do while 循环从执行语句开始。第一次没有检查任何条件。
2. 在执行语句和更新变量值之后，检查条件的真值或假值。如果它被评估为真，则循环的下一次迭代开始。
3. 当条件变为假时，循环终止，这标志着其生命周期的结束。
4. 重要的是要注意 do-while 循环将在检查任何条件之前至少执行一次其语句，因此是退出控制循环的一个示例。
```
// Java program to illustrate do-while loop
class dowhileloopDemo
{
    public static void main(String args[])
    {
        int x = 21;
        do
        {
            // The line will be printed even
            // if the condition is false
            System.out.println("Value of x:" + x);
            x++;
        }
        while (x < 20);
    }
}
```
输出：
```
Value of x: 21
```

循环的陷阱

无限循环：实现任何类型的循环时最常见的错误之一是它可能永远不会退出，即循环运行无限时间。当条件由于某种原因失败时会发生这种情况。
例子：

//Java program to illustrate various pitfalls.
public class LooppitfallsDemo
{
    public static void main(String[] args)
    {
  
        // infinite loop because condition is not apt
        // condition should have been i>0.
        for (int i = 5; i != 0; i -= 2)
        {
            System.out.println(i);
        }
        int x = 5;
  
        // infinite loop because update statement
        // is not provided.
        while (x == 5)
        {
            System.out.println("In the loop");
        }
    }
}

另一个陷阱是您可能会通过循环将某些内容添加到您的集合对象中，并且您可能会耗尽内存。如果您尝试执行以下程序，一段时间后，将抛出内存不足异常。

//Java program for out of memory exception.
import java.util.ArrayList;
public class Integer1
{
    public static void main(String[] args)
    {
        ArrayList ar = new ArrayList<>();
        for (int i = 0; i < Integer.MAX_VALUE; i++)
        {
            ar.add(i);
        }
    }
}

输出：

Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
at java.util.Arrays.copyOf(Unknown Source)
at java.util.Arrays.copyOf(Unknown Source)
at java.util.ArrayList.grow(Unknown Source)
at java.util.ArrayList.ensureCapacityInternal(Unknown Source)
at java.util.ArrayList.add(Unknown Source)
at article.Integer1.main(Integer1.java:9)