最近學習使用lambda表示式的時候,碰到lambda的內部迭代迴圈,書寫十分方便,但是不知道執行效率如何,於是自己進行了一個測試.

demo程式碼:

package com.example.demo;

import io.swagger.models.auth.In;

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

/**
 * 普通for迴圈,foreach增強迴圈,lambda表示式foreach效能的測試
 */
public class ForEachTest {
    
 
public static void main(String[] args) {
//        System.out.println("ArrayList第一次");
//        testArrayList();
//        System.out.println("ArrayList第二次");
//        testArrayList();
//        System.out.println("ArrayList第三次");
//        testArrayList();

        System.out.println("LinkedList第一次");
        testLinkedList();
        System.out.println(
 
"LinkedList第二次");
        testLinkedList();
        System.out.println("LinkedList第三次");
        testLinkedList();

    }

    /**
     * 初始化測試集合ArrayList
     * @param size
     * @return
     */
    public static List<User> initArrayList(int size){
        List<User> al = new ArrayList<>();
        
 
for (int i = 0; i < size; i++) {
            al.add(new User());
        }
        return al;
    }

    /**
     * 初始化測試集合LinkedList
     * @param size
     * @return
     */
    public static List<User> initLinkedList(int size){
        LinkedList<User> ll = new LinkedList<>();
        for (int i = 0; i < ll.size(); i++) {
            ll.add(new User());
        }
        return ll;
    }

    /**
     * 普通for迴圈
     * @param users
     */
    public static void testFor(List<User> users){
        for (int i = 0; i < users.size(); i++) {
            users.get(i).hashCode();
        }
    }

    /**
     * foreach增強迴圈
     * @param users
     */
    public static void testForEach(List<User> users){
        for (User user : users) {
            user.hashCode();
        }
    }

    /**
     * lambda表示式foreach迴圈
     * @param users
     */
    public static void testLambda(List<User> users){
        users.forEach(user -> user.hashCode());
    }

    /**
     * 測試方法ArrayList
     */
    public static void testArrayList(){
        List<User> users = initArrayList(10000000);
        long time1 = System.nanoTime();
        testFor(users);
        long time2 = System.nanoTime();
        testForEach(users);
        long time3 = System.nanoTime();
        testLambda(users);
        long time4 = System.nanoTime();

        System.out.println("普通for迴圈所需時間: " + (time2 - time1) + "mμs");
        System.out.println("foreach迴圈所需時間: " + (time3 - time2) + "mμs");
        System.out.println("lambda 迴圈所需時間: " + (time4 - time3) + "mμs");
    }

    /**
     * 測試方法LinkedList
     */
    public static void testLinkedList(){
        List<User> users = initLinkedList(10000000);
        long time1 = System.nanoTime();
        testFor(users);
        long time2 = System.nanoTime();
        testForEach(users);
        long time3 = System.nanoTime();
        testLambda(users);
        long time4 = System.nanoTime();

        System.out.println("普通for迴圈所需時間: " + (time2 - time1) + "mμs");
        System.out.println("foreach迴圈所需時間: " + (time3 - time2) + "mμs");
        System.out.println("lambda 迴圈所需時間: " + (time4 - time3) + "mμs");
    }


}

ArrayList千萬元素集合測試結果:

ArrayList第一次
普通for迴圈所需時間: 302337344mμs
foreach迴圈所需時間: 50572324mμs
lambda 迴圈所需時間: 85110328mμs
ArrayList第二次
普通for迴圈所需時間: 436025007mμs
foreach迴圈所需時間: 40059824mμs
lambda 迴圈所需時間: 32511582mμs
ArrayList第三次
普通for迴圈所需時間: 442201775mμs
foreach迴圈所需時間: 33280390mμs
lambda 迴圈所需時間: 29819309mμs

根據測試結果可知:　　

　　首次遍歷ArrayList集合,普通for迴圈效率<lambda迴圈<foreach迴圈,但是第二次開始lambda迴圈的效率變高,lambda的forEach迴圈在首次執行的時候會初始化部分內容，從而導致執行過慢.

　　實際使用推薦foreach和lambda.【可將lambda表達式的初始化放到項目啟動的過程中，這樣可以大大提高lambda表達式的性能。】

LinkedList千萬元素集合測試結果:

LinkedList第一次
普通for迴圈所需時間: 5452mμs
foreach迴圈所需時間: 273590mμs
lambda 迴圈所需時間: 49361539mμs
LinkedList第二次
普通for迴圈所需時間: 641mμs
foreach迴圈所需時間: 2887mμs
lambda 迴圈所需時間: 1925mμs
LinkedList第三次
普通for迴圈所需時間: 321mμs
foreach迴圈所需時間: 1603mμs
lambda 迴圈所需時間: 963mμs

根據測試結果可知:　　

　　首次遍歷LinkedList集合,lambda效率<foreach迴圈<普通for迴圈