Java 中的循环

在本教程中，我们将了解如何在 Java 编程中使用循环语句或迭代语句，根据某些条件多次运行一组指令。众所周知，计算机可以不厌其烦地执行重复操作，无论是 10 次、100 次，甚至是 100000 次。因此，每种编程语言都具有此类功能来控制程序执行次数的流程。

循环类型

循环是控制流语句，它通过重复执行一组相同的语句直到满足终止条件，为控制程序的流程到不同的部分提供了一种方式。计算机编程语言中的循环有助于一组指令/函数重复执行到所需的次数，直到某些条件为真。代码块可以执行任意次数，从 0 到无限次。如果循环永远继续下去，则称为无限循环。

Java 有三种循环类型用于多次执行一组指令/函数。这些重复语句循环的基本功能相似，但它们在语法和工作时间上有所不同。此外，控制结构根据控制语句在循环中的位置，分为入口控制循环或出口控制循环。
Java 中的三种循环类型如下：

1. For 循环
2. While 循环 / 入口控制循环
3. Do while 循环 / 出口控制循环

让我们以表格形式了解循环的差异

现在我们可以详细了解 Java 中每个循环语句的工作原理。

JAVA 中的 FOR 循环

如果您知道需要执行代码块的次数，可以使用 For 循环。例如；如果您想检查公司员工的缺勤记录，您可以使用 for 循环，因为您知道办公室的员工数量。
For 循环是一种控制流语句，用于重复执行代码块多次，直到满足特定条件为止。
For 循环的结构如下：

• 初始化
• 条件/测试语句
• 更新语句/递增或递减表达式

for 循环语法的时序如下：

for(initialization; testing_condition; increment/ decrement) 
{ 
// Block of codes 
/ statements …… 
…... 
}
 

Java for 循环流程图

for 循环语句的执行如下：

1. For 循环中的初始化

   在这里，我们使用一个起始值初始化控制变量，该变量充当 for 循环的开始。for 循环的初始化部分只执行一次，并且在测试条件之前在循环开始时执行。另外，请注意初始化是可选的。

   让我们看一个例子；

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

   int i=0 是初始化部分，其中整型变量i初始化为值0。

2. For 循环中的测试条件

   这一部分是为循环执行提供测试条件。应仔细陈述测试条件，以执行所需的执行次数或确定循环何时退出。测试条件在每次迭代时重复，直到满足/满足条件才终止。
   在上面的例子中，变量的值被测试，即i <5是要测试的条件；表示变量 i 必须小于 5，否则，循环将终止，控制将转移到循环之后的语句。

3. For 循环中的更新语句 

   通常称为递增/递减表达式。它通常用于在每次迭代后更新控制变量，在语句部分迭代完成后每次执行。for 循环也允许负数递减。
   在上面的例子中，i++ 是更新语句。当条件为真时，控制进入循环执行语句/代码块，并且在整个迭代完成后，变量的值会增加1, i=i+1。然后将控制变量的新值与条件进行测试。

现在让我们看一个例子来理解 for 循环中的迭代。
 

class ForLoopEx {
    public static void main(String[] args) {
      for( int i=0; i<=10; i++)
         {
        System.out.println(i*i);
        }
    }
}

 

这个 for 循环执行 11 次，并在同一行打印 0 到 10 的数字的平方。

输出

0
1
4
9
16
25
36
49
64

For 循环的其他功能

For 循环有许多其他功能。

1. 一次可以初始化多个变量。

   语句 n=1; for(i=0; i<=10; i++) 可以写成

   
   for(n=1; i=0; i<=10; i++)
    
   

2. 增量部分也有多个部分。

   
   for(n=1; i=10; n<=i; n++,i--)
   {
     ……
     ……
   }
    
   

3. 测试条件具有任何复合关系，并且测试不必限于循环控制变量。

   
   sum=0;
   for(i=1, i<10 && sum<50; i++)
   {
     ……
     ……
   }
   
    
   

Java 中的嵌套 For 循环

在 Java 中，一个 for 循环内嵌套另一个 for 循环称为循环嵌套。每个语句都应正确陈述，以便轻松确定哪些语句属于哪个 for 循环。

for (i=1; i<10; i++)
 {
    ……
    ……
    for (j=1; j<=5; j++)
    {
       …..
       …..
    }
    ……
    …..
 }
 …….
 ……
 

例如，

