避免peek（）和forEach（）的侧面影响

Question

这是一个关于示例项目的基本问题，因为我仍在学习Java8个特性的最佳实践。

假设我有一个OrderDetail对象，该对象表示OrderDetail的List。同时，OrderDetail包含一个源代码和一个命运，以及数量和产品。

对于本例，我将把产品从源移动到命运，这两个都是产品仓库对象，具有availableStock属性，这将受到订单结果的影响。

现在，我需要更新所有源代码和destiny-ie的availableStock。库存应在destiny-ies增加，在sources减少OrderDetail的数量。由于destiny和source属于同一类型，我可以同时更新它们。问题是，当然，它们是不同的属性。

我的第一个想法是：

//Map keeps record of the sum of products moved from the source. Key is the id the Product
HashMap<Integer, Double> quantities;

ArrayList<OrderDetail> orderDetails;

/**
*  This could've been a single stream, but I divided it in two for readability here
*  If not divided, the forEach() method from ArrayList<> might been enough though
*/
public void updateStock() {
    List<ProductWarehouse> updated = new ArrayList<>();
    orderDetails.stream()
        .map(OrderDetail::getSource)
        .forEach(src -> {
            src.setAvailableStock(src.getAvailableStock - quantities.get(src.getProductId()));
            updated.add(src);
        });
    orderDetails.stream()
        .map(OrderDetail::getDestiny)
        .forEach(dst -> {
            dst.setAvailableStock(dst.getAvailableStock + quantities.get(dst.getProductId()));
            updated.add(dst);
        });
    productWarehouseRepository.save(updated);
}

虽然这行得通，但有一个问题：这就像Javadoc中关于“不必要的副作用”的例子。这并不完全相同，但考虑到它们的相似之处，我认为我在冒可以避免的风险。

我想到的另一个选择是使用peek（），它有自己的含义，因为根据javadoc，该方法主要被认为是一个调试工具。

HashMap<Integer, Double> quantities;
ArrayList<OrderDetail> orderDetails;

/**
* Either make it less readable and do one save or do one save for source and one for destiny
* I could also keep the updated list from before and addAll() the result of each .collect()
*/
public void updateStock() {
    productWarehouseRepository.save(
        orderDetails.stream()
            .map(/*Same as above*/)
            .peek(src -> {/*Same as above*/})
            .collect(toList()) //static import
    );
}

我也在一些博客文章中读到，应该避免peek。这也是因为文档说明了它的用法（主要是）。

因此，问题是：如果我想使用StreamAPI修改Collection的属性，那么遵循最佳实践的最佳方法是什么？对于这样的例子，使用Iterable.for每个（）还是简单的增强for循环更好？老实说，我看不出像这样使用Stream的操作会产生什么副作用，但这可能是由于缺乏经验和对应用编程接口的理解。

这个问题中的代码只是为了举例，但是如果模型或更多信息更容易理解，我可以添加它。




Answer 1

在这两种情况下，forEach都是一个终端操作，因此应该改用map

如果您想避免副作用，请在map中调用setter方法，然后将其收集到列表中，并将其添加到外部列表中。

updated.addAll(orderDetails.stream().map()...collect(Collectors.toList())

相关解决方案-如何将Java8流的元素添加到现有列表中

Answer 2

您希望执行两个不同的操作。

>

更新每个productWarehouse对象

将所有ProductWarehouse对象收集到一个列表中，以便保存

不要把这两种操作混在一起。

public void updateStock() {
    orderDetails.forEach(o -> {
        ProductWarehouse src = o.getSource();
        src.setAvailableStock(src.getAvailableStock()-quantities.get(src.getProductId()));
        ProductWarehouse dst = o.getDestiny();
        dst.setAvailableStock(dst.getAvailableStock()+quantities.get(dst.getProductId()));
    });
    List<ProductWarehouse> updated = orderDetails.stream()
        .flatMap(o -> Stream.of(o.getSource(), o.getDestiny()))
        .collect(Collectors.toList());
    productWarehouseRepository.save(updated);
}

试图不惜一切代价在单个流操作中执行所有内容是没有意义的。在很少的情况下，迭代两次源是费用或不能保证产生相同的元素，您可以迭代结果列表，例如。

public void updateStock() {
    List<ProductWarehouse> updated = orderDetails.stream()
        .flatMap(o -> Stream.of(o.getSource(), o.getDestiny()))
        .collect(Collectors.toList());
    for(int ix = 0; ix < updated.size(); ) {
        ProductWarehouse src = updated.get(ix++);
        src.setAvailableStock(src.getAvailableStock()-quantities.get(src.getProductId()));
        ProductWarehouse dst = updated.get(ix++);
        dst.setAvailableStock(dst.getAvailableStock()+quantities.get(dst.getProductId()));
    }
    productWarehouseRepository.save(updated);
}

第二次迭代绝对便宜。