Поверните связанные объекты в поток или коллекцию

Я хочу перебрать стек. Элемент stacktrace состоит из throwables, getCause() возвращает следующий throwable. Последний вызов getCause() возвращает значение null. (Пример: a → b → null)

Я попытался использовать Stream.iterable(), что приводит к исключению NullPointerException, поскольку элементы в iterable не могут быть нулевыми. Вот короткая демонстрация проблемы:

  public void process() {
      Throwable b = new Throwable();
      Throwable a = new Throwable(b);
      Stream.iterate(a, Throwable::getCause).forEach(System.out::println);
  }

В настоящее время я использую цикл while для создания коллекции вручную:

public void process() {
    Throwable b = new Throwable();
    Throwable a = new Throwable(b);

    List<Throwable> list = new ArrayList<>();
    Throwable element = a;
    while (Objects.nonNull(element)) {
      list.add(element);
      element = element.getCause();
    }
    list.stream().forEach(System.out::println);
  }

Есть ли лучший способ (более короткий, более функциональный) для достижения этого?

Ответ 1

Я думаю, что вы можете сделать рекурсивный вызов здесь:

static Stream<Throwable> process(Throwable t) {
    return t == null ? Stream.empty() : Stream.concat(Stream.of(t), process(t.getCause()));
}

Ответ 2

Проблема заключается в отсутствующем состоянии остановки в Stream.iterate. В Java 9 вы можете использовать

Stream.iterate(exception, Objects::nonNull, Throwable::getCause)

который эквивалентен Java 9s

Stream.iterate(exception, Throwable::getCause)
      .takeWhile(Objects::nonNull)

См. Stream.iterate или Stream.takeWhile.

Поскольку эта функция не существует в Java 8, потребуется обратный порт:

public static <T> Stream<T>
                  iterate(T seed, Predicate<? super T> hasNext, UnaryOperator<T> next)
{
    Objects.requireNonNull(next);
    Objects.requireNonNull(hasNext);
    return StreamSupport.stream(
        new Spliterators.AbstractSpliterator<T>(Long.MAX_VALUE, Spliterator.ORDERED) {
            T current = seed;
            int state;
            public boolean tryAdvance(Consumer<? super T> action) {
                Objects.requireNonNull(action);
                T value = current;
                if(state > 0) value = next.apply(value);
                else if(state == 0) state = 1;
                else return false;
                if(!hasNext.test(value)) {
                    state = -1;
                    current = null;
                    return false;
                }
                action.accept(current = value);
                return true;
            }
        },
        false);
}

Семантика такая же, как с Java 9s Stream.iterate:

MyStreamFactory.iterate(exception, Objects::nonNull, Throwable::getCause)
               .forEach(System.out::println); // just an example

Ответ 3

Рекурсивный подход Stream::concat() создает весь поток заранее в одном рекурсивном вызове. Ленивый подход takeWhile недоступен до Java 9.

Ниже представлен ленивый подход Java 8:

class NullTerminated {
    public static <T> Stream<T>  stream(T start, Function<T, T> advance) {
        Iterable<T> iterable = () -> new Iterator<T>() {
            T next = start;

            @Override
            public boolean hasNext() {
                return next != null;
            }

            @Override
            public T next() {
                T current = next;
                next = advance.apply(current);
                return current;
            }           
        };
        return StreamSupport.stream(iterable.spliterator(), false);
    }
}

Использование:

Throwable b = new Throwable();
Throwable a = new Throwable(b);

NullTerminated.stream(a, Throwable::getCause).forEach(System.out::println);

Обновление: Замена Iterator/Iterable.spliterator() прямой конструкцией a Spliterator:

class NullTerminated {
    public static <T> Stream<T>  stream(T start, Function<T, T> advance) {
        Spliterator<T> sp = new AbstractSpliterator<T>(Long.MAX_VALUE, Spliterator.ORDERED | Spliterator.NONNULL) {
            T current = start;
            @Override
            public boolean tryAdvance(Consumer<? super T> action) {
                if (current != null) {
                    action.accept(current);
                    current = advance.apply(current);
                    return true;
                }
                return false;
            }
        };
        return StreamSupport.stream(sp, false);
    }
}

Обновление 2:

Для одноразовой, эффективной реализации минимального кода, которая преобразует цепочку объектов Throwable в поток Stream<Throwable> и сразу же использует указанный поток:

Stream.Builder<Throwable> builder = Stream.builder();
for(Throwable t = a; t != null; t = t.getCause())
    builder.accept(t);
builder.build().forEach(System.out::println);

Это имеет недостаток, заключающийся в том, что он не является ленивым (перемещая всю цепочку во время построения потока), но избегает неэффективности рекурсии и Stream.concat().

Ответ 4

У меня есть еще один вариант с помощью Spliterator:

static Stream<Throwable> process(Throwable t) {

    Spliterator<Throwable> sp = new AbstractSpliterator<Throwable>(100L, Spliterator.ORDERED) {

        Throwable inner = t;

        @Override
        public boolean tryAdvance(Consumer<? super Throwable> action) {
            if (inner != null) {
                action.accept(inner);
                inner = inner.getCause();
                return true;
            }

            return false;
        }
    };

    return StreamSupport.stream(sp, false);
}

Ответ 5

Если вы правильно поняли, вы можете создать Stream с семенем root (ваша голова Throwable в связанном списке). Поскольку UnaryOperator take - следующий Throwable. Пример:

Stream.iterate(root, Throwable::getNext)
         .takeWhile(node -> node != null)
         .forEach(node -> System.out.println(node.getCause()));

Ответ 6

Что именно не так с этим?

while (exception) {
    System.out.println(exception); //or whatever you want to do
    exception = exception.getCause();
}

Нет смысла быть "более функциональным". Функциональный стиль - это просто инструмент, и он явно неуместен здесь.