public class NestedLoopEx {
    public static void main(String args[]) {
        int i, j, row = 10;

        for (i = 0; i & lt; row; i++) // loop 1 returns the number of rows
        {
            for (j = 0; j & lt; = i; j++) // loop 2 returns the number of columns
            {
                System.out.print( & quot;* & quot;); // prints *
            }
            System.out.println(); // next line
        }
    }
}

输出

* 
* * 
* * * 
* * * * 
* * * * * 
* * * * * * 
* * * * * * * 
* * * * * * * * 

增强 For 循环

也称为 for each 循环，它用于检索数组元素，而不是使用数组索引。此功能有助于遍历数组元素，从而提高代码的可读性。forEach 循环中要注意的一点是，它不允许反向遍历元素。增强的 for 循环允许在 for 循环中消除迭代器并从集合中检索元素。

语法

for (Type Identifier : Expression)
 {  
  //statements;
 }

 

此处，

•  Type 代表数据类型或使用的对象
•  Identifier 指变量的名称
•  Expression 是 java. lang.Iterable 接口的实例或数组

While 循环

While 循环也称为入口控制循环。这是 Java 中最简单的循环结构，它检查为 while 循环指定的条件。While 循环是 Java 的基本循环语句，它在特定测试条件为真时持续执行代码块。

While 循环评估必须返回布尔值的条件，如果条件为真，则 while 循环执行 while 循环中的代码块。这会持续测试表达式，直到条件求值为 false，并将迭代的控制转移出循环。如果测试条件为假，则不会执行，并且将执行紧跟在循环之后的代码。

在 Java 程序中定义 While 循环语句的基本格式为：

Initialization:
While (test condition)
{
 Body of the loop
}

 

While 迭代语句如下：

 

使用 While 循环的程序

class HelloWorld {
    public static void main(String[] args) {
    int i;
    i=0;
    while (i<=10)
       {
          System.out.println(i*i);
          i=i+1;
      }
    }
}

 

输出

0
1
4
9
16
25
36
49
64

请注意，我们给了i一个初始值0。在第一个周期，“while”检查它是否小于或等于 10。由于0<10，代码执行并打印 0 的平方，为0。语句'i=i+1'将'i'的值从0增加到1.现在“while”再次检查并发现 1<10，因此打印 1 的平方，即 1。类似地，打印 2,3,4,....直到 10。但是，在最后一个循环的最后一条语句中，'i'变为11'。因此，“while”发现 11 既不小于也不等于10，循环终止。

Java 中的嵌套 WHILE 循环

Java 允许包含嵌套的 while 循环，即 while 循环内嵌套另一个 while 循环。您可以在嵌套概念中包含任意数量的 while 循环。

语法

While()
{
While()
{
…..
…..
}
….
}

 

请看下面的例子，使用嵌套的 while 循环打印乘法表。

class NestedWhileLoopEx {
    public static void main(String[] args) {
     int i=1;
     while(i<2)
     {
        int j =1;
         while(j<=10)
        {
        System.out.printf("%d * %d = %d \n", i, j, i * j);
        j=j + 1;
        }
     i=i + 1;

    }
}
}
 

输出

1 x 1 = 1
1 x 2 = 2
1 x 3 = 3
1 x 4 = 4
1 x 5 = 5
1 x 6 = 6
1 x 7 = 7
1 x 8 = 8
1 x 9 = 9
1 x 10 = 10

Java 中的 do-while 语句

在 While 循环中，它在循环执行之前测试条件。因此，如果条件不满足，循环体可能不会执行。在某些程序中，在执行测试之前执行循环体是必要的。在这种情况下，可以使用 do-while 循环。与 For 循环和 While 循环不同，do-while 循环在测试条件之前至少执行一次循环体。do-while 循环保证在第一次尝试时就执行一次循环。

Java 编程语言中的 do-while 循环可以表示为：

Initialization:
do
{
 Body of the loop
}
While (test condition);

 

do-while 循环是一种控制流语句，它在执行底部测试条件之前先评估循环体。从语法可以看出，while 语句中的测试条件在循环末尾进行测试；它提供了一个出口控制循环。因此，do-while 循环也称为出口控制循环。

如果布尔条件得到满足，程序控制将再次评估循环体。这会一直持续到条件为真。一旦条件变为假，控制就会转移到 while 语句之后的紧邻语句。

public class DoWhileEx {    
public static void main(String[] args) {    
    int i=0;    
    do{    
        System.out.println(i*i);    
    i++;    
    }while(i<=10);    
}    
}    

 

输出

0
1
4
9
16
25
36
49

While 与 do-While 的区别