顺序结构的程序语句只能被执行一次。如果您想要同样的操作执行多次,，就需要使用循环结构。
Java中有三种主要的循环结构：

  • while 循环
  • do…while 循环

  • for 循环

    while 循环

    while是最基本的循环，它的结构为：

    1. while( 布尔表达式 ) {
    2. //循环内容
    3. }

    只要布尔表达式为 true，循环就会一直执行下去。

    1. public class Test {
    2.  public static void main(String args[]) {
    3.     int x = 1;
    4.     while( x < 6 ) {
    5.        System.out.print("x的值为: " + x);
    6.        x++;
    7.        System.out.println();
    8.     }
    9.  }
    10. }

    以上实例编译运行结果如下：

    1. x的值为:1
    2. x的值为:2
    3. x的值为:3
    4. x的值为:4
    5. x的值为:5

    do…while 循环

    对于 while 语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。
    do…while 循环和 while 循环相似，不同的是，do…while 循环至少会执行一次。

    1. do {
    2.      //代码语句
    3. }while(布尔表达式);

    备注：布尔表达式在循环体的后面，所以语句块在检测布尔表达式之前已经执行了。 如果布尔表达式的值为 true，则语句块一直执行，直到布尔表达式的值为 false。

    1. public class Test {
    2.  public static void main(String args[]){
    3.     int x = 1;
    5.     do{
    6.        System.out.print(""x的值为: " + x );
    7.        x++;
    8.        System.out.println();
    9.     }while( x < 6 );
    10.  }
    11. }

    以上实例编译运行结果如下：

    1. x的值为:1
    2. x的值为:2
    3. x的值为:3
    4. x的值为:4
    5. x的值为:5

    for循环

    虽然所有循环结构都可以用 while 或者 do…while表示，但 Java 提供了另一种语句 —— for 循环，使一些循环结构变得更加简单。
    for循环执行的次数是在执行前就确定的。语法格式如下：
    for(初始化; 布尔表达式; 更新) { //代码语句}
    关于 for 循环有以下几点说明：

  • 最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。

  • 然后，检测布尔表达式的值。如果true，循环被执行。如果false，循环终止，开始执行循环体后面的语句。
  • 执行一次循环后，更新循环控制变量。
  • 再次检测布尔表达式。循环执行上面的过程。
    1. public class Test {
    2.   public static void main(String[] args) {
    3.       //for循环用来遍历数组（依次打印数组中每一个值）
    4.       int[] arr = {22,32,-40,80,10};
    5.       for (int i = 0; i < arr.length; i++){
    6.           System.out.print(arr[i]);
    7.       }
    8.       System.out.println();
    9.       //倒叙输出数组
    10.       for (int i = arr.length - 1; i >= 0; i--) {
    11.           System.out.print(arr[i]);
    12.       }
    13.   }
    14. }
    以上实例编译运行结果如下：
    1. 22 32 -40 80 10
    2. 10 80 -40 32 22
    求和思想，利用for循环求值
    1. public class Test {
    2.   public static void main(String[] args) {
    3.       /**
    4.        * 分别求出0-100中奇数和与偶数和
    5.        * evenNumbersSum 偶数和
    6.        * oddNumbersSum  奇数和
    7.        */
    8.       int evenNumbersSum = 0;
    9.       int oddNumbersSum = 0;
    10.       for (int i = 1;i<=100;i++){
    11.           //System.out.println(i);
    12.           if (i%2 == 0){
    13.               evenNumbersSum += i;
    14.           }else { //此处也可用if或者else if，判断条件可写 i%2 != 0;，因只有两种可能我就偷懒用else
    15.               oddNumbersSum += i;
    16.           }
    17.       }
    18.       System.out.println("0-100中偶数相加的和为"+evenNumbersSum);
    19.       System.out.println("0-100中奇数相加的和为"+oddNumbersSum);
    20.   }
    21. }
    以上实例编译运行结果如下：
    1. 0-100中偶数相加的和为2550
    2. 0-100中奇数相加的和为2500
    嵌套for循环打印等边三角形：
    1. public class Test {
    2.   public static void main(String[] args) {
    3.       for (int i = 1; i <= 5; i++) {     
    4.           for (int j = 4; j >= i; j--) {
    5.               System.out.print(" ");
    6.           }
    7.           for (int j = 1; j <= i; j++) {
    8.               System.out.print(" *");
    9.           }
    10.           System.out.println();
    11.       }
    12.   }
    13. }
    以上实例编译运行结果如下：
    1.    *
    2.   * *
    3.  * * *
    4. * * * *
    5. * * * * *

Java 增强 for 循环

Java 增强 for 循环语法格式如下:

  1. for(声明语句 : 表达式)
  2. {
  3.    //代码句子
  4. }

声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。
表达式：表达式是要访问的数组名，或者是返回值为数组的方法。for增强有个缺陷就是拿不到数组的索引。

  1. public class Test {
  2.     public static void main(String[] args) {
  3.       int [] numbers = {10, 20, 30, 40, 50};
  5.       for(int x : numbers ){
  6.          System.out.print( x );
  7.          System.out.print(",");
  8.       }
  9.       System.out.println("");
  10.       String [] names ={"詹姆斯", "科比", "哈登", "杜兰特"};
  11.       for( String name : names ) {
  12.          System.out.print( name );
  13.          System.out.print(",");
  14.     }
  15. }

以上实例编译运行结果如下：

  1. 0,20,30,40,50,
  2. 詹姆斯,科比,哈登,杜兰特,

利用for循环进行数组的冒泡排序

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         /**
  4.          * 将数组[4,1,3,2,5,9,10.30,10,59]按小到大顺序排列
  5.          * 冒泡排序原理：相邻两个相比大的往后排
  6.          */
  7.         int [] arrayList = {4,1,3,2,5,9,100,30,10,59};
  8.         for (int i = 0; i < arrayList.length; i++) {
  9.             for (int j = 0; j <arrayList.length-1-i; j++) {
  10.                 if (arrayList[j]>arrayList[j+1]){
  11.                     int temp = arrayList[j];
  12.                     arrayList[j] = arrayList[j+1];
  13.                     arrayList[j+1] = temp;
  14.                 }
  15.             }
  16.         }
  17.         for (int newArrayList : arrayList) {
  18.             System.out.print(newArrayList);
  19.             System.out.print(",");
  20.         }
  21.     }
  22. }

以上实例编译运行结果如下：

  1. 1,2,3,4,5,9,10,30,59,100,