Utilisation récursive du flux.flatMap()

Considérons la classe suivante:

public class Order {

    private String id;

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

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

    // getters & setters
}

NOTE: Il est important de noter que je ne peux pas modifier cette classe, Car je la consomme à partir d'une API externe.

Considérons également la hiérarchie des ordres suivante:

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));

Qui pourrait être représenté visuellement de cette façon:

1
1.1
1.1.1
1.2
2
2.1
2.2
2.3

Maintenant, je veux aplatir cette hiérarchie des ordres dans un List, de sorte que j'obtient:

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

J'ai réussi à le faire en utilisant récursivement flatMap() (avec une classe d'aide), comme suit:

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

C'est la classe d'aide:

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
    }
}

La ligne suivante:

System.out.println(flattened);

Produit la sortie suivante:

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

Jusqu'à présent tout va bien. Le résultat est absolument correcte.

Cependant, après avoir lu cette question, j'ai eu quelques préoccupations concernant l'utilisation de flatMap() dans une méthode récursive. En particulier, je voulais savoir comment le flux était en cours d'expansion (si c'est le terme). J'Ai Donc modifié la classe Helper et utilisé peek(System.out::println) pour vérifier ceci:

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);
    }
}

Et la sortie était:

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

Je ne suis pas sûr si c'est la sortie qui devrait être imprimée.

Donc, je me demande s'il est correct de laisser les flux intermédiaires contenir des éléments répétés. En outre, quels sont les avantages et les inconvénients de cette approche? Est-il correct, après tout, d'utiliser flatMap() de cette façon? Est-il une meilleure façon d'obtenir les mêmes?