引言
從JDK1.5起，增加了加強型的for迴圈語法，也被稱為 “for-Each 迴圈”。加強型迴圈在運算元組與集合方面增加了很大的方便性。那麼，加強型for迴圈是怎麼解析的呢？同時，這是不是意味著基本for迴圈就會被取代呢？
語法：
for(var item:items){//var 代表各鍾型別
//相關操作
}
複製程式碼一、陣列中的for-each迴圈
我們先來看一下陣列中的 for-Each 迴圈的使用；
String str[]= new String[]{"1","2","3"};
//普通for迴圈
for(int i=0;i<str.length;i++){
String item = str[i];
item += "str";
System.out.println(item);
}
//加強型for迴圈
for(String item:str){
item += "str";
System.out.println(item);
}
複製程式碼通過比較上面例子中的兩種型別的for迴圈，可以看出，for-Each 迴圈編寫起來更加簡單，更加方便程式設計師。因此，在程式中，應該多使用加強型迴圈。
回答一下上面提出的兩個問題：
1、編譯器是怎麼處理陣列中的for-Each迴圈的？
事實上，在陣列中的 for-Each 最終會被編譯器處理成一個普通的for迴圈，也就是說 for-Each迴圈是完全與普通for迴圈等價的，沒有任何特殊的命令。
可以通過反編譯來驗證，很簡單，此處不再多說。
2、在陣列中，for-Each 迴圈能否完全替代普通for迴圈
答案是否定的。雖然for-Each 寫起來方便，但也有以下幾個侷限性：
只能對元素進行順序的訪問；
只能訪問陣列或集合中的所有元素；
迴圈中沒有當前的索引，無法對指定的元素操作。如更換當前索引位置的元素。
二、集合中的for-each迴圈
陣列的加強型的for-Each迴圈很簡單，我們再來看一下集合中的for-Each 迴圈又是怎麼樣的。我們都知道集合中的遍歷都是通過迭代（iterator）完成的。也許有人說，也可以按照下面的方式來遍歷集合，不一定非要使用迭代：
List<String> list = new LinkedList<String>();
list.add("a");
list.add("b");
list.add("c");
for(int i=0;i<list.size();i++){
String item = list.get(i);
System.out.println(item);
}
複製程式碼然而，這種方式對於基於連結串列實現的List來說，是比較耗效能的，因為get(int i)方法包含了一個迴圈，而且這個迴圈就是迭代遍歷一次List，直到遇到第i個元素，才停止迴圈，返回第i個元素。對於數量小，遍歷不頻繁的List來說，開銷可以忽略。否則，開銷將不容忽視。
所以，正確集合遍歷是使用迭代器Iterator來遍歷的：
List<String> list = new LinkedList<String>();
list.add("a");
list.add("b");
list.add("c");
//獲取集合的迭代器
Iterator<String> itor = list.iterator();
//集合的普通for迴圈
for(;itor.hasNext();){//相當於 while(itor.hasNext())
String item = itor.next();
System.out.println(item);
}
複製程式碼再看看對應的for-Each迴圈的例子：
List<String> list = new LinkedList<String>();
list.add("a");
list.add("b");
list.add("c");
for(String item:list){//for-Each
System.out.println(item);
}
複製程式碼可以看出，for-Each迴圈比普通for迴圈要簡潔很多。我們依舊回答上面的兩個問題：
編譯器是如何處理 集合中的for-Each迴圈的？
public static void main(String args[])
{
List list = new LinkedList();
list.add("aa");
list.add("bb");
for(String item:list)
{
if("bb".equals(item))
list.add("cc");
}
}
複製程式碼我們看一下上面例子的 反編譯程式碼：
public static void main(String args[])
{
List list = new LinkedList();
list.add("aa");
list.add("bb");
for(Iterator iterator = list.iterator(); iterator.hasNext();)
{
String item = (String)iterator.next();
if("bb".equals(item))
list.add("cc");
}
}
複製程式碼 與陣列類似，編譯器最終也就是將集合中的for-Each迴圈處理成集合的普通for迴圈。 而集合的Collection介面通過擴充套件Iterable介面來提供iterator()方。那麼我們換一個角度，是不是隻要實現 Iterable介面，提供iterator()方法，也可以使用 for-Each迴圈呢？來看個例子：
class MyList<T> implements Iterable<T>{
private ArrayList<T> list = new ArrayList<>();
public void addId(T id){
list.add(id);
}
public boolean removeId(T id){
return list.remove(id);
}
@Override
public Iterator<T> iterator() {//擴充套件自Iterable介面
//為了簡單起見，就直接使用已有的迭代器
return list.iterator();
}
public static void main(String[] args) {
MyList<String> myList = new MyList<>();
myList.addId("666999");
myList.addId("973219");
//for-Each
for(String item:myList){
System.out.println(item);
}
}
}
複製程式碼 上面的例子編譯通過，並且執行無誤。所以，只要實現了Iterable介面的類，都可以使用for-Each迴圈來遍歷。
1、集合迭代的陷阱
集合迴圈遍歷時所使用的迭代器Iterator有一個要求：在迭代的過程中，除了使用迭代器（如:Iterator.remove()方法）對集合增刪元素外，是不允許直接對集合進行增刪操作。否則將會丟擲 ConcurrentModificationException異常。所以，由於集合的for-Each迴圈本質上使用的還是Iterator來迭代，因此也要注意這個陷阱。for-Each迴圈很隱蔽地使用了Iterator，導致程式設計師很容易忽略掉這個細節，所以一定要注意。看下面的例子，for-Each迴圈中修改了集合。
public static void main(String[] args) {
List<String> list = new LinkedList<>();
list.add("aa");
list.add("bb");
for (String item : list) {//for-Each
if ("bb".equals(item)) {
list.add("cc"); //直接操作list
}
}
}
複製程式碼執行丟擲異常:
上面僅僅是 單執行緒 下的情況，如果你有併發程式設計的基礎的話，就會知道：在 多執行緒 的環境中，執行緒是交替執行的（時間片輪轉排程）。這就意味著，如果有兩個執行緒A、B，執行緒A對集合使用Iterator迭代遍歷，執行緒B則對集合進行增刪操作。執行緒A、B一旦交替執行，就會出現在迭代的同時對集合增刪的效果，也會丟擲異常。解決辦法就是加鎖變成原子操作，多執行緒在這裡不是本文重點，不多說了。
2、集合中的for-each迴圈能代替集合中的普通for迴圈嗎？
同樣也是不能的。集合中的for-Each迴圈的侷限性與陣列的for-Each迴圈是一樣的。集合的for-Each迴圈是不能對集合進行增刪操作、也不能獲取索引。而集合的普通for迴圈可以使用的迭代器提供了對集合的增刪方法（如：Iterator.remove，ListIterator.add()），獲取索引的方法（如：ListIterator.nextIndex()、ListIterator.previousIndex()）；
三、Iterator原始碼分析
我們來分析一下Iterator原始碼，主要看看為什麼在集合迭代時，修改集合可能會丟擲ConcurrentModificationException異常。以ArrayList中實現的Iterator為例。
先來看一下ArrayList.iterator()方法，如下：
public Iterator<E> iterator() {
return new Itr();
}
複製程式碼iterator()方法直接建立了一個類Itr的物件。那就接著看 Itr類的定義吧！發現Itr其實是ArrayList的內部類，實現了 Iterator 介面。
/**
* An optimized version of AbstractList.Itr
*/
private class Itr implements Iterator<E> {
int cursor; // 當前的索引值，index of next element to return
int lastRet = -1; // index of last element returned; -1 if no such
int expectedModCount = modCount;
public boolean hasNext() {
return cursor != size;
}
@SuppressWarnings("unchecked")
public E next() {
checkForComodification();
int i = cursor;
if (i >= size)
throw new NoSuchElementException();
//ArrayList的底層陣列
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i + 1;
return (E) elementData[lastRet = i];
}
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
ArrayList.this.remove(lastRet);
cursor = lastRet;
lastRet = -1;
//再次更新 expectedModCount
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
@Override
@SuppressWarnings("unchecked")
public void forEachRemaining(Consumer<? super E> consumer) {
Objects.requireNonNull(consumer);
final int size = ArrayList.this.size;
int i = cursor;
if (i >= size) {
return;
}
final Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length) {
throw new ConcurrentModificationException();
}
while (i != size && modCount == expectedModCount) {
consumer.accept((E) elementData[i++]);
}
// update once at end of iteration to reduce heap write traffic
cursor = i;
lastRet = i - 1;
checkForComodification();
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
複製程式碼 ArrayList.this.elementData是ArrayList的底層陣列，上面這些方法都很簡單，都是對ArrayList.this.elementData這個底層陣列進行操作。
重點看一下checkForComodification（）方法，這個方法就是用來丟擲 ConcurrentModificationException異常，這個方法也很簡單，就是判斷modCount與expectedModCount是否相等。modCount儲存的AarryList中的元素個數。而expectedModCount則是物件建立時將modCount的值賦給它，也就是說expectedModCount儲存的是迭代器建立時元素的個數。那麼checkForComodification（）方法其實在比較迭代期間，ArrayList元素的個數 是否發生了改變，如果改變了，就丟擲異常。注意一下，expectedModCount除了在宣告時賦值外，也在remove()方法中更新了一次。
總結
無論是在陣列中還是在集合中，for-Each加強型for迴圈都是它們各自的普通for迴圈的一種“簡寫方式”，即兩者意思上是等價的，但前者方便簡單，建議多使用。
for-Each迴圈不能完全代替普通for迴圈，因為for-Each有一定的侷限性。
for-Each迴圈只能用於 陣列、Iterable型別（包括集合）。
集合中的for-Each迴圈本質上使用了Ierator迭代器，所以要注意Itrator迭代陷阱（單執行緒和多執行緒都有問題）。
出處：http://www.cnblogs.com/jinggod/p/8424868.html
文章有不當之處，歡迎指正，你也可以關注我的微信公眾號：`好好學java`，獲取優質學習資源。