Diese Frage hat hier bereits eine Antwort:

Ich lerne langsam die neuen Java 8-Funktionen und suche nach einer Möglichkeit, eine Klassenhierarchie (von Kind zu Eltern) als Stream zu verarbeiten.

inden Sie beispielsweise eine Anmerkung zu einer Klasse oder ihren Elter

Vor Java 8 hätte ich es so gemacht:

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

Nun möchte ich es mit einer "funktionaleren" Programmierweise machen. Ich könnte keinen besseren Weg finden, als Streams mit einem rekursiven wie folgt zu verketten:

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

Aber ich bin mit der lösung nicht ganz zufrieden. Obwohl ich es nicht bewertet habe, finde ich die Stream-Verkettung ziemlich umständlich und unterperformant.

Gibt es eine bessere Möglichkeit, einen rekursiven in einen Stream umzuwandeln?