版权声明：觉得此文有用的，不嫌麻烦的，就留个言呐，或者点个赞呐(额，就是文章底部的“顶”啦)，要是嫌弃麻烦呢，也麻烦点个赞嘛，要是实在不想点赞呢，也不是不可以。 但是，你要是想踩一脚呢，那还是赶紧，马上，快快的闪人。 小心我手里三十米长的大刀。 哼哼。想想都怕 ！！！ https://blog.csdn.net/qq_27093465/article/details/91890824
在做效率测试的时候，会发现，在代码里面不起眼的一个for循环，会损失掉不少时间。几种for循环要使用哪个，会效率高点，常用的集合一般都是arrayList，他的循环遍历的效率如何，是不是首选的呢？
开局一张图
然后看这个图的运行代码
package com.lxk.commonTest; import com.lxk.util.CollectionUtil; import java.util.List; /** * 关于for循环的测试 * * @author lxk on 2017/4/21 */ public class ForTest { private static final int SIZE = 40000; public static void main(String[] args) { testForEfficiency(); } /** * 测试不同for的效率问题 */ private static void testForEfficiency() { String[] array = CollectionUtil.getArray(SIZE); List<String> arrayList = CollectionUtil.getArrayList(SIZE); List<String> linkedList = CollectionUtil.getLinkedList(SIZE); while (true) { testArray(array); testArrayList(arrayList); //testLinkedList(linkedList); } } /** * array 在使用forI循环的效率测试 */ private static void testArray(String[] array) { testForI(array); testForeach(array); } /** * arrayList 在使用forI循环，forEach循环和lambda循环的效率测试 */ private static void testArrayList(List<String> arrayList) { testForI(arrayList); testForEach(arrayList); testLambda(arrayList); } /** * linkedList 在使用forI循环，forEach循环和lambda循环的效率测试 */ private static void testLinkedList(List<String> linkedList) { testForI(linkedList); testForEach(linkedList); testLambda(linkedList); } private static void testForI(String[] array) { StringBuilder sb = new StringBuilder(); for (int i = 0; i < SIZE; i++) { sb.append(array[i]); } } private static void testForeach(String[] array) { StringBuilder sb = new StringBuilder(); for (String s : array) { sb.append(s); } } private static void testForI(List<String> arrayList) { StringBuilder sb = new StringBuilder(); for (int i = 0; i < SIZE; i++) { sb.append(arrayList.get(i)); } } private static void testForEach(List<String> arrayList) { StringBuilder sb = new StringBuilder(); for (String s : arrayList) { sb.append(s); } } private static void testLambda(List<String> arrayList) { StringBuilder sb = new StringBuilder(); arrayList.forEach(sb::append); } } 先，暂时注释掉linkedList集合的测试代码。
分析一下：
1，数组和集合谁的遍历效率高？
看上面的图，同样的数据，使用ArrayList存储，再遍历最快的占比21.6%，使用数组存储，然后来遍历，时间占比是12.1%。明显是数组循环的时间占比少，所以，数组的遍历效率是比较好的。
2，for i，for each，lambda 三种循环方式，谁好呢？
对于数组来说：我测试的地方数组使用来for i 循环和for each 循环，lambda没得。发现两者是一样的。
同样的数据使用ArrayList去存储，使用三种遍历方式，发现，for each是比较慢的，for i 和lambda的循环效率是差不多的。for i 稍微占点点优势。
然后，打开，linkedList的注释，再来一次。
开局还是一张图
分析一下：
对于linkedList来说，底层是链表结构，for i 循环，是最差的循环方式，
剩下的结论和上面的差不多了
还是数组存储数据，遍历最快，然后就是for i 循环比lambda好一点点，最后是for each循环。
另：使用的另一个造数据的类
package com.lxk.util; import com.google.common.collect.Lists; import com.google.common.collect.Maps; import java.util.List; import java.util.Map; /** * 自定义集合类 * * @author lxk on 2017/11/13 */ public class CollectionUtil { private static final int SIZE = 5; /** * 获得底层是数组的list集合 */ public static List<String> getArrayList(Integer size) { size = (size == null || size <= 0) ? SIZE : size; List<String> list = Lists.newArrayListWithExpectedSize(size); for (Integer i = 0; i < size; i++) { list.add(i.toString() + "1234567890"); } return list; } /** * 获得底层是数组的数组 */ public static String[] getArray(Integer size) { size = (size == null || size <= 0) ? SIZE : size; String[] list = new String[size]; for (Integer i = 0; i < size; i++) { list[i] = (i.toString() + "1234567890"); } return list; } /** * 获得底层是链表的list集合 */ public static List<String> getLinkedList(Integer size) { size = (size == null || size <= 0) ? SIZE : size; List<String> list = Lists.newLinkedList(); for (Integer i = 0; i < size; i++) { list.add(i.toString() + "1234567890"); } return list; } /** * 获得底层是链表的list集合 */ public static Map<String, String> getMap(Integer size) { size = (size == null || size <= 0) ? SIZE : size; Map<String, String> map = Maps.newHashMapWithExpectedSize(size); for (Integer i = 0; i < size; i++) { map.put(i.toString(), i.toString()); } return map; } } 文章来源: https://blog.csdn.net/qq_27093465/article/details/91890824