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當然還是循環體.