Esta pregunta ya tiene una respuesta aquí:

oco a poco estoy aprendiendo las nuevas características de Java 8 y estoy tratando de encontrar una manera de procesar una jerarquía de clases (de niño a padre) como una secuencia.

Por ejemplo, encuentre una anotación en una clase o en sus padres.

Antes de Java 8, lo habría hecho de esta manera:

public static <T extends Annotation> T getAnnonationOn(Class<?> type, Class<T> annType) {
    Class<?> t = type;
    T annot = null;
    while (t != null && annot == null) {
        annot = t.getAnnotation(annType);
        t = t.getSuperclass();
    }
    return annot;
}

Ahora deseo hacerlo con una forma más "funcional de programación". No pude encontrar una mejor manera que concatenar secuencias con un recursivo como el siguiente:

import java.lang.annotation.Annotation;
import java.util.stream.Stream;

public static <T extends Annotation> T getAnnonationOn(Class<?> type, Class<T> annType) {
    return ClassIterator.streamSuperclass(type)
        .map(t -> t.getAnnotation(annType))
        .filter(a -> a != null)
        .findFirst()
        .orElse(null);
}

public static class ClassIterator {
    public static Stream<Class<?>> streamSuperclass(Class<?> type) {
        if (type.getSuperclass() != null) {
            return Stream.concat(Stream.of(type), Stream.of(type.getSuperclass()).flatMap(ClassIterator::streamSuperclass));
        }
        return Stream.of(type);
    }
}

Pero no estoy muy satisfecho con la solución. Aunque no lo comparé, creo que la concatenación de flujo es bastante engorrosa y de bajo rendimiento.

Existe una mejor manera de convertir un recursivo en una transmisión?