java新特性之for循環最全用法集錦

1.增強for概述

增強for循環，也叫Foreach循環，用於數組和容器（集合類）的遍歷。使用foreach循環遍歷數組和集合元素時，無需獲得數組和集合長度，無需根據索引來訪問數組元素和集合元素，大大提高的效率，代碼也簡潔不少。

2.Oracle官網的解釋

So when should you use the for-each loop? Any time you can. It really beautifies your code. Unfortunately, you cannot use it everywhere. Consider, for example, the expurgate method. The program needs access to the iterator in order to remove the current element. The for-each loop hides the iterator, so you cannot call remove. Therefore, the for-each loop is not usable for filtering. Similarly it is not usable for loops where you need to replace elements in a list or array as you traverse it. Finally, it is not usable for loops that must iterate over multiple collections in parallel. These shortcomings were known by the designers, who made a conscious decision to go with a clean, simple construct that would cover the great majority of cases.

所以你應該什麼時候使用for-each循環？任何時候都可以。這真的美化你的代碼。不幸的是，你不能在任何地方使用它。考慮這些情況，例如，刪除方法。爲了移除當前的元素，該程序需要訪問迭代器。for-each循環隱藏了迭代器，所以你不能調用刪除功能。因此，for-each循環不適用於過濾元素。同樣當遍歷集合或數組時需要替換元素的循環也是不適用的。最後，它不適用於多個集合迭代中並行循環使用。設計師應該瞭解這些缺陷，有意識地設計一個乾淨，簡單的構造，來避免這些情況。有興趣的可以查看官網的API，如果不知道怎麼在官網找到API，請點擊打開官網查看API方法。

3.增強for格式

for(集合或者數組元素的類型   變量名   ： 集合對象或者數組對象){

引用變量名的java語句;

}

官網解釋：

 for (TimerTask t : c)
        t.cancel();

When you see the colon (:) read it as “in.” The loop above reads as “for each TimerTask t in c.” As you can see, the for-each construct combines beautifully with generics. It preserves all of the type safety, while removing the remaining clutter. Because you don't have to declare the iterator, you don't have to provide a generic declaration for it. (The compiler does this for you behind your back, but you need not concern yourself with it.)

大意爲：

當你看到冒號(:),它讀作“進來。”上述循環讀作“把c中的每個TimerTask元素進行遍歷。”正如你所看到的，for-each結構完美的與泛型結合。它保留了所有類型的安全性，同時去除剩餘的混亂。因爲你不必聲明迭代器，你不必爲它提供一個泛型的聲明。 （編譯器在你背後已經做了，你不需要關心它。）

簡單體驗下：

1.增強for遍歷數組

package cn.jason01;
//增強for遍歷數組
public class ForTest01 {
	public static void main(String[] args) {
		int[] array={1,2,3};
		for(int element: array){
			System.out.println(element);
		}
	}
}

2.增強for遍歷集合

package cn.jason01;

import java.util.ArrayList;

public class ForTest {
	public static void main(String[] args) {
		// 泛型推斷，後面可以寫可以不寫String
		ArrayList<String> array = new ArrayList();
		array.add("a");
		array.add("b");
		array.add("c");
		for (String string : array) {
			System.out.println(string);
		}

	}
}

4.增強for底層原理

先看代碼

package cn.jason01;

import java.util.ArrayList;
import java.util.Iterator;

/**
 * 增強for底層原理
 * 
 * @author cassandra
 * @version 1.1
 */
public class ForTest {
	public static void main(String[] args) {
		// 泛型推斷，後面可以寫可以不寫String.規範一些是要寫上的。
		ArrayList<String> array = new ArrayList();
		// 添加元素
		array.add("a");
		array.add("b");
		array.add("c");

		// 增強for實現
		System.out.println("----enhanced for----");
		for (String string : array) {
			System.out.println(string);
		}

		// 反編譯之後的效果，也就是底層實現原理
		System.out.println("---reverse compile---");
		String string;
		for (Iterator iterator = array.iterator(); iterator.hasNext(); System.out.println(string)) {
			string = (String) iterator.next();

		}

		// 迭代器實現
		System.out.println("------Iterator------");
		for (Iterator<String> i = array.iterator(); i.hasNext(); System.out.println(i.next())) {

		}

		// 普通for實現
		System.out.println("-----general for-----");
		for (int x = 0; x < array.size(); x++) {
			System.out.println(array.get(x));
		}
	}
}

從上面代碼可以看出，底層是由迭代器實現的，增強for實際上是隱藏了迭代器，所以不用創建迭代器自然代碼簡潔不少。這也是增強for推出的原因，就是爲了減少代碼，方便遍歷集合和數組，提高效率。

注意：正因爲增強for隱藏了迭代器，所以用增強for遍歷集合和數組時，要先判斷是否爲null，否則會拋出空指針異常。原因很簡單，底層需要用數組或者集合對象去調用iterator()方法去創建迭代器(Iterator迭代器是一個接口，所以要用子類來實現)，如果是null，肯定拋出異常。

5.增強for的適用性以及侷限性

1.適用性

適用於集合和數組的遍歷。

2.侷限性：

①集合不能爲null，因爲底層是迭代器。

②隱藏了迭代器，所以在遍歷集合時不能對集合進行修改(增刪)。

③不能設置角標。

6.增強for用法詳解

1.增強for在數組中用法

package cn.jason05;

import java.util.ArrayList;
import java.util.List;

/**
 * 增強for用法
 * 
 * @author cassandra
 */
public class ForDemo {
	public static void main(String[] args) {
		// 遍歷數組
		int[] arr = { 1, 2, 3, 4, 5 };
		for (int x : arr) {
			System.out.println(x);
		}
	}
}

2.增強for在集合中用法

package cn.jason05;

import java.util.ArrayList;
import java.util.List;

/**
 * 增強for用法
 * 
 * @author cassandra
 */
public class ForDemo {
	public static void main(String[] args) {
		// 遍歷集合
		ArrayList<String> array = new ArrayList<String>();
		array.add("hello");
		array.add("world");
		array.add("java");

		for (String s : array) {
			System.out.println(s);
		}

		// 集合爲null，拋出NullPointerException空指針異常
		List<String> list = null;
		if (list != null) {
			for (String s : list) {
				System.out.println(s);
			}
		}

		// 增強for中添加或修改元素，拋出ConcurrentModificationException併發修改異常
		for (String x : array) {
			if (array.contains("java"))
				array.add(1, "love");
		}

	}

3.泛型與增強for完美結合

注意：必須要與泛型完美結合，不然還得手動向下轉型

1.沒有泛型效果，不能使用增強for

Student類

package cn.jason01;

public class Student {
	private String name1;
	private String name2;

	public Student() {
		super();
	}

	public Student(String name1, String name2) {
		super();
		this.name1 = name1;
		this.name2 = name2;
	}

	public String getName1() {
		return name1;
	}

	public void setName1(String name1) {
		this.name1 = name1;
	}

	public String getName2() {
		return name2;
	}

	public void setName2(String name2) {
		this.name2 = name2;
	}

}

測試代碼

package cn.jason01;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Test02 {
	public static void main(String[] args) {
		// 創建集合1
		List list1 = new ArrayList();
		list1.add("a");
		list1.add("b");
		list1.add("c");

		// 創建集合2
		List list2 = new ArrayList();
		list2.add("d");
		list2.add("e");
		list2.add("f");
		// 創建集合三
		List list3 = new ArrayList();

		// 遍歷第一和第二個集合，並添加元素到集合三
		for (Iterator i = list1.iterator(); i.hasNext();) {
			// System.out.println(i.next());
			String s = (String) i.next();
			for (Iterator j = list2.iterator(); j.hasNext();) {
				// list2.add(new Student(s,j.next()));
				String ss = (String) j.next();
				list3.add(new Student(s, ss));
			}
		}

		// 遍歷集合三，並輸出元素
		Student st;
		for (Iterator k = list3.iterator(); k.hasNext(); System.out
				.println(new StringBuilder().append(st.getName1()).append(st.getName2()))) {
			st = (Student) k.next();
		}
	}
}

上面的代碼如果去掉註釋的兩行代碼，程序就會報錯，因爲集合沒有聲明元素是什麼類型，迭代器自然也不知道是什麼類型。所以沒有泛型，那麼就要向下轉型，只能用迭代器，不能用增強for。

2.泛型與增強for

泛型修改上面代碼

package cn.jason01;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 * 增強for和泛型完美結合
 * 
 * @author cassandra
 */
public class Test03 {
	public static void main(String[] args) {
		// 創建集合1
		List<String> list1 = new ArrayList<String>();
		list1.add("a");
		list1.add("b");
		list1.add("c");

		// 創建集合2
		List<String> list2 = new ArrayList<String>();
		list2.add("d");
		list2.add("e");
		list2.add("f");
		// 創建集合三
		List<Student> list3 = new ArrayList<Student>();

		//// 遍歷第一和第二個集合，並添加元素到集合三
		for (String s1 : list1) {
			for (String s2 : list2) {
				list3.add(new Student(s1, s2));
			}
		}

		// 遍歷集合三，並輸出元素
		for (Student st : list3) {
			System.out.println(new StringBuilder().append(st.getName1()).append(st.getName2()));
		}
	}
}

4.List集合遍歷四種方法

Collection接口中有iterator()方法，返回的是Iterator類型，有一個迭代器爲Iterator。List中有listIterator()方法，所以多了一個集合器ListIterator，其子類LinkedList、ArrayList、Vector都實現了List和Collection接口，所以都可以用兩個迭代器遍歷。

代碼測試

package cn.jason05;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

/**
 * 這是List集合遍歷四種方法
 * 
 * @author cassandra
 */

public class ForDemo01 {
	public static void main(String[] args) {
		// 創建集合
		List<String> list = new ArrayList<String>();
		list.add("hello");
		list.add("world");
		list.add("java");

		// 方法1，Iterator迭代器遍歷
		Iterator<String> i = list.iterator();
		while (i.hasNext()) {
			String s = i.next();
			System.out.println(s);
		}

		// 方法2，ListIterator迭代器遍歷集合
		ListIterator<String> lt = list.listIterator();
		while (lt.hasNext()) {
			String ss = lt.next();
			System.out.println(ss);
		}

		// 方法3，普通for遍歷集合
		for (int x = 0; x < list.size(); x++) {
			String sss = list.get(x);
			System.out.println(sss);
		}

		// 方法4，增強for遍歷集合
		for (String ssss : list) {
			System.out.println(ssss);
		}

	}
}

5.Set集合遍歷2中方法

由於Set集合沒有get(int index)方法，所以沒有普通for循環，Set中沒有listIterator()方法，所以沒有ListIterator迭代器。所以只有兩種遍歷方式。

代碼測試

package cn.jason05;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class ForTest03 {
	public static void main(String[] args) {
		Set<String> set = new HashSet<String>();
		set.add("hello");
		set.add("world");
		set.add("java");

		// 方法1，Iterator迭代器遍歷集合
		Iterator<String> it = set.iterator();
		while (it.hasNext()) {
			System.out.println(it.next());
		}

		// 方法2，增強for遍歷集合
		for (String s : set) {
			System.out.println(s);
		}

	}
}

7.歸納總結

1.增強for的適用性以及侷限性

適用性：適用於集合和數組的遍歷。

侷限性：

①集合不能爲null，因爲底層是迭代器。

②不能設置角標。

③隱藏了迭代器，所以在遍歷集合時不能對集合進行修改(增刪)。

2.在集合中增強for與泛型結合，才能發揮新特性的作用。

3.查看官網新特性挺重要的，要知其然還要知其所以然，瞭如心中，才能運用自如。