List list = new ArrayList(); Stream<Object> stream = list.stream(); // маппинг так для примера List<String> collect = stream.map(obj -> obj.toString()) .collect(toList());

What have I missed in generics? This design is valid, but removing the generic from Stream stream = list.stream(); not valid?

Or so, why is this casting? (List<Object>) list

 List<String> collect = ((List<Object>) list).stream.map(obj -> obj.toString()) .collect(toList());

    2 answers 2

    The answer is given here , but since this is StackOverflow in Russian, I will provide a translation:

    stream() , map() , collect() and all other stream methods are tied to generics. If you omit their use, all associated generics in the libraries will also be omitted and all structures will turn into regular interfaces without specifying the type. For example, if you use List<String> , then by calling the stream() method, get Stream<String> .

    However, if you call stream() on an object of type List without specifying a type, then a Stream object will be returned.

    The map() method in the same case has the following declaration:

     <R> Stream<R> map(Function<? super T,? extends R> mapper)

    But if we take into account the fact that the type was not specified, it will be reduced to the form:

     Stream map(Function mapper)

    Thus, as a result, map() will return a Stream object. This will also prevent the collect() function from working properly, which is of the form

     <R> R collect(Supplier<R> supplier, BiConsumer<R,? super T> accumulator, BiConsumer<R,R> combiner)

    Turn into:

      Object collect(Supplier supplier, BiConsumer accumulator, BiConsumer combiner)

    This will lose the List and List<String> declaration, respectively. Which causes a compilation error.

    As a result, you can bring this object to the required form, however, this type of cast will cause a warning unchecked casts , because the compiler does not know whether you have led the type correctly.

      If you use the raw type Stream stream , then the generics disappear in all Stream methods, and the collect method in particular starts to return just Object . If you wish, of course, you can bring the result of the execution of the method collect to List<String> :

       List<String> collect = (List<String>)stream.map(obj -> obj.toString()) .collect(Collectors.toList());

      Similarly, with a list being cast to a List<Object> : either the resulting Stream will be parametrized, or it will be the raw type with the same problem.