java中迭代列表的各种方法的性能评估

我在java中创建了一个包含10个数字的整数列表。我希望得到列表中数字的总和。为此，我使用了四种方法来迭代列表并返回总和。下面给出了相同的代码

public static void main(String[] args) {

    List<Integer> numbers=Arrays.asList(1,5,10,25,30,17,3,9,11,26);

    //Using simple for loop for finding sum of numbers in the list
    System.out.println(sumOfNumbersUsingSimpleForLoop(numbers));

    //Using listIterator interface for finding sum of numbers in the list
    System.out.println(sumOfNumbersUsingIterableInterface(numbers));

    //Using enhanced for loop for finding sum of numbers in the list
    System.out.println(sumOfNumbersUsingEnhancedForLoop(numbers));

    //Using lambda expression for finding sum of numbers in the list
    System.out.println(sumOfNumbersUsingLambdaExpression(numbers));



}
public static int sumOfNumbersUsingSimpleForLoop(List<Integer> numbers)
{
    int sum=0;
    for(int i=0;i<numbers.size();i++)
    {
        sum=sum+numbers.get(i);
    }
    return sum;
}
public static int sumOfNumbersUsingIterableInterface(List<Integer> numbers) 
{
    int sum=0;
    ListIterator<Integer> iterator=numbers.listIterator();
    while(iterator.hasNext())
    {

            sum=sum+iterator.next();

    }
    return sum;
}
public static int sumOfNumbersUsingEnhancedForLoop(List<Integer> numbers) 
{
    int sum=0;
    for(int number:numbers)
    {
        sum=sum+number;
    }
    return sum;
}
public static int sumOfNumbersUsingLambdaExpression(List<Integer> numbers) 
{
    return numbers.stream().parallel().reduce(0, (e,num)->e+num);
}

publicstaticvoidmain（字符串[]args）{
列表编号=数组.asList（1,5,10,25,30,17,3,9,11,26）；
//使用simple for循环查找列表中的数字之和
System.out.println（sumOfNumbersUsingSimpleForLoop（numbers））；
//使用listIterator接口查找列表中的数字之和
System.out.println（数字和可访问接口（数字））；
//使用增强的for循环查找列表中的数字之和
System.out.println（susingenhancedforloop（数字）之和）；
//使用lambda表达式查找列表中的数字之和
System.out.println（sumOfNumbersUsingLambdaExpression（numbers））；
}
公共静态整数总和使用简单循环（列表编号）
{
整数和=0；
for（int i=0；ie+num）；
}

---

所有这些方法的结果都返回137。对于我来说，使用lambda表达式计算总和是很方便的。但是，如果列表的大小变大，我不确定它的性能。如果有人能举例说明所有方法的性能比较，这将非常有用。

在您的例子中，顺序流不能比for循环快（流也会在列表上循环，但会有一些开销）。for循环应该是等效的

与for循环版本相比，流示例产生的装箱/取消装箱操作要多得多。您可以通过以下方式进行改进：

return numbers.parallelStream().mapToInt(Integer::intValue).sum();

如果您的列表很大，并行流可能会更快（我的猜测是：超过10k+个元素-低于10k+个元素，并行化的开销可能会太高）

---

如果您确实需要性能，您应该使用原语…

在您的情况下，顺序流不能比for循环快（流也会在列表上循环，但会有一些开销）。for循环应该是等效的

与for循环版本相比，流示例产生的装箱/取消装箱操作要多得多。您可以通过以下方式进行改进：

return numbers.parallelStream().mapToInt(Integer::intValue).sum();

如果您的列表很大，并行流可能会更快（我的猜测是：超过10k+个元素-低于10k+个元素，并行化的开销可能会太高）

---

如果您确实需要性能，您应该使用原语…

在您的情况下，顺序流不能比for循环快（流也会在列表上循环，但会有一些开销）。for循环应该是等效的

与for循环版本相比，流示例产生的装箱/取消装箱操作要多得多。您可以通过以下方式进行改进：

return numbers.parallelStream().mapToInt(Integer::intValue).sum();

如果您的列表很大，并行流可能会更快（我的猜测是：超过10k+个元素-低于10k+个元素，并行化的开销可能会太高）

---

如果您确实需要性能，您应该使用原语…

在您的情况下，顺序流不能比for循环快（流也会在列表上循环，但会有一些开销）。for循环应该是等效的

与for循环版本相比，流示例产生的装箱/取消装箱操作要多得多。您可以通过以下方式进行改进：

return numbers.parallelStream().mapToInt(Integer::intValue).sum();

如果您的列表很大，并行流可能会更快（我的猜测是：超过10k+个元素-低于10k+个元素，并行化的开销可能会太高）

---

如果您真的需要性能，您应该使用原语…

在lambda示例中，您可能遇到的唯一假设性能问题是它的并行化。这会导致JVM启动一些线程，这会带来固有的开销成本，再加上通信成本。也就是说，如果您同时处理10亿个整数，那么在大多数情况下，并行化版本的运行速度可能会快得多。如果仅仅因为缺少内核和物理CPU而大量运行它，那么它将出现性能问题。使用单线程示例可以更容易地预测成本，但只要它没有被多次调用（如被真正常用的REST API调用），它在大列表上的运行速度就会更快。

使用lambda示例可能遇到的唯一假设性性能问题是它的并行化。这会导致JVM启动一些线程，这会带来固有的开销成本，再加上通信成本。也就是说，如果您同时处理10亿个整数，那么在大多数情况下，并行化版本的运行速度可能会快得多。如果仅仅因为缺少内核和物理CPU而大量运行它，那么它将出现性能问题。使用单线程示例可以更容易地预测成本，但只要它没有被多次调用（如被真正常用的REST API调用），它在大列表上的运行速度就会更快。

使用lambda示例可能遇到的唯一假设性性能问题是它的并行化。这会导致JVM启动一些线程，这会带来固有的开销成本，再加上通信成本。也就是说，如果您同时处理10亿个整数，那么在大多数情况下，并行化版本的运行速度可能会快得多。如果仅仅因为缺少内核和物理CPU而大量运行它，那么它将出现性能问题。使用单线程示例可以更容易地预测成本，但只要它没有被多次调用（如被真正常用的REST API调用），它在大列表上的运行速度就会更快。

使用lambda示例可能遇到的唯一假设性性能问题是它的并行化。这会导致JVM加速一些线程，这会带来固有的开销成本，再加上com的成本