的確，如果你在百度上搜索java for foreach java8 等關鍵詞會出現很多的搜尋結果，比如這幾個迴圈效率的對比。並且很多博主的結論是java8的foreach迴圈是真的菜，效率不是差的一點點！！！慎用，之類的。

我的思考：若java8的foreach效率如此低下，為何還要推出？難道jdk的開發人員不會優化一下？
帶著這個思考，我仔細看了“已往之不諫”的博主最後為java8 正名的部落格，寫的不錯，測試也很充分（說實話，沒有仔細的閱讀）但是結論很明顯。java8勝了。作者為了證明java8不是吃素的，確實下了不少功夫。
最後的最後，作者提到了，

java8的foreach預熱是jvm級別的，需要預熱。

針對這一點，我想是不是能對作者的第一篇部落格的測試方式進行一下改進？
那我們就給jvm預熱一下，下面是我的測試。

package cn.edu.zua.corejava.java8.foreach;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;

/**
 * ForiForeachJava8ForeachTest
 *
 * @author ascend
 * @date 2018/6/22 15:28.
 */
public class
 
 ForiForeachJava8ForeachTest {


    public static void main(String[] args) {
        // 預熱
        List<Dog> tmpList = listDog(10);
        testFori(tmpList);
        testForeach(tmpList);
        testJava8ForEach(tmpList);

        List<Integer> list = Arrays.asList(10, 50, 250, 1000, 2000, 3000, 5000, 10000
 
, 20000);
        for (int i = 0; i < list.size(); i++) {
            test(list.get(i));
        }
    }

    public static void test(int size) {
        System.out.println("-----------次數:" + size + "------------");
        List<Dog> list = listDog(size);
        long nanoTime = System.nanoTime();
        testFori(list);
        long nanoTime1 = System.nanoTime();
        testForeach(list);
        long nanoTime2 = System.nanoTime();
        testJava8ForEach(list);
        long nanoTime3 = System.nanoTime();

        System.out.println("fori\t\t\t\t" + (int) (nanoTime1 - nanoTime) / 1000.0 + " ms");
        System.out.println("增強for\t\t\t\t" + (int) (nanoTime2 - nanoTime1) / 1000.0 + " ms");
        System.out.println("java8 foreach\t\t" + (int) (nanoTime3 - nanoTime2) / 1000.0 + " ms");
        System.out.println();
    }

    /**
     * 初始化list
     *
     * @param size int
     * @return list
     */
    public static List<Dog> listDog(int size) {
        List<Dog> list = new ArrayList<>();
        for (int i = 0; i < size; i++) {
            list.add(new Dog(i + 1, "dog " + (i + 1)));
        }
        return list;
    }

    /**
     * 測試fori
     *
     * @param list List
     */
    public static void testFori(List<Dog> list) {
        for (int i = 0; i < list.size(); i++) {
            list.get(i).hashCode();
        }
    }

    /**
     * 測試增強for迴圈
     *
     * @param list List
     */
    public static void testForeach(List<Dog> list) {
        for (Dog dog : list) {
            dog.hashCode();
        }
    }

    /**
     * 測試java8的foreach
     *
     * @param list List
     */
    public static void testJava8ForEach(List<Dog> list) {
        list.forEach(dog -> dog.hashCode());
    }
}

/**
 * 測試實體類，用來計算hashCode
 */
class Dog {
    private int age;
    private String name;

    public Dog(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public int hashCode() {
        int result = 17;
        result = 31 * result + age;
        result = 31 * result + (name == null ? 0 : name.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == this) {
            return true;
        }
        if (!(obj instanceof Dog)) {
            return false;
        }
        Dog dog = (Dog) obj;
        return dog.age == this.age &&
                Objects.equals(dog.name, this.name);
    }
}

筆者執行的幾組資料


筆者根據資料1，繪圖如下：

大家也可以多多進行測試。
筆者機器配置：