java循环示例集锦

 

1、
/*
* Created on 2004-8-22
*
* TODO To change the template for this generated file go to
* Window - Preferences - Java - Code Style - Code Templates
*/

/**
* @author diyer6
*
* TODO To change the template for this generated type comment go to
* Window - Preferences - Java - Code Style - Code Templates
*/
/*
此图是运行结果:
**********
　*********
　　********
　　　*******
　　　　******
　　　　　*****
　　　　　　****
　　　　　　　***
　　　　　　　　**
　　　　　　　　　*
*/
public class XingHaoOne {
public static void main(String[] args) {
　for(int i=10;i>0;i--){
　 for (int j=0; j < 10-i; j++) {

　　　　　　　　　System.out.print(" ");
　　　　　　　　}

　　　　 for(int o=i;o>0;o--){
　　　　　　 System.out.print("*");
　　　　　}
　 System.out.print("/n");
　　　　}
　　}

2、
/*
* Created on 2004-8-22
*
* TODO To change the template for this generated file go to
* Window - Preferences - Java - Code Style - Code Templates
*/

/**
* @author diyer6
*
* TODO To change the template for this generated type comment go to
* Window - Preferences - Java - Code Style - Code Templates
*/
/*
此图是打印结果:

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

*/
public class XingHaoTwo {

public static void main(String[] args) {
　for(int i=10;i>0;i--){　
　　　　 for(int n=i;n<11;n++){　

　　　　　　　System.out.print("*");
　　　　　 }
　　System.out.print("/n");
　　　　}
　　}
}

3、
/*
* Created on 2004-8-22
*
* TODO To change the template for this generated file go to
* Window - Preferences - Java - Code Style - Code Templates
*/

/**
* @author diyer6
*
* TODO To change the template for this generated type comment go to
* Window - Preferences - Java - Code Style - Code Templates
*/
/*
此图是运行结果:

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

*/
public class XingHaoThree {

public static void main(String[] args) {
　for(int i=10;i>0;i--)
　{
　 for(int j=0;j　 System.out.print("*");
　System.out.print("/n");
　}
}
}

4、
/*
* Created on 2004-8-22
*
* TODO To change the template for this generated file go to
* Window - Preferences - Java - Code Style - Code Templates
*/

/**
* @author diyer6
*
* TODO To change the template for this generated type comment go to
* Window - Preferences - Java - Code Style - Code Templates
*/
/*
此图是打印结果:

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

*/
public class XingHaoFour {

public static void main(String[] args) {
　for(int i=10;i>0;i--)
　{
　 for(int j=i;j>1;j--){
　　　 System.out.print(" ");}
　
　 for(int n=i;n<11;n++){
　　　　　　 System.out.print("*");
　　　　　}
　
　System.out.print("/n");
　}

}

}

5、
/*
* Created on 2004-8-22
*
* TODO To change the template for this generated file go to
* Window - Preferences - Java - Code Style - Code Templates
*/

/**
* @author diyer6
*
* TODO To change the template for this generated type comment go to
* Window - Preferences - Java - Code Style - Code Templates
*/
/*
此图是运行结果：

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

*/
public class XingHaoJuXing {

public static void main(String[] args) {
　
　for(int i=10;i>0;i--){
　
　 for(int n=0;n　　System.out.print("*");
　　}
　
　 for(int j=i;j<11;j++){
　　System.out.print("*");
　 }
　 System.out.print("/n");
　　
　}
}
}

6、
/*
* Created on 2004-8-22
*
* TODO To change the template for this generated file go to
* Window - Preferences - Java - Code Style - Code Templates
*/

/**
* @author diyer6
*
* TODO To change the template for this generated type comment go to
* Window - Preferences - Java - Code Style - Code Templates
*/
/*
此图是打印结果:

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

*/
public class Shishi {

public static void main(String[] args) {
　for(int i=10;i>0;i--){
　 for(int f=0;f<10;f++){
　 System.out.print("*");}

　　System.out.print("/n");

　　 }
}
}

再来个带 注释 的 ：

/*
* Created on 2004-8-22
*
* TODO To change the template for this generated file go to
* Window - Preferences - Java - Code Style - Code Templates
*/

/**
* @author diyer6
*
* TODO To change the template for this generated type comment go to
* Window - Preferences - Java - Code Style - Code Templates
*/
/*
此图是打印结果:

0**********
00*********
000********
0000*******
00000******
000000*****
0000000****
00000000***
000000000**
0000000000*

*/
public class Zaishi {

public static void main(String[] args) {
　for(int i=10;i>0;i--){
　 for(int j=i;j<11;j++){ //j=10;j<11;循环一次,打印一个 0 ,在执行 j++ ，
　　　　　　　　　　　　　　　　　 //此时j=11;i<11;为false，所以在第一行只打印了一个 0 。
　 System.out.print("0");}
　 for(int n=i;n>0;n--){ /*n=10;n>0;循环一次，打印一个 * ，在执行n--,
　　　　　　　　　　　　 *此时n=9;n>0;再循环一次,再打印一个 * ,在执行n--,
　　　　　　　　　　　　 *此时n=8;n>0;再循环一次,再打印一个 * ,在执行n--,
　　　　　　　　　　　　 *依次类推... 所就在第一行打印了10个 * 。
　　　　　　　　　　　　 *接下来执行 System.out.print("/n"); 换行 。
　　　　　　　　　　　　 *然后执行第一个大循环中的 i-- ; 此时 i 就等于 9 了。
　　　　　　　　　　　　 *
　　　　　　　　　　　　 *这时 第一个小循环 中：（j=i 从 i=9 开始循环）
　　　　　　　　　　　　 *j=9;j<11;循环两次,所以在第二行只打印 2 个 0 。
　　　　　　　　　　　　 *这时 第二个小循环 中：（n=i 从 i=9 开始循环）
　　　　　　　　　　　　 *n=9;n>0;循环一次，打印一个 * ，在执行n--,
　　　　　　　　　　　　 *此时n=8;n>0;再循环一次,再打印一个 * ,在执行n--,
　　　　　　　　　　　　 *依次类推... 所就在第二行打印了 9 个 * 。
　　　　　　　　　　　　 *接下来执行 System.out.print("/n"); 换行 。
　　　　　　　　　　　　 *然后执行第一个大循环中的 i-- ; 此时 i 就等于 8 了。
　　　　　　　　　　　　 *
　　　　　　　　　　　　 *往下 依次类推....
　　　　　　　　　　　*/
　　System.out.print("*");
　 }
　
　System.out.print("/n");
　}
}
}

原文出处可以参考：http://www.scjp.com.cn/news/article_catalog.asp?id=5

这篇文章是每一个菜鸟入门的必修课，好好研究，可以非常清楚地体会Java对于循环的流程控制。

Java  的循环语句有for，while 和 do-while 。这些语句创造了我们通常所称的循环（loops）。你可能知道，一个循环重复执行同一套指令直到一个结束条件出现。你将看到， Java 有适合任何编程所需要的循环结构。

5.2.1 while 语句
while 语句是Java 最基本的循环语句。当它的控制表达式是真时，while 语句重复执行一个语句或语句块。它的通用格式如下：

while(condition) {
// body of loop
}

条件condition 可以是任何布尔表达式。只要条件表达式为真，循环体就被执行。当条件condition 为假时，程序控制就传递到循环后面紧跟的语句行。如果只有单个语句需要重复，大括号是不必要的。

下面的while 循环从10开始进行减计数，打印出10行“tick”。

// Demonstrate the while loop.
class While {
public static void main(String args[]) {
int n = 10;

while(n > 0) {
System.out.println("tick " + n);
n--;

}
}
}

当你运行这个程序，它将“tick”10次：

tick 10
tick 9
tick 8
tick 7
tick 6
tick 5
tick 4
tick 3
tick 2
tick 1

因为while 语句在循环一开始就计算条件表达式，若开始时条件为假，则循环体一次也不会执行。例如，下面的程序中，对println( ) 的调用从未被执行过：

int a = 10, b = 20;

while(a > b)
System.out.println("This will not be displayed");

while 循环（或Java 的其他任何循环）的循环体可以为空。这是因为一个空语句（null statement) （仅由一个分号组成的语句）在Java 的语法上是合法的。例如，下面的程序：

// The target of a loop can be empty.
class NoBody {
public static void main(String args[]) {

int i, j;

i = 100;
j = 200;

// find midpoint between i and j
while(++i < --j) ; // no body in this loop

System.out.println("Midpoint is " + i);
}
}

该程序找出变量i和变量j的中间点。它产生的输出如下：

Midpoint is 150

该程序中的while 循环是这样执行的。值i自增，而值j自减，然后比较这两个值。如果新的值i仍比新的值j小，则进行循环。如果i等于或大于j，则循环停止。在退出循环前，i 将保存原始i和j的中间值（当然，这个程序只有在开始时i比j小的情况下才执行）。正如你看到的，这里不需要循环体。所有的行为都出现在条件表达式自身内部。在专业化的Java 代码中，一些可以由控制表达式本身处理的短循环通常都没有循环体。

5.2.2 do-while 循环
如你刚才所见，如果while 循环一开始条件表达式就是假的，那么循环体就根本不被执行。然而，有时需要在开始时条件表达式即使是假的情况下，while 循环至少也要执行一次。换句话说，有时你需要在一次循环结束后再测试中止表达式，而不是在循环开始时。幸运的是，Java 就提供了这样的循环：do-while 循环。do-while 循环总是执行它的循环体至少一次，因为它的条件表达式在循环的结尾。它的通用格式如下：

do {
// body of loop
} while (condition);

do-while 循环总是先执行循环体，然后再计算条件表达式。如果表达式为真，则循环继续。否则，循环结束。对所有的Java 循环都一样，条件condition 必须是一个布尔表达式。下面是一个重写的“tick”程序，用来演示do-while 循环。它的输出与先前程序的输出相同。

// Demonstrate the do-while loop.
class DoWhile {
public static void main(String args[]) {
int n = 10;

do {
System.out.println("tick " + n);
n--;

} while(n > 0);
}
}

该程序中的循环虽然在技术上是正确的，但可以像如下这样编写更为高效：

do {
System.out.println("tick " + n);
} while(--n > 0);

在本例中，表达式“-- n > 0 ”将n值的递减与测试n是否为0组合在一个表达式中。它的执行过程是这样的。首先，执行-- n 语句，将变量n递减，然后返回n的新值。这个值再与0比较，如果比0大，则循环继续。否则结束。

do-while 循环在你编制菜单选择时尤为有用，因为通常都想让菜单循环体至少执行一次。下面的程序是一个实现Java 选择和重复语句的很简单的帮助系统：

// Using a do-while to process a menu selection
class Menu {

public static void main(String args[])
throws java.io.IOException {
char choice;

do {
System.out.println("Help on:");
System.out.println(" 1. if");
System.out.println(" 2. switch");
System.out.println(" 3. while");
System.out.println(" 4. do-while");
System.out.println(" 5. for/n");
System.out.println("Choose one:");
choice = (char) System.in.read();

} while( choice < '1' || choice > '5');

System.out.println("/n");

switch(choice) {

case '1':
System.out.println("The if:/n");
System.out.println("if(condition) statement;");
System.out.println("else statement;");

break;

case '2':
System.out.println("The switch:/n");
System.out.println("switch(expression) {");
System.out.println(" case constant:");
System.out.println(" statement sequence");
System.out.println(" break;");
System.out.println(" // ...");
System.out.println("}");
break;

case '3':
System.out.println("The while:/n");
System.out.println("while(condition) statement;");
break;

case '4':
System.out.println("The do-while:/n");
System.out.println("do {");

System.out.println(" statement;");
System.out.println("} while (condition);");
break;

case '5':
System.out.println("The for:/n");
System.out.print("for(init; condition; iteration)");
System.out.println(" statement;");
break;

}
}
}

下面是这个程序执行的一个样本输出：

Help on:

1. if
2. switch
3. while
4. do-while
5. for
Choose one:
4
The do-while:
do {

statement;
} while (condition);

在程序中，do-while 循环用来验证用户是否输入了有效的选择。如果没有，则要求用户重新输入。因为菜单至少要显示一次，do-while 循环是完成此任务的合适语句。

关于此例的其他几点：注意从键盘输入字符通过调用System.in.read( ) 来读入。这是一个Java 的控制台输入函数。尽管Java 的终端 I/O （输入/输出)方法将在第12章中详细讨论，在这里使用System.in.read ( ) 来读入用户的选择。它从标准的输入读取字符（返回整数，因此将返回值choice 定义为字符型）。默认地，标准输入是按行进入缓冲区的，因此在你输入的任何字符被送到你的程序以前，必须按回车键。

