Java 8 Streams - 收集与减少

Question

您什么时候使用collect() 和reduce()？有没有人有好的、具体的例子说明什么时候选择一种方式肯定更好？

Javadoc mentions that collect() is a mutable reduction.

鉴于这是一个可变的缩减，我认为它需要同步（内部），而这反过来又会损害性能。大概reduce() 更容易并行化，代价是必须在reduce 的每一步之后创建一个新的数据结构以返回。

不过，以上陈述都是猜测，我希望专家能在此插话。

Answer 1

reduce 是一个“fold”操作，它将二元运算符应用于流中的每个元素，其中运算符的第一个参数是前一个应用程序的返回值，第二个参数是当前流元素.

collect 是一种聚合操作，其中创建了一个“集合”并将每个元素“添加”到该集合中。然后将流中不同部分的集合添加到一起。

document you linked 给出了采用两种不同方法的原因：

如果我们想要获取一个字符串流并将它们连接成一个 单个长字符串，我们可以通过普通的归约来实现：

 String concatenated = strings.reduce("", String::concat)  

我们会得到想要的结果，它甚至可以并行工作。 但是，我们可能对性能不满意！这样一个 实现会做大量的字符串复制，然后运行 时间将是 O(n^2) 的字符数。更高效的 方法是将结果累积到 StringBuilder 中， 这是一个用于累积字符串的可变容器。我们可以使用 与普通的并行化可变缩减相同的技术 减少。

所以重点是两种情况下的并行化是相同的，但在reduce 的情况下，我们将函数应用于流元素本身。在collect 的情况下，我们将函数应用于可变容器。

Answer 2

原因很简单：

• collect() 只能与可变结果对象一起工作。
• reduce()设计用于与不可变结果对象。

“reduce() 不可变”示例

public class Employee {
  private Integer salary;
  public Employee(String aSalary){
    this.salary = new Integer(aSalary);
  }
  public Integer getSalary(){
    return this.salary;
  }
}

@Test
public void testReduceWithImmutable(){
  List<Employee> list = new LinkedList<>();
  list.add(new Employee("1"));
  list.add(new Employee("2"));
  list.add(new Employee("3"));

  Integer sum = list
  .stream()
  .map(Employee::getSalary)
  .reduce(0, (Integer a, Integer b) -> Integer.sum(a, b));

  assertEquals(Integer.valueOf(6), sum);
}

“collect() 可变”示例

例如如果您想使用collect() 手动计算总和，则它不能与BigDecimal 一起使用，而只能与来自org.apache.commons.lang.mutable 的MutableInt 一起使用。见：

public class Employee {
  private MutableInt salary;
  public Employee(String aSalary){
    this.salary = new MutableInt(aSalary);
  }
  public MutableInt getSalary(){
    return this.salary;
  }
}

@Test
public void testCollectWithMutable(){
  List<Employee> list = new LinkedList<>();
  list.add(new Employee("1"));
  list.add(new Employee("2"));

  MutableInt sum = list.stream().collect(
    MutableInt::new, 
    (MutableInt container, Employee employee) -> 
      container.add(employee.getSalary().intValue())
    , 
    MutableInt::add);
  assertEquals(new MutableInt(3), sum);
}

这是可行的，因为 accumulator container.add(employee.getSalary().intValue()); 不应该返回带有结果的新对象，而是更改 MutableInt 类型的可变 container 的状态。

如果您想使用BigDecimal 代替container，则不能使用collect() 方法，因为container.add(employee.getSalary()); 不会更改container，因为BigDecimal 是不可变的。 （除此之外BigDecimal::new 将无法工作，因为BigDecimal 没有空构造函数）

Answer 3

正常归约是指将两个不可变值组合起来，例如int、double等，并产生一个新的值；这是一个不可变缩减。相比之下，collect 方法旨在改变容器以累积它应该产生的结果。

为了说明问题，假设您想使用类似的简单归约来实现Collectors.toList()

List<Integer> numbers = stream.reduce(
        new ArrayList<Integer>(),
        (List<Integer> l, Integer e) -> {
            l.add(e);
            return l;
        },
        (List<Integer> l1, List<Integer> l2) -> {
            l1.addAll(l2);
            return l1;
        });

这相当于Collectors.toList()。但是，在这种情况下，您改变了 List<Integer>。正如我们所知，ArrayList 不是线程安全的，在迭代时从其中添加/删除值也不安全，因此当您遇到并发异常或ArrayIndexOutOfBoundsException 或任何类型的异常时（尤其是并行运行时）更新列表或组合器尝试合并列表，因为您正在通过累积（添加）整数来改变列表。如果你想让这个线程安全，你需要每次都传递一个新列表，这会影响性能。

相比之下，Collectors.toList() 的工作方式类似。但是，当您将值累积到列表中时，它可以保证线程安全。来自documentation for the collect method：

使用收集器对此流的元素执行可变归约操作。如果流是并行的，并且收集器是并发的，并且要么 流是无序的或收集器是无序的，那么 将执行并发减少。 并行执行时，可能会实例化、填充和合并多个中间结果，以保持可变数据结构的隔离。 因此，即使与非线程安全数据并行执行结构（例如 ArrayList），并行缩减不需要额外的同步。

所以回答你的问题：

您什么时候使用collect() 和reduce()？

如果您有诸如ints、doubles、Strings 之类的不可变值，那么正常的归约就可以了。但是，如果您必须将您的值 reduce 转换为 List（可变数据结构），那么您需要通过 collect 方法使用可变归约。

Answer 4

让流为a

在减少，

你将拥有 ((a # b) # c) # d

其中 # 是您想做的有趣操作。

收藏中，

您的收集器将具有某种收集结构 K。

K 消耗 a。 然后 K 消耗 b。 然后K消耗c。 K 然后消耗 d。

最后你问K最后的结果是什么。

K 然后给你。

Answer 5

它们在运行时的潜在内存占用方面非常不同。 collect() 收集所有数据并将其放入集合中，reduce() 明确要求您指定如何减少通过流的数据。

例如，如果您想从文件中读取一些数据，对其进行处理，并将其放入某个数据库中，您最终可能会得到类似这样的 java 流代码：

streamDataFromFile(file)
            .map(data -> processData(data))
            .map(result -> database.save(result))
            .collect(Collectors.toList());

在这种情况下，我们使用collect() 来强制java 流式传输数据并将结果保存到数据库中。没有collect()，数据永远不会被读取和存储。

如果文件大小足够大或堆大小足够低，此代码会愉快地生成java.lang.OutOfMemoryError: Java heap space 运行时错误。显而易见的原因是它试图将通过流的所有数据（事实上，已经存储在数据库中）堆叠到结果集合中，这会炸毁堆。

但是，如果您将collect() 替换为reduce()，这将不再是问题，因为后者会减少并丢弃所有通过它的数据。

在给出的示例中，只需将 collect() 替换为 reduce：

.reduce(0L, (aLong, result) -> aLong, (aLong1, aLong2) -> aLong1);

您甚至不需要关心使计算依赖于result，因为 Java 不是纯 FP（函数式编程）语言，并且无法优化流底部未使用的数据，因为可能的副作用。

Answer 6

这是代码示例

List<Integer> list = Arrays.asList(1,2,3,4,5,6,7);
int sum = list.stream().reduce((x,y) -> {
        System.out.println(String.format("x=%d,y=%d",x,y));
        return (x + y);
    }).get();

System.out.println(sum);

执行结果如下：

x=1,y=2
x=3,y=3
x=6,y=4
x=10,y=5
x=15,y=6
x=21,y=7
28

reduce函数句柄有两个参数，第一个参数是流中前一个返回值，第二个参数是当前 计算流中的值，将第一个值和当前值相加作为下次计算的第一个值。

Answer 7

根据the docs

reducing() 收集器在用于多级归约、groupingBy 或 partitioningBy 下游时最有用。要对流执行简单的归约，请改用 Stream.reduce(BinaryOperator)。

所以基本上你只会在收集中强制使用reducing()。 这是另一个example：

 For example, given a stream of Person, to calculate the longest last name 
 of residents in each city:

    Comparator<String> byLength = Comparator.comparing(String::length);
    Map<String, String> longestLastNameByCity
        = personList.stream().collect(groupingBy(Person::getCity,
            reducing("", Person::getLastName, BinaryOperator.maxBy(byLength))));

根据this tutorialreduce 有时效率较低

reduce 操作总是返回一个新值。但是，累加器函数在每次处理流的元素时也会返回一个新值。假设您要将流的元素简化为更复杂的对象，例如集合。这可能会妨碍您的应用程序的性能。如果您的 reduce 操作涉及将元素添加到集合中，那么每次您的累加器函数处理一个元素时，它都会创建一个包含该元素的新集合，这是低效的。相反，更新现有集合对您来说会更有效。您可以使用 Stream.collect 方法执行此操作，下一节将对此进行介绍...

所以身份在 reduce 场景中被“重复使用”，所以如果可能的话，使用.reduce 会更有效。

Answer 8

有一个很好的理由总是更喜欢 collect() 而不是 reduce() 方法。 使用 collect() 的性能要高得多，如下所述：

Java 8 tutorial

*可变归约操作（例如 Stream.collect()）在处理流元素时将其收集到可变结果容器（集合）中。 与不可变归约操作（例如 Stream.reduce()）相比，可变归约操作提供了大大提高的性能。

这是因为在每个归约步骤中保存结果的集合对于收集器来说是可变的，并且可以在下一步中再次使用。

另一方面，Stream.reduce() 操作使用不可变的结果容器，因此需要在缩减的每个中间步骤实例化容器的新实例，这会降低性能。*