我有以下代码:

mostRecentMessageSentDate = messageInfoList
    .stream()
    .findFirst().orElse(new MessageInfo())
    .getSentDate();

unprocessedMessagesCount = messageInfoList
    .stream()
    .filter(messageInfo -> messageInfo.getProcessedDate() == null)
    .count();

hasAttachment = messageInfoList
    .stream()
    .anyMatch(messageInfo -> messageInfo.getAttachmentCount() > 0);

如您所见，我将同一个列表流式传输 3 次，因为我想找到 3 个不同的值。如果我在 For-Each 循环中执行此操作，我可以只循环一次。

那么做这个 for 循环是否更好，性能更明智，这样我只循环一次？我发现流更具可读性。

编辑:我进行了一些测试:

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class Main {

public static void main(String[] args) {

    List<Integer> integerList = populateList();

    System.out.println("Stream time: " + timeStream(integerList));
    System.out.println("Loop time: " + timeLoop(integerList));

}

private static List<Integer> populateList() {
    return IntStream.range(0, 10000000)
            .boxed()
            .collect(Collectors.toList());
}

private static long timeStream(List<Integer> integerList) {
    long start = System.currentTimeMillis();

    Integer first = integerList
            .stream()
            .findFirst().orElse(0);

    long containsNumbersGreaterThan10000 = integerList
            .stream()
            .filter(i -> i > 10000)
            .count();

    boolean has10000 = integerList
            .stream()
            .anyMatch(i -> i == 10000);

    long end = System.currentTimeMillis();

    System.out.println("first: " + first);
    System.out.println("containsNumbersGreaterThan10000: " + containsNumbersGreaterThan10000);
    System.out.println("has10000: " + has10000);

    return end - start;
}

private static long timeLoop(List<Integer> integerList) {
    long start = System.currentTimeMillis();

    Integer first = 0;
    boolean has10000 = false;
    int count = 0;
    long containsNumbersGreaterThan10000 = 0L;
    for (Integer i : integerList) {
        if (count == 0) {
            first = i;
        }

        if (i > 10000) {
            containsNumbersGreaterThan10000++;
        }

        if (!has10000 && i == 10000) {
            has10000 = true;
        }

        count++;
    }

    long end = System.currentTimeMillis();

    System.out.println("first: " + first);
    System.out.println("containsNumbersGreaterThan10000: " + containsNumbersGreaterThan10000);
    System.out.println("has10000: " + has10000);

    return end - start;
}
}

正如预期的那样，for 循环总是比流快

first: 0
containsNumbersGreaterThan10000: 9989999
has10000: true
Stream time: 57
first: 0
containsNumbersGreaterThan10000: 9989999
has10000: true
Loop time: 38

但从来没有显着。

findFirst 可能是一个不好的例子，因为如果流为空它就会退出，但我想知道它是否有所作为。

我希望得到一个允许从一个流进行多次计算的解决方案。 IntSummaryStatistics 并没有完全按照我的意愿行事。我想我会注意@florian-schaetz 并坚持支持可读性以获得边际性能提升

最佳答案

您不会遍历集合 3 次。

mostRecentMessageSentDate = messageInfoList
        .stream()
        .findFirst().orElse(new MessageInfo())
        .getSentDate();

以上检查集合中是否有任何元素，并根据此返回一个值。它不需要遍历整个集合。

unprocessedMessagesCount = messageInfoList
        .stream()
        .filter(messageInfo -> messageInfo.getProcessedDate() == null)
        .count();

这个需要过滤掉所有没有处理日期的元素并对它们进行计数，所以这个要遍历整个集合。

hasAttachment = messageInfoList
        .stream()
        .anyMatch(messageInfo -> messageInfo.getAttachmentCount() > 0);

上面只需要遍历元素，直到找到带有附件的消息。

因此，在三个流中，只有其中一个需要遍历整个集合，在最坏的情况下，您需要进行两次迭代(第二个，可能是第三个流) .

使用常规的 For-Each 循环可能会更有效，但您真的需要它吗？如果您的集合只包含几个对象，我不会费心去优化它。

但是，使用传统的 For-Each 循环，您可以组合最后两个流:

int unprocessedMessagesCount = 0;
boolean hasAttachment = false;

for (MessageInfo messageInfo: messageInfoList) {
  if (messageInfo.getProcessedDate() == null) {
    unprocessedMessagesCount++;
  }
  if (hasAttachment == false && messageInfo.getAttachmentCount() > 0) {
    hasAttachment = true;
  }
}

如果您认为这是一个更好的解决方案，这真的取决于您(我还发现流更具可读性)。我看不到将三个流合并为一个流的方法，至少不是以更具可读性的方式。

关于java - 我应该流多次还是在一个流中进行所有计算？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/44237839/