foreach语句使用总结

java foreach 使用 

 
foreach语句是java5的新特征之一，在遍历数组、集合方面，foreach为开发人员提供了极大的方便。
 
foreach语句是for语句的特殊简化版本，但是foreach语句并不能完全取代for语句，然而，任何的foreach语句都可以改写为for语句版本。
 
foreach并不是一个关键字，习惯上将这种特殊的for语句格式称之为“foreach”语句。从英文字面意思理解foreach也就是“for 每一个”的意思。实际上也就是这个意思。
 
foreach的语句格式：
for(元素类型t 元素变量x : 遍历对象obj){
     引用了x的java语句;
}
 
下面通过两个例子简单例子看看foreach是如何简化编程的。代码如下：
 
一、foreach简化数组和集合的遍历
 
import java.util.Arrays; 
import java.util.List; 
import java.util.ArrayList; 


/** 
* Created by IntelliJ IDEA. 
* User: leizhimin 
* Date: 2007-12-3 
* Time: 16:58:24 
* Java5新特征之foreach语句使用总结 
*/ 
public class TestArray { 
    public static void main(String args[]) { 
         TestArray test = new TestArray(); 
         test.test1(); 
         test.listToArray(); 
         test.testArray3(); 


     } 


    /** 
     * foreach语句输出一维数组 
     */ 
    public void test1() { 
        //定义并初始化一个数组 
        int arr[] = {2, 3, 1}; 
         System.out.println("----1----排序前的一维数组"); 
        for (int x : arr) { 
             System.out.println(x); //逐个输出数组元素的值 
         } 


        //对数组排序 
         Arrays.sort(arr); 


        //利用java新特性for each循环输出数组 
         System.out.println("----1----排序后的一维数组"); 
        for (int x : arr) { 
             System.out.println(x); //逐个输出数组元素的值 
         } 
     } 


    /** 
     * 集合转换为一维数组 
     */ 
    public void listToArray() { 
        //创建List并添加元素 
         List<String> list = new ArrayList<String>(); 
         list.add("1"); 
         list.add("3"); 
         list.add("4"); 


        //利用froeach语句输出集合元素 
         System.out.println("----2----froeach语句输出集合元素"); 
        for (String x : list) { 
             System.out.println(x); 
         } 


        //将ArrayList转换为数组 
         Object s[] = list.toArray(); 


        //利用froeach语句输出集合元素 
         System.out.println("----2----froeach语句输出集合转换而来的数组元素"); 
        for (Object x : s) { 
             System.out.println(x.toString()); //逐个输出数组元素的值 
         } 
     } 


    /** 
     * foreach输出二维数组测试 
     */ 
    public void testArray2() { 
        int arr2[][] = {{4, 3}, {1, 2}}; 
         System.out.println("----3----foreach输出二维数组测试"); 
        for (int x[] : arr2) { 
            for (int e : x) { 
                 System.out.println(e); //逐个输出数组元素的值 
             } 
         } 
     } 


    /** 
     * foreach输出三维数组 
     */ 
    public void testArray3() { 
        int arr[][][] = { 
                 {{1, 2}, {3, 4}}, 
                 {{5, 6}, {7, 8}} 
         }; 


         System.out.println("----4----foreach输出三维数组测试"); 
        for (int[][] a2 : arr) { 
            for (int[] a1 : a2) { 
                for (int x : a1) { 
                     System.out.println(x); 
                 } 
             } 
         } 
     } 
} 
运行结果：
----1----排序前的一维数组 
2 
3 
1 
----1----排序后的一维数组 
1 
2 
3 
----2----froeach语句输出集合元素 
1 
3 
4 
----2----froeach语句输出集合转换而来的数组元素 
1 
3 
4 
----4----foreach输出三维数组测试 
1 
2 
3 
4 
5 
6 
7 
8 


Process finished with exit code 0 
二、foreach语句的局限性
 
通过上面的例子可以发现，如果要引用数组或者集合的索引，则foreach语句无法做到，foreach仅仅老老实实地遍历数组或者集合一遍。下面看一个例子就明白了：
 
/** 
* Created by IntelliJ IDEA. 
* User: leizhimin 
* Date: 2007-12-3 
* Time: 17:07:30 
* foreach语句的局限性 
*/ 
public class TestArray2 { 


    public static void main(String args[]) { 
        //定义一个一维数组 
        int arr[] = new int[4]; 
         System.out.println("----未赋值前输出刚刚定义的数组----"); 
        for (int x : arr) { 
             System.out.println(x); 
         } 


        //通过索引给数组元素赋值 
         System.out.println("----通过循环变量给数组元素赋值----"); 
        for (int i = 3; i > 0; i--) { 
             arr[i] = i; 
         } 
        //循环输出创建的数组 
         System.out.println("----赋值后，foreach输出创建好的数组----"); 
        for (int x : arr) { 
             System.out.println(x); 
         } 
     } 
}
运行结果：
 
----未赋值前输出刚刚定义的数组---- 
0 
0 
0 
0 
----通过循环变量给数组元素赋值---- 
----赋值后，foreach输出创建好的数组---- 
0 
1 
2 
3 


Process finished with exit code 0 
三、总结
 
foreach语句是for语句特殊情况下的增强版本，简化了编程，提高了代码的可读性和安全性（不用怕数组越界）。相对老的for语句来说是个很 好的补充。提倡能用foreach的地方就不要再用for了。在用到对集合或者数组索引的情况下，foreach显得力不从心，这个时候是用for语句的 时候了。foreach一般结合泛型使用.




java中foreach 博客分类： java
Java.Java代码  
1.public class TestForEach {   
2.  
3.    /**  
4.     * @param args  
5.     */  
6.    public static void main(String[] args) {   
7.        Aeach[] a = new Aeach[2];   
8.  
9.        //第一种赋值方式   
10.  
11.        // for (int i = 0; i < a.length; i++) {   
12.        //   a[i] = new Aeach();   
13.        //  }   
14.  
15.        //第二种赋值方式   
16.  
17.        for (Aeach aeach : a) {   
18.            aeach = new Aeach();   
19.        }   
20.  
21.        for (Aeach aeach : a) {   
22.  
23.            //测试是否foreach会影响数组元素   
24.            aeach.setName("1111111111111");   
25.            System.out.println(aeach);   
26.        }   
27.        System.out.println(Arrays.toString(a));   
28.    }   
29.  
30.}   
31.  
32.class Aeach {   
33.    String name = "AAAAA初始化";   
34.  
35.    public void setName(String name) {   
36.        this.name = name;   
37.    }   
38.  
39.    public String toString() {   
40.        return super.toString() + name;   
41.    }   
42.}  
public class TestForEach {


    /**
     * @param args
     */
    public static void main(String[] args) {
        Aeach[] a = new Aeach[2];


        //第一种赋值方式


        // for (int i = 0; i < a.length; i++) {
        //   a[i] = new Aeach();
        //  }


        //第二种赋值方式


        for (Aeach aeach : a) {
            aeach = new Aeach();
        }


        for (Aeach aeach : a) {


            //测试是否foreach会影响数组元素
            aeach.setName("1111111111111");
            System.out.println(aeach);
        }
        System.out.println(Arrays.toString(a));
    }


}


class Aeach {
    String name = "AAAAA初始化";


    public void setName(String name) {
        this.name = name;
    }


    public String toString() {
        return super.toString() + name;
    }
}
  


 


对上面的数组采用两种赋值方式，一个是foreach，一个是直接引用。看输入能看到采用foreach赋值打印的结果都为null，直接引用赋值能达到预期结果。


     主要是因为foreach赋值的时候


     for (Aeach aeach : a) {
       aeach = new Aeach();
     }


     相当于 


     for(){


     Aeach aeach=a[i]; 


     aeach=new Aeach(); 


     }


     这就相当于中间产生了一个副本，采用new操作符就等于没有操作数组的元素。


     我之前看到这个例子，还以为foreach操作不影响数组原来的元素呢。


     后面的代码，用直接引用的循环赋值方式，然后再用aeach.setName("1111111111111");
     再打印是发生了变化的。


     不是自己亲自试下还真忽略了，以后得小心对待这些问题，细细想来确实就是这么回事。new这个操作符新建个对象，明显不会影响数组元素，而采用引用的方式进行操作明显会改变了。。。


1.java的foreach可以遍历数组和所有的Collection对象（Collection接口中包括iterator()，因此所有实现Collection接口的类都可以进行foreach遍历）。
2.因为JavaSE5引入了新的被称为Iterable接口，该接口包含一个能够产生Iterator的iterator()方法，并且Iterable接口被foreach用来在序列中移动。
3.因此，只要你创建的类实现了Iterable接口，就可以使用foreach进行遍历。


4.




 
返回一个实现了Iterable<String>的匿名内部类实例




JDK 5.0中增加了一些新的特性,但是以前只是肤浅的了解了一下,只知道怎么回事,但是根本没有用心去学习,最近觉得自己学习太浮躁了.先学着做一些笔记吧.慢慢养成习惯吧.


JDK5.0中对for语句增加了一种形式,和其他语言中的foreach比较像,所以题目取名叫JAVA中的foreach.该形式的具体语法如下:for(声明:表达式).解释一下,也就是说冒号前面是声明一个临时变量,在下面的语句中进行引用.冒号后面是表达式,应该为集合或者数组


这样看起来可能不太明白.用实例看一下:


for (Object listElement : list) {
    System.out.println(listElement.toString());
    // Do something else with this list element
}


这样是不是简介了许多?list为一个list对象.JDK5以前的实现方式一般是加一个临时变量i,或者是用iterator.代码如下:


for (Iterator i = list.iterator(); i.hasNext(); ) {
    Object listElement = i.next();
    out.println(listElement.toString());
    // Do something else with this list element
}


或者


for (int i=0;i<list.size();i++) {
    Object listElement = list.get(i);
    out.println(listElement.toString());
    // Do something else with this list element
}
相比之下,这个for的新的形式确实是使代码简洁不少.那么这种形式的原理是什么呢?它做法很聪明,只是在编译的时候转换成如下形式:


for (Iterator<E> #i = (expression).iterator(); #i.hasNext(); ) {
        declaration = #i.next();
        statement
}


这样估计减少了修改javac的工作量.这样做还有一个优点:如果你想用自己定义的集合来使用这种形式,很简单,只需要实现java.lang.iterable接口就可以了.


任何事物都有两面,这样做的缺点是什么呢?


这种形式的一个最大的缺点就是不能访问元素在这个集合中的定位,举个例子来说:


for (int i=0; i<args.length; i++) {
    wordList.add("word " + (i+1) + ": '" + args[i] + "'");
}
        
for (String word : wordList) {
    out.println(word);
}


这两个例子说明了问题.没法访问定位,也就没办法修改,删除这个集合中的内容.前面已经说了,这种形式是转换为Iterator形式使用的.所以Iterator能做到的,他就能做到.这种写法这么简洁,如果你只是要遍历这个集合,数组,这种写法非常适合.


这里还有需要注意的一个问题,数组集合中如果是对象的话,在声明中要定义成Object类型,不要定义成集合中数据的类型,比如下面的代码:


List list=new ArrayList();
  list.add("test1");
  list.add("test2");
  list.add("test3");
  list.add("test4");
  for(String test:list){
   System.out.println(test);
  }


这种写法会报错,因为Iterator本来就是返回的Object对象,不能从Object转为String.


可以通过JDK5中的范型来解决,可以写成下面的形式:


List<String> list=new ArrayList<String>();
  list.add("test1");
  list.add("test2");
  list.add("test3");
  list.add("test4");
  for(String test:list){
   System.out.println(test);
  }


Java中foreach用法,增强型的for循环的样例和解释 博客分类： java
JavaJ#.JDK1.5加入的增强for和循环. 


语法是: 


Java代码  
1.for(ElementType element:arrayName){};     
2.  
3.for(ElementType element:arrayName){};  
for(ElementType element:arrayName){};  


for(ElementType element:arrayName){};


举个例子:(1) 




Java代码  
1.int[] numArray = { 1, 2, 3, 4, 5, 6 };      
2.for (int i : numArray) {      
3.  System.out.print(i);      
4.}    
int[] numArray = { 1, 2, 3, 4, 5, 6 };   
for (int i : numArray) {   
  System.out.print(i);   
}  




Java代码  
1.int[] numArray = { 1, 2, 3, 4, 5, 6 };   
2.for (int i : numArray) {   
3.  System.out.print(i);   
4.}  
    int[] numArray = { 1, 2, 3, 4, 5, 6 };
    for (int i : numArray) {
      System.out.print(i);
    }


//结果会是123456 




等价于(2) 


Java代码  
1.int[] numArray = { 1, 2, 3, 4, 5, 6 };      
2.for (int i; i < numArray.length; i++) {      
3.  System.out.print(numArray[i]);      
4.}    
int[] numArray = { 1, 2, 3, 4, 5, 6 };   
for (int i; i < numArray.length; i++) {   
  System.out.print(numArray[i]);   
}  




Java代码  
1.int[] numArray = { 1, 2, 3, 4, 5, 6 };   
2.for (int i; i < numArray.length; i++) {   
3.  System.out.print(numArray[i]);   
4.}  
    int[] numArray = { 1, 2, 3, 4, 5, 6 };
    for (int i; i < numArray.length; i++) {
      System.out.print(numArray[i]);
    }


或者更贴切是这样的:(3) 


Java代码  
1.int[] numArray = { 1, 2, 3, 4, 5, 6 };      
2.for (int i; i < numArray.length; i++) {      
3.  int j = numArray[i];// 这个j,就等价与(1)中的i      
4.  System.out.println(j);      
5.}    
int[] numArray = { 1, 2, 3, 4, 5, 6 };   
for (int i; i < numArray.length; i++) {   
  int j = numArray[i];// 这个j,就等价与(1)中的i   
  System.out.println(j);   
}  




Java代码  
1.int[] numArray = { 1, 2, 3, 4, 5, 6 };   
2.for (int i; i < numArray.length; i++) {   
3.  int j = numArray[i];// 这个j,就等价与(1)中的i   
4.  System.out.println(j);   
5.}  
    int[] numArray = { 1, 2, 3, 4, 5, 6 };
    for (int i; i < numArray.length; i++) {
      int j = numArray[i];// 这个j,就等价与(1)中的i
      System.out.println(j);
    }这个结合集合的概念和同样是JDK1.5加入的泛性,可以做到简化代码的作用.比如 




Java代码  
1.List<Integer> intList = new ArrayList<Integer>();      
2.for (Integer i : intList) {      
3.  System.out.print(i);// 可以打印出intList中的所有元素      
4.}     
5.  
6.    List<Integer> intList = new ArrayList<Integer>();   
7.    for (Integer i : intList) {   
8.      System.out.print(i);// 可以打印出intList中的所有元素   
9.    }  
List<Integer> intList = new ArrayList<Integer>();   
for (Integer i : intList) {   
  System.out.print(i);// 可以打印出intList中的所有元素   
}  


    List<Integer> intList = new ArrayList<Integer>();
    for (Integer i : intList) {
      System.out.print(i);// 可以打印出intList中的所有元素
    }




增强for(part1:part2){part3}; 


part2中是一个数组对象,或者是带有泛性的集合. 
part1定义了一个局部变量,这个局部变量的类型与part2中的对象元素的类型是一致的. 
part3当然还是循环体.