Why are these Java 8 lambdas behaving differently during type conversions?

Question

Stream st = Stream.of(1,2,3,4);

Does this create a stream of Integers (By inferring at runtime) or a Stream of Objects?

st.collect(Collectors.averagingInt((Integer x)->x));

This line compiles fine.

st.forEach((Integer x)-> System.out.println(x));

This line does not compile. It gives a compilation error at (Integer x), saying expected object but found Integer. Why?

Why does it not complain the same for the averagingInt method above?

averagingInt takes the ToIntFunction interface with raw reference type as <? super T> and allowing Integer value. While forEach is taking the Consumer interface with the same raw reference type as <? super T> and the compiler is complaining for the Integer argument value.

Answer 1

Does this create stream of Integers (By inferring at runtime) or Stream of Objects ?

Generics do not exist at runtime, there is nothing to "infer" at runtime. Since you have used a raw type for the Stream st - it is a Stream<Object> if you want.

Well, even what you wrote for (and does compile):

st.collect(Collectors.averagingInt((Integer x)->x));

would not compile when you try to add the expected result:

Double i = st.collect(Collectors.averagingInt((Integer x) -> x));

I wonder if you re-write like below would make more sense:

Collector<Integer, ?, Double> collector = Collectors.averagingInt((Integer x) -> x);
Double result = st.collect(collector); // does not compile

Inference would work for Collectors.averagingInt, but since you have used Stream as raw - everything else is raw too.

Answer 2

As was told above you are trying to use raw Stream. If you want to iterate across Integer then you need to specify generic for Stream.

For instance

Stream<Integer> st = Stream.of(1,2,3,4);

Then it will compile.

This probalem is equuvalent to problem with iterating across generic colection in old style

Collection values = Arrays.asList(1,2,3,4);
for(Integer v: values){
    System.out.println(v);
}

The code above won't compile because values is list of objects not integers.

As for averagingInt it will compile even if you will provide a list of String. For instance

    Stream st = Stream.of("1","2","3","4");
    st.collect(Collectors.averagingInt((Integer x)->x));

However it will failed during runtime with ClassCastException. The difference here is that averagingInt tryes to cast all incoming types to specific and forEach just uses types as is what may cause compilation fail.

It is equivalent

    ToIntFunction<? super Integer> mapper = new ToIntFunction<Integer>(){
        @Override
        public int applyAsInt(Integer value) {
            return value;
        }
    };

    st.collect(Collectors.averagingInt(mapper));

The anonymous class will be used inside of averagingInt and before passing args to applyAsInt method it will be cast to appropriate type (in my sample to Integer )

Another interesting thing

Stream st = Stream.of(1,2,3,4);

Consumer<String> stringConsumer = new Consumer<String>() {
    @Override
    public void accept(String o) {

    }
};

st.forEach(stringConsumer); // will compile disregarding to raw type of Stream and specific Consumer

st.forEach((Integer  a) -> System.out.println(a)); // will fail because os raw Stream