Java 8 ogólnych kolekcji z opcjami

Question

Mam stosunkowo prosty problem, który próbuję rozwiązać. Wydaje się, że nie ma intuicyjnego sposobu, aby to zrobić, lub czegoś tu brakuje.

Rozważmy tę metodę w celu znalezienia główny obraz i jeśli żaden nie istnieje, zwraca pierwszy Obraz-

public Image findMainImage(Collection<? extends Image> images) { 
    if (images == null || images.isEmpty()) return null 
    return images.stream() 
       .filter(Image::isMain) 
       .findFirst() 
       .orElse(images.iterator().next()) 
} 

pojawia się błąd - orElse(capture<? extends Image>) in Optional cannot be applied

dowolnym kierunku na to byłoby świetnie.

Answer 1

Jednym ze sposobów, aby to naprawić jest użycie parametr typu:

public <I extends Image> I findMainImage(Collection<I> images) { 
    if (images == null || images.isEmpty()) return null; 
    return images.stream() 
       .filter(Image::isMain) 
       .findFirst() 
       .orElse(images.iterator().next()); 
} 

Bo wtedy (kompilator) Optional pewno ma ten sam typ argumentu jako images.

I moglibyśmy użyć jej jako capturing helper jeśli chcieliśmy:

public Image findMainImage(Collection<? extends Image> images) { 
    return findMainImageHelper(images); 
} 

private <I extends Image> I findMainImageHelper(Collection<I> images) { 
    // ... 
} 

Osobiście, chciałbym po prostu użyć wersji rodzajowy, bo wtedy można zrobić np:

List<ImageSub> list = ...; 
ImageSub main = findMainImage(list); 

---

Zasadniczo ... powodem, dla którego nie kompiluje się oryginalnie, jest powstrzymanie cię przed zrobieniem czegoś takiego:

public Image findMainImage(
    Collection<? extends Image> images1, 
    Collection<? extends Image> images2 
) { 
    return images1.stream() 
        .filter(Image::isMain) 
        .findFirst() 
        .orElse(images2.iterator().next()); 
}

I w oryginalnym przykładzie kompilator nie musi określać faktu, że zarówno Stream, jak i Iterator pochodzą z tego samego obiektu. Dwa oddzielne wyrażenia odwołujące się do tego samego obiektu zostają przechwycone do dwóch oddzielnych typów.

Answer 2

Załóżmy, że masz List<? extends Number>. Nie można dodać dowolnej liczby do tej listy, ponieważ może to być List<Integer>, a liczba, którą próbujesz dodać, może wynosić Float.

Z tego samego powodu metoda orElse(T t) z Optional<T> wymaga T. Ponieważ dany Optional to Optional<? extends Image>, kompilator nie może być pewien, że images.iterator().next() jest właściwego typu.

mam to skompilować poprzez umieszczenie w .map(t -> (Image) t):

return images.stream() 
      .filter(Image::isMain) 
      .findFirst() 
      .map(t -> (Image) t) 
      .orElse(images.iterator().next()); 

W rzeczywistości, z jakiegoś powodu nie mogę zrozumieć, że działa nawet bez obsady. Wydaje się, że to działa.