Instanz von im Stream prüfen

Ich habe folgenden Ausdruck:

scheduleIntervalContainers.stream()
        .filter(sic -> ((ScheduleIntervalContainer) sic).getStartTime() != ((ScheduleIntervalContainer)sic).getEndTime())
        .collect(Collectors.toList());

…wo scheduleIntervalContainers Elementtyp hat ScheduleContainer:

final List<ScheduleContainer> scheduleIntervalContainers

Ist es möglich, den Typ vor dem Filter zu überprüfen?

Sie können eine andere anwenden filter um nur die zu behalten ScheduleIntervalContainer Instanzen und Hinzufügen von a map erspart Ihnen die späteren Besetzungen :

scheduleIntervalContainers.stream()
    .filter(sc -> sc instanceof ScheduleIntervalContainer)
    .map (sc -> (ScheduleIntervalContainer) sc)
    .filter(sic -> sic.getStartTime() != sic.getEndTime())
    .collect(Collectors.toList());

Oder, wie Holger kommentierte, Sie können die Lambda-Ausdrücke durch Methodenreferenzen ersetzen, wenn Sie diesen Stil bevorzugen:

scheduleIntervalContainers.stream()
    .filter(ScheduleIntervalContainer.class::isInstance)
    .map (ScheduleIntervalContainer.class::cast)
    .filter(sic -> sic.getStartTime() != sic.getEndTime())
    .collect(Collectors.toList());

Eine ziemlich elegante Option ist die Verwendung der Methodenreferenz der Klasse:

scheduleIntervalContainers
  .stream()
  .filter( ScheduleIntervalContainer.class::isInstance )
  .map( ScheduleIntervalContainer.class::cast )
  .filter( sic -> sic.getStartTime() != sic.getEndTime())
  .collect(Collectors.toList() );

Es gibt ein kleines Problem mit der @Eran-Lösung – das Eingeben des Klassennamens in beiden filter und map ist fehleranfällig – es kann leicht vergessen werden, den Namen der Klasse an beiden Stellen zu ändern. Eine verbesserte Lösung wäre etwa so:

private static <T, R> Function<T, Stream<R>> select(Class<R> clazz) {
    return e -> clazz.isInstance(e) ? Stream.of(clazz.cast(e)) : null;
}

scheduleIntervalContainers
  .stream()
  .flatMap(select(ScheduleIntervalContainer.class))
  .filter( sic -> sic.getStartTime() != sic.getEndTime())
  .collect(Collectors.toList());   

Es kann jedoch zu Leistungseinbußen beim Erstellen einer Stream für jedes passende Element. Seien Sie vorsichtig, wenn Sie es bei großen Datensätzen verwenden. Ich habe diese Lösung von @Tagir Vailev gelernt

Anstelle eines Filters + einer Karte, wie andere Antworten vorschlagen, würde ich diese Hilfsmethode empfehlen:

public static <Super, Sub extends Super> Function<Super, Stream<Sub>> filterType(Class<Sub> clz) {
  return obj -> clz.isInstance(obj) ? Stream.of(clz.cast(obj)) : Stream.empty();
}

Verwenden Sie es als:

Stream.of(dog, cat fish)
  .flatMap(filterType(Dog.class));

Im Vergleich zu filter + map hat es folgende Vorteile:

• Wenn die Klasse Ihre Klasse nicht erweitert, erhalten Sie einen Kompilierungsfehler
• An einem einzigen Ort können Sie nie vergessen, eine Klasse in einem Filter oder einer Karte zu ändern