Вложенная коллекция Flatmap

У меня есть список объектов, некоторые из них могут быть коллекциями. Я хотел бы получить поток простых объектов.

List<Object> objects = List.of(1, 2, "SomeString", List.of(3, 4, 5, 6), 
    7, List.of("a", "b", "c"),
    List.of(8, List.of(9, List.of(10))));

Я хотел бы получить поток с элементами.

1, 2, "SomeString", 3, 4, 5, 6, 7, "a", "b", "c", 8, 9, 10

я пытался

Function<Object, Stream<Object>> mbjectToStreamMapper = null; //define it. I have not figured it out yet!
objects.stream().flatMap(ObjectToStreamMapper).forEach(System.out::println);

Я также проверил пример, который показывает, как использовать рекурсивную функцию, которая выравнивает коллекцию. Однако в этом примере .collect(Collectors.toList()); используется для сохранения промежуточного результата. Collectors.toList() является терминальной операцией, которая сразу же начнет обработку потока. Я хотел бы получить поток, который я могу повторить позже.

Обновить

Я согласен с комментариями, это ужасная идея иметь поток, состоящий из объектов различной природы. Я просто написал этот вопрос для простоты. В реальной жизни может случиться так, что я слушаю различные события и обрабатываю некоторые бизнес-объекты из входящих потоков, некоторые из них могут отправлять поток объектов, другие - просто отдельные объекты.

Ответ 1

Мы можем рекурсивно получить вложенный stream если пройденный объект является экземпляром Collection.

public static void main(String args[]) {
       List<Object> objects = List.of(1, 2, "SomeString", List.of(3, 4, 5, 6),
            7, List.of("a", "b", "c"),
            List.of(8, List.of(9, List.of(10))));
       List<Object> list = objects.stream().flatMap(c -> getNestedStream(c)).collect(Collectors.toList());
}

public static Stream<Object> getNestedStream(Object obj) {
    if(obj instanceof Collection){
        return ((Collection)obj).stream().flatMap((coll) -> getNestedStream(coll));
    }
    return Stream.of(obj);
}

Ответ 2

class Loop {
    private static Stream<Object> flat(Object o) {
        return o instanceof Collection ?
                ((Collection) o).stream().flatMap(Loop::flat) : Stream.of(o);
    }

    public static void main(String[] args) {
        List<Object> objects = List.of(1, 2, "SomeString", List.of( 3, 4, 5, 6),
                7, List.of("a", "b", "c"), List.of(8, List.of(9, List.of(10))));

        List<Object> flat = flat(objects).collect(Collectors.toList());

        System.out.println(flat);
    }
}

Обратите внимание, что List.of(null) бросает NPE.

Ответ 3

Обратите внимание, что в поле можно определить рекурсивные методы:

public class Test {
  static Function<Object,Stream<?>> flat=
    s->s instanceof Collection ? ((Collection<?>)s).stream().flatMap(Test.flat) : Stream.of(s);
  public static void main(String[] args) {
    objects.stream().flatMap(flat).forEach(System.out::print);
  }
}

Ответ 4

Если вы хотите использовать рекурсию, вы можете сделать следующий простой пример:

public static List<Object> flat(Collection list) {
        List<Object> flat = new ArrayList<>();
        for (Object obj : list) {
            if (obj instanceof Collection) {
                flat.addAll(flat((Collection) obj));
            } else {
                flat.add(obj);
            }
        }
        return flat;
    }