Java 的终端输入功能相当有限且不好使用。进一步说，大多数现实的Java 程序和Applets （小应用程序）都具有图形界面并且是基于窗口的。因此，这本书使用终端的输入并不多。然而，它在本例中是有用的。另外一点:因为使用System.in.read ( ) ，程序必须指定throws java.io.IOException 子句。这行代码对于处理输入错误是必要的。这是Java 的异常处理的一部分，将在第10章讨论。

5.2.3 for 循环
在第2章曾使用过一个for循环的简单格式。你将看到，for循环是一个功能强大且形式灵活的结构。下面是for 循环的通用格式：

for(initialization; condition; iteration) {
// body
}

如只有一条语句需要重复，大括号就没有必要。

for循环的执行过程如下。第一步，当循环启动时，先执行其初始化部分。通常，这是设置循环控制变量值的一个表达式，作为控制循环的计数器。重要的是你要理解初始化表达式仅被执行一次。下一步，计算条件condition 的值。条件condition 必须是布尔表达式。它通常将循环控制变量与目标值相比较。如果这个表达式为真，则执行循环体；如果为假，则循环终止。再下一步执行循环体的反复部分。这部分通常是增加或减少循环控制变量的一个表达式。接下来重复循环，首先计算条件表达式的值，然后执行循环体，接着执行反复表达式。这个过程不断重复直到控制表达式变为假。

下面是使用for 循环的“tick”程序：

// Demonstrate the for loop.
class ForTick {
public static void main(String args[]) {
int n;

for(n=10; n>0; n--)
System.out.println("tick " + n);
}
}

在for 循环中声明循环控制变量

控制for循环的变量经常只是用于该循环，而不用在程序的其他地方。在这种情况下，可以在循环的初始化部分中声明变量。例如，下面重写了前面的程序，使变量 n 在for循环中被声明为整型：

// Declare a loop control variable inside the for.
class ForTick {
public static void main(String args[]) {

// here, n is declared inside of the for loop
for(int n=10; n>0; n--)
System.out.println("tick " + n);
}
}

当你在for 循环内声明变量时，必须记住重要的一点:该变量的作用域在for语句执行后就结束了（因此，该变量的作用域就局限于for 循环内）。在for循环外，变量就不存在了。如果你在程序的其他地方需要使用循环控制变量，你就不能在for循环中声明它。

由于循环控制变量不会在程序的其他地方使用，大多数程序员都在for循环中来声明它。例如，以下为测试素数的一个简单程序。注意由于其他地方不需要i，所以循环控制变量i在for循环中声明。

// Test for primes.
class FindPrime {

public static void main(String args[]) {
int num;
boolean isPrime = true;

num = 14;

for(int i=2; i <= num/2; i++) {

if((num % i) == 0) {
isPrime = false;
break;

}
}
if(isPrime) System.out.println("Prime");
else System.out.println("Not Prime");

}
}

使用逗号

你可能经常需要在初始化和for循环的反复部分包括超过一个变量的声明。例如，考虑下面程序的循环部分：

class Sample {

public static void main(String args[]) {
int a, b;
b = 4;
for(a=1; a

System.out.println("a = " + a);
System.out.println("b = " + b);
b--;

}
}
}

如你所看到的，循环被两个相互作用的变量控制。由于循环被两个变量控制，如果两个变量都能被定义在for 循环中，而变量b不需要通过人工处理将是很有用的。幸好，Java 提供了一个完成此任务的方法。为了允许两个或两个以上的变量控制循环，Java 允许你在for 循环的初始化部分和反复部分声明多个变量，每个变量之间用逗号分开。

使用逗号，前面的for循环将更高效，改写后的程序如下：

// Using the comma.
class Comma {
public static void main(String args[]) {
int a, b;

for(a=1, b=4; aC++ 熟悉，你就会知道逗号是一个运算符，能在任何有效的表达

式中使用。然而，在Java 中不是这样。在 Java 中，逗号仅仅是一个分隔符，只

适用于for循环。

5.2.4 for 循环的一些变化
for循环支持一些变化，这增加了它的功能和灵活性。for循环这样灵活是因为它的3部分（初始化部分，条件测试部分和反复部分）并不仅用于它们所限定的那些目的。事实上，for 循环的3部分能被用于你需要的任何目的。让我们看一些例子。

最普通的变化之一包含在条件表达式中。具体地说，条件表达式可以不需要用循环变量和目标值的比较来测试循环条件。事实上，控制for 循环的条件可以是任何布尔表达式。例如，考虑下列程序片段：

boolean done = false;

for(int i=1; !done; i++) {

// ...

if(interrupted()) done = true;

}

在本例中，for循环将一直运行，直到布尔型变量done 被设置为真。for循环的条件部分不测试值i。

下面是for循环的另外一个有趣的变化。在Java 中可以使for循环的初始化、条件或者反复部分中的任何或者全部都为空，如下面的程序：

// Parts of the for loop can be empty.

class ForVar {

public static void main(String args[]) {

int i;

boolean done = false;

i = 0;

for( ; !done; ) {

System.out.println("i is " + i);

if(i == 10) done = true;

i++;}}

}

本例中，初始化部分和反复部分被移到了for 循环以外。这样，for循环的初始化部分和反复部分是空的。当这个简单的例子中，for循环中没有值，确实，这种 风格 被认为是相当差的，有时这种风格也是有用的。例如，如果初始条件由程序中其他部分的复杂表达式来定义，或者循环控制变量的改变由发生在循环体内的行为决定，而且这种改变是一种非顺序的方式，这种情况下，可以使for 循环的这些部分为空。

下面是for 循环变化的又一种方式。如果for循环的三个部分全为空，你就可以创建一个无限循环（从来不停止的循环）。例如：

for( ; ; ) {
// ...
}

这个循环将始终运行，因为没有使它终止的条件。尽管有一些程序，例如操作系统命令处理器，需要无限循环，但大多数“无限循环”实际上是具有特殊终止要求的循环。在不久你将看到如何不用正常的条件表达式来终止这种类型的循环。

5.2.5 循环嵌套
和其他编程语言一样，Java 允许循环嵌套。也就是，一个循环在另一个循环之内。例如，下面的程序就是循环嵌套：

// Loops may be nested.
class Nested {
public static void main(String args[]) {
int i, j;

for(i=0; i<10; i++) {
for(j=i; j<10; j++)
System.out.print(".");
System.out.println();
}
}
}

该程序产生的输出如下所示：

. . . . . . . . . .
. . . . . . . . .
. . . . . . . .
. . . . . . .
. . . . . .
. . . . .
. . . .
. . .
. .
.

 

import java.util.*;
public class Josephus {

    public static void main(String[] args) {
        if(args.length<2){
            System.out.println("Input N and M.");
            return;
        }
        int n = Integer.parseInt(args[0]);
        int m = Integer.parseInt(args[1]);
        int point=0,number=1;
        List list = new ArrayList ();
        for(int i=1;i<=n; i++){
            //初始化链表
            list.add(i);
        }

        while(list.size()>1){
            if(number%m==0){
                list.remove(point);
                --point;
            }
            ++point;//指针后移
            ++number;
            if(point>list.size()-1){
                //指针越界重新开始
                point=0;
            }
        }
       

        System.out.println(list.get(0));
       
    }
}

http://www.blogjava.net/hellboys/archive/2006/06/07/51222.aspx

 

J2SE 1.5提供了另一种形式的for循环。借助这种形式的for循环，可以用更简单地方式来遍历数组和Collection等类型的对象。本文介绍使用这种循环的具体方式，说明如何自行定义能被这样遍历的类，并解释和这一机制的一些常见问题。
　　
　　在Java程序中，要“逐一处理”——或者说，“遍历”——某一个数组或Collection中的元素的时候，一般会使用一个for循环来实现（当然，用其它种类的循环也不是不可以，只是不知道是因为for这个词的长度比较短，还是因为for这个词的含义和这种操作比较配，在这种时候for循环比其它循环常用得多）。
　　
　　对于遍历数组，这个循环一般是采取这样的写法：
　　
　　清单1：遍历数组的传统方式
　　/* 建立一个数组 */
　　int[] integers = {1, 2, 3, 4};
　　/* 开始遍历 */
　　for (int j = 0; j <　integers.length; j++) {
　　　　int i = integers[j];
　　　　System.out.println(i);
　　}
　　
　　而对于遍历Collection对象，这个循环则通常是采用这样的形式：
　　
　　清单2：遍历Collection对象的传统方式
　　/* 建立一个Collection */
　　String[] strings = {"A", "B", "C", "D"};
　　Collection stringList = java.util.Arrays.asList(strings);
　　/* 开始遍历 */
　　for (Iterator itr = stringList.iterator(); itr.hasNext();) {
　　　　Object str = itr.next();
　　　　System.out.println(str);
　　}
　　
　　而在Java语言的最新版本——J2SE 1.5中，引入了另一种形式的for循环。借助这种形式的for循环，现在可以用一种更简单地方式来进行遍历的工作。
　　
　　1. 第二种for循环
　　不严格的说，Java的第二种for循环基本是这样的格式：
　　
　　for (循环变量类型 循环变量名称 : 要被遍历的对象) 循环体
　　
　　借助这种语法，遍历一个数组的操作就可以采取这样的写法：
　　
　　清单3：遍历数组的简单方式
　　/* 建立一个数组 */
　　int[] integers = {1, 2, 3, 4};
　　/* 开始遍历 */
　　for (int i : integers) {
　　　　System.out.println(i);/* 依次输出“1”、“2”、“3”、“4” */
　　}
　　
　　这里所用的for循环，会在编译期间被看成是这样的形式：
　　
　　清单4：遍历数组的简单方式的等价代码
　　/* 建立一个数组 */
　　int[] integers = {1, 2, 3, 4};
　　/* 开始遍历 */
　　for (int 变量名甲 = 0; 变量名甲 <　integers.length; 变量名甲++) {
　　　　System.out.println(integers[变量名甲]);/* 依次输出“1”、“2”、“3”、“4” */
　　}
　　
　　这里的“变量名甲”是一个由编译器自动生成的不会造成混乱的名字。
　　
　　而遍历一个Collection的操作也就可以采用这样的写法：
　　
　　清单5：遍历Collection的简单方式
　　/* 建立一个Collection */
　　String[] strings = {"A", "B", "C", "D"};
　　Collection list = java.util.Arrays.asList(strings);
　　/* 开始遍历 */
　　for (Object str : list) {
　　　　System.out.println(str);/* 依次输出“A”、“B”、“C”、“D” */
　　}
　　
　　这里所用的for循环，则会在编译期间被看成是这样的形式：
　　
　　清单6：遍历Collection的简单方式的等价代码
　　/* 建立一个Collection */
　　String[] strings = {"A", "B", "C", "D"};
　　Collection stringList = java.util.Arrays.asList(strings);
　　/* 开始遍历 */
　　for (Iterator 变量名乙 = list.iterator(); 变量名乙.hasNext();) {
　　　　Object str = 变量名乙.next();
　　　　System.out.println(str);/* 依次输出“A”、“B”、“C”、“D” */
　　}
　　
　　这里的“变量名乙”也是一个由编译器自动生成的不会造成混乱的名字。
　　
　　因为在编译期间，J2SE 1.5的编译器会把这种形式的for循环，看成是对应的传统形式，所以不必担心出现性能方面的问题。
　　
　　不用“foreach”和“in”的原因
　　Java采用“for”（而不是意义更明确的“foreach”）来引导这种一般被叫做“for-each循环”的循环，并使用“:”（而不是意义更明确的“in”）来分割循环变量名称和要被遍历的对象。这样作的主要原因，是为了避免因为引入新的关键字，造成兼容性方面的问题——在Java语言中，不允许把关键字当作变量名来使用，虽然使用“foreach”这名字的情况并不是非常多，但是“in”却是一个经常用来表示输入流的名字（例如java.lang.System类里，就有一个名字叫做“in”的static属性，表示“标准输入流”）。
　　
　　的确可以通过巧妙的设计语法，让关键字只在特定的上下文中有特殊的含义，来允许它们也作为普通的标识符来使用。不过这种会使语法变复杂的策略，并没有得到广泛的采用。
　　
　　“for-each循环”的悠久历史
　　“for-each循环”并不是一个最近才出现的控制结构。在1979正式发布的Bourne shell（第一个成熟的UNIX命令解释器）里就已经包含了这种控制结构（循环用“for”和“in”来引导，循环体则用“do”和“done”来标识）。
　　
　　2. 防止在循环体里修改循环变量
　　在默认情况下，编译器是允许在第二种for循环的循环体里，对循环变量重新赋值的。不过，因为这种做法对循环体外面的情况丝毫没有影响，又容易造成理解代码时的困难，所以一般并不推荐使用。
　　
　　Java提供了一种机制，可以在编译期间就把这样的操作封杀。具体的方法，是在循环变量类型前面加上一个“final”修饰符。这样一来，在循环体里对循环变量进行赋值，就会导致一个编译错误。借助这一机制，就可以有效的杜绝有意或无意的进行“在循环体里修改循环变量”的操作了。
　　
　　清单7：禁止重新赋值
　　int[] integers = {1, 2, 3, 4};
　　for (final int i : integers) {
　　　　i = i / 2; /* 编译时出错 */
　　}
　　
　　注意，这只是禁止了对循环变量进行重新赋值。给循环变量的属性赋值，或者调用能让循环变量的内容变化的方法，是不被禁止的。
　　
　　清单8：允许修改状态
　　Random[] randoms = new Random[]{new Random(1), new Random(2), new Random(3)};
　　for (final Random r : randoms) {
　　　　r.setSeed(4);/* 将所有Random对象设成使用相同的种子 */
　　　　System.out.println(r.nextLong());/* 种子相同，第一个结果也相同 */
　　}
　　
　　3. 类型相容问题
　　为了保证循环变量能在每次循环开始的时候，都被安全的赋值，J2SE 1.5对循环变量的类型有一定的限制。这些限制之下，循环变量的类型可以有这样一些选择：
　　
　　循环变量的类型可以和要被遍历的对象中的元素的类型相同。例如，用int型的循环变量来遍历一个int[]型的数组，用Object型的循环变量来遍历一个Collection等。
　　
　　清单9：使用和要被遍历的数组中的元素相同类型的循环变量
　　int[] integers = {1, 2, 3, 4};
　　for (int i : integers) {
　　　　System.out.println(i);/* 依次输出“1”、“2”、“3”、“4” */
　　}
　　
　　清单10：使用和要被遍历的Collection中的元素相同类型的循环变量
　　Collection< String> strings = new ArrayList< String>();
　　strings.add("A");
　　strings.add("B");
　　strings.add("C");
　　strings.add("D");
　　for (String str : integers) {
　　　　System.out.println(str);/* 依次输出“A”、“B”、“C”、“D” */
　　}
　　
　　循环变量的类型可以是要被遍历的对象中的元素的上级类型。例如，用int型的循环变量来遍历一个byte[]型的数组，用Object型的循环变量来遍历一个Collection< String>（全部元素都是String的Collection）等。
　　
　　清单11：使用要被遍历的对象中的元素的上级类型的循环变量
　　String[] strings = {"A", "B", "C", "D"};
　　Collection< String> list = java.util.Arrays.asList(strings);
　　for (Object str : list) {
　　　　System.out.println(str);/* 依次输出“A”、“B”、“C”、“D” */
　　}
　　
　　循环变量的类型可以和要被遍历的对象中的元素的类型之间存在能自动转换的关系。J2SE 1.5中包含了“Autoboxing/Auto-Unboxing”的机制，允许编译器在必要的时候，自动在基本类型和它们的包裹类（Wrapper Classes）之间进行转换。因此，用Integer型的循环变量来遍历一个int[]型的数组，或者用byte型的循环变量来遍历一个Collection< Byte>，也是可行的。
　　
　　清单12：使用能和要被遍历的对象中的元素的类型自动转换的类型的循环变量
　　int[] integers = {1, 2, 3, 4};
　　for (Integer i : integers) {
　　　　System.out.println(i);/* 依次输出“1”、“2”、“3”、“4” */
　　}
　　
　　注意，这里说的“元素的类型”，是由要被遍历的对象的决定的——如果它是一个Object[]型的数组，那么元素的类型就是Object，即使里面装的都是String对象也是如此。
　　
　　可以限定元素类型的Collection
　　截至到J2SE 1.4为止，始终无法在Java程序里限定Collection中所能保存的对象的类型——它们全部被看成是最一般的Object对象。一直到J2SE 1.5中，引入了“泛型（Generics）”机制之后，这个问题才得到了解决。