有說這個快，有說那個快，但是，靠嘴不頂用啊。還是測試一下就知道啦。

(Lists.newArrayList(); 這個是guava裡面的一個集合初始化的工具)

如下 ：

先是main方法吧

    /**
     * 測試不同for的效率問題
     */
    private static void testForEfficiency() {
        List<String> arrayList = CollectionUtil.getArrayList();
        List<String> linkedList = CollectionUtil.getLinkedList();
        testForI(arrayList, linkedList);
        testForEach(arrayList, linkedList);
        testForLambda(arrayList, linkedList);
    }
 

package com.lxk.util;

import com.google.common.collect.Lists;

import java.util.List;

/**
 * 自定義集合告警類
 *
 * @author lxk on 2017/11/13
 */
public class CollectionUtil {
    private static final int SIZE = 1000000;

    /**
     * 獲得底層是陣列的list集合
     */
    public static List<String> getArrayList() {
        List<String> list = Lists.newArrayListWithExpectedSize(SIZE);
        for (Integer i = 0; i < SIZE; i++) {
            list.add(i.toString());
        }
        return list;
    }

    /**
     * 獲得底層是連結串列的list集合
     */
    public static List<String> getLinkedList() {
        List<String> list = Lists.newArrayListWithExpectedSize(SIZE);
        for (Integer i = 0; i < SIZE; i++) {
            list.add(i.toString());
        }
        return list;
    }
}
 

    /**
     * for i
     *
     * @param arrayList  arrayList
     * @param linkedList linkedList
     */
    private static void testForI(List<String> arrayList, List<String> linkedList) {
        int size = arrayList.size();
        StringBuilder sb = new StringBuilder();
        long a = System.currentTimeMillis();
        for (int i = 0; i < size; i++) {
            sb.append(arrayList.get(i));
        }
        PrintUtil.printRunTime(a, "for i for arrayList");

        size = linkedList.size();
        sb = new StringBuilder();
        a = System.currentTimeMillis();
        for (int i = 0; i < size; i++) {
            sb.append(linkedList.get(i));
        }
        PrintUtil.printRunTime(a, "for i for linkedList");
    }

    /**
     * for each
     *
     * @param arrayList  arrayList
     * @param linkedList linkedList
     */
    private static void testForEach(List<String> arrayList, List<String> linkedList) {
        StringBuilder sb = new StringBuilder();
        long a = System.currentTimeMillis();
        for (String s : arrayList) {
            sb.append(s);
        }
        PrintUtil.printRunTime(a, "for each for arrayList");

        sb = new StringBuilder();
        a = System.currentTimeMillis();
        for (String s : linkedList) {
            sb.append(s);
        }
        PrintUtil.printRunTime(a, "for each for linkedList");
    }

    /**
     * Java 8 的for迴圈
     *
     * @param arrayList  arrayList
     * @param linkedList linkedList
     */
    private static void testForLambda(List<String> arrayList, List<String> linkedList) {
        StringBuilder sb = new StringBuilder();
        long a = System.currentTimeMillis();
        arrayList.forEach(sb::append);
        PrintUtil.printRunTime(a, "Lambda for arrayList");

        sb = new StringBuilder();
        a = System.currentTimeMillis();
        linkedList.forEach(sb::append);
        PrintUtil.printRunTime(a, "Lambda for linkedList");
    }
 

package com.lxk.util;

/**
 * @author lxk on 2017/9/27
 */
public class PrintUtil {
    public static void divideLine() {
        System.out.println("--------------分界符--------------");
    }

    /**
     * @param a        long a=System.currentTimeMillis();
     * @param describe 執行時間的描述
     */
    public static void printRunTime(long a, String describe) {
        System.out.println(describe + " 執行耗時 : " + (System.currentTimeMillis() - a) + " 毫秒 ");
    }
}

for i for arrayList 執行耗時 : 105 毫秒 
for i for linkedList 執行耗時 : 22 毫秒 
for each for arrayList 執行耗時 : 44 毫秒 
for each for linkedList 執行耗時 : 25 毫秒 
Lambda for arrayList 執行耗時 : 74 毫秒 
Lambda for linkedList 執行耗時 : 44 毫秒 

for i for arrayList 執行耗時 : 164 毫秒 
for i for linkedList 執行耗時 : 29 毫秒 
for each for arrayList 執行耗時 : 91 毫秒 
for each for linkedList 執行耗時 : 27 毫秒 
Lambda for arrayList 執行耗時 : 94 毫秒 
Lambda for linkedList 執行耗時 : 43 毫秒 

for i for arrayList 執行耗時 : 114 毫秒 
for i for linkedList 執行耗時 : 26 毫秒 
for each for arrayList 執行耗時 : 52 毫秒 
for each for linkedList 執行耗時 : 28 毫秒 
Lambda for arrayList 執行耗時 : 92 毫秒 
Lambda for linkedList 執行耗時 : 54 毫秒 

for i for arrayList 執行耗時 : 130 毫秒 
for i for linkedList 執行耗時 : 45 毫秒 
for each for arrayList 執行耗時 : 72 毫秒 
for each for linkedList 執行耗時 : 30 毫秒 
Lambda for arrayList 執行耗時 : 96 毫秒 
Lambda for linkedList 執行耗時 : 45 毫秒

for i for arrayList 執行耗時 : 127 毫秒 
for i for linkedList 執行耗時 : 26 毫秒 
for each for arrayList 執行耗時 : 103 毫秒 
for each for linkedList 執行耗時 : 36 毫秒 
Lambda for arrayList 執行耗時 : 123 毫秒 
Lambda for linkedList 執行耗時 : 58 毫秒 

為什麼：

    for each是jdk5.0新增加的一個迴圈結構，可以用來處理集合中的每個元素而不用考慮集合定下標。
    格式就不說了

迴圈的集合：collection必須是一個數組或者是一個實現了lterable介面的類物件。
(Iterator<E> iterator(); List 集合實現了這個介面，它的子類當然也實現了，好吧collection也是實現的，所以這裡可以看到的集合都可以用for each)
Collection
├List
│├LinkedList
│├ArrayList
│└Vector
│　└Stack
└Set

使用for each迴圈語句的優勢在於更加簡潔，更不容易出錯，不必關心下標的起始值和終止值。
forEach不是關鍵字,關鍵字還是for,語句是由iterator實現的，他們最大的不同之處就在於remove()方法上。
 
 一般呼叫刪除和新增方法都是具體集合的方法，例如：
List list = new ArrayList(); list.add(...); list.remove(...);
但是，如果在for each迴圈的過程中呼叫集合的remove()方法，就會導致迴圈出錯，
因為迴圈過程中list.size()的大小變化了，就導致了錯誤。 所以，如果想在迴圈語句中刪除集合中的某個元素，
就要用迭代器iterator的remove()方法，因為它的remove()方法不僅會刪除元素，還會維護一個標誌，
用來記錄目前是不是可刪除狀態，這就涉及到原始碼了，想考慮了可以看下這個異常報錯，連結如下：
（ -->點選這個     http://blog.csdn.net/qq_27093465/article/details/52033629）
例如，你不能連續兩次呼叫它的remove()方法，呼叫之前至少有一次next()方法的呼叫。  
forEach就是為了讓用iterator迴圈訪問的形式簡單，寫起來更方便。當然功能不太全,所以但如有刪除操作，還是要用它原來的形式。

使用for迴圈與使用迭代器iterator的對比
 
效率上的各有優勢
採用ArrayList對隨機訪問比較快，而for迴圈中的get()方法，採用的即是隨機訪問的方法，因此在ArrayList裡，for迴圈較快
採用LinkedList則是順序訪問比較快，iterator中的next()方法，採用的即是順序訪問的方法，因此在LinkedList裡，使用iterator較快
從資料結構角度分析,for迴圈適合訪問順序結構,可以根據下標快速獲取指定元素.而Iterator 
適合訪問鏈式結構,因為迭代器是通過next()和Pre()來定位的.可以訪問沒有順序的集合. 
而使用 Iterator 的好處在於可以使用相同方式去遍歷集合中元素，而不用考慮集合類的內部實現（只要它實現了 java.lang.Iterable 介面），
如果使用 Iterator 來遍歷集合中元素，一旦不再使用 List 轉而使用 Set 來組織資料，
那遍歷元素的程式碼不用做任何修改，如果使用 for 來遍歷，
那所有遍歷此集合的演算法都得做相應調整,
因為List有序,Set無序,結構不同,
他們的訪問演算法也不一樣.