普通for循环,foreach循环,lambda循环性能对比

最近学习使用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循环

普通for循环,foreach循环,lambda循环性能对比

猜你喜欢