Stream.FlatMap（）的递归使用

Question

请考虑以下类：

public class Order {

    private String id;

    private List<Order> orders = new ArrayList<>();

    @Override
    public String toString() {
        return this.id;
    }

    // getters & setters
}

注意：很重要的一点是，我不能修改这个类，因为我是从外部API中使用它的。

还要考虑以下订单层次结构：

Order o1 = new Order();
o1.setId("1");
Order o11 = new Order();
o11.setId("1.1");
Order o111 = new Order();
o111.setId("1.1.1");
List<Order> o11Children = new ArrayList<>(Arrays.asList(o111));
o11.setOrders(o11Children);

Order o12 = new Order();
o12.setId("1.2");
List<Order> o1Children = new ArrayList<>(Arrays.asList(o11, o12));
o1.setOrders(o1Children);

Order o2 = new Order();
o2.setId("2");
Order o21 = new Order();
o21.setId("2.1");
Order o22 = new Order();
o22.setId("2.2");
Order o23 = new Order();
o23.setId("2.3");
List<Order> o2Children = new ArrayList<>(Arrays.asList(o21, o22, o23));
o2.setOrders(o2Children);

List<Order> orders = new ArrayList<>(Arrays.asList(o1, o2));

1
1.1
1.1.1
1.2
2
2.1
2.2
2.3

[1, 1.1, 1.1.1, 1.2, 2, 2.1, 2.2, 2.3]

通过递归地使用flatmap()（以及一个helper类），我已经设法做到了这一点，如下所示：

List<Order> flattened = orders.stream()
    .flatMap(Helper::flatten)
    .collect(Collectors.toList());

这是helper类：

public final class Helper {

    private Helper() {
    }

    public static Stream<Order> flatten(Order order) {
        return Stream.concat(
            Stream.of(order), 
            order.getOrders().stream().flatMap(Helper::flatten)); // recursion here
    }
}

以下一行：

System.out.println(flattened);

产生以下输出：

[1, 1.1, 1.1.1, 1.2, 2, 2.1, 2.2, 2.3]

到目前为止还不错。结果是绝对正确的。

但是，在阅读了这个问题之后，我对flatmap()在递归方法中的用法有些担心。特别是，我想知道流是如何被扩展的（如果这是术语的话）。因此，我修改了helper类，并使用peek(System.out::println)检查以下内容：

public static final class Helper {

    private Helper() {
    }

    public static Stream<Order> flatten(Order order) {
        return Stream.concat(
            Stream.of(order), 
            order.getOrders().stream().flatMap(Helper::flatten))
        .peek(System.out::println);
    }
}

结果是：

1
1.1
1.1
1.1.1
1.1.1
1.1.1
1.2
1.2
2
2.1
2.1
2.2
2.2
2.3
2.3

我不确定这是否是应该打印的输出。

Answer 1

嗯，我在一个泛型tree类中使用了相同的模式，并没有产生错误的感觉。唯一的区别是，tree类本身提供了children()和allDescendes()方法，这两个方法都返回了stream，后者建立在前者的基础上。这与“我应该返回一个集合还是一个流？”和“命名返回流的java方法”有关。

从流的角度来看，对于不同类型的子级的FlatMap（即在遍历属性时）和对于相同类型的子级的FlatMap没有区别。如果返回的流再次包含相同的元素也没有问题，因为流的元素之间没有关系。原则上，您可以使用FlatMap作为Filter操作，使用模式FlatMap(x->condition？stream.of(x):stream.empty())。也可以使用它来复制像这个答案中的元素。