Using Streams with primitives data types and corresponding wrappers

Question

While playing around with Java8's Streams-API, I stumbled over the following:

To convert an array of primitive wrapper classe objects into a Stream I just have to call Stream.of(array). But to convert an array of primitive data types, I have to call .of(array) from the corresponding wrapper (class) stream class (<-- that sounds silly).

An example:

final Integer[] integers = {1, 2, 3};
final int[]     ints     = {1, 2, 3};


Stream.of(integers).forEach(System.out::println); //That works just fine

Stream.of(ints).forEach(System.out::println);     //That doesn't

IntStream.of(ints).forEach(System.out::println);  //Have to use IntStream instead

My question(s): Why is this? Does this correlate to e.g. the behaviour of Arrays.asList() which also just works for wrapper class arrays?

Rumal

Isn't it normal to use IntStream methods to deal with IntStreams, and Stream methods to deal with Streams? – Oniskey

You can also use Arrays.stream(ints).forEach(System.out::println). – Humperdinck

Related to (but not a direct duplicate of) https://mcmap.net/q/588738/-why-are-there-primitive-functions-like-doublefunction-in-java-8/2886891 – Twitch

Answer 1

Java 8 stream framework has a generic Stream<T> for objects as elements, and three primitive streams IntStream, LongStream, DoubleStream for the main three primitives. If you work with primitives, use one of those latter, in your case IntStream.

See the picture:

What lies behind is that:

1. Java generics cannot work with primitive types: it is possible to have only List<Integer> and Stream<Integer>, but not List<int> and Stream<int>

2. When the Java Collections framework was introduced, it was introduced only for classes, so if you want to have a List of ints, you have to wrap them (each single element!) to Integers. This is costly!

3. When the Java Streams framework was introduced, they decided to get around this overhead and in parallel with the "class-oriented" streams (using the generics mechanism), they introduced three extra sets of all the library functions, specifically designed for the most important primitive types: int, long, double.

BTW, they did the same with the predefined functional interfaces in the java.util.function package, so you have Predicate, IntPredicate, DoublePredicate, and LongPredicate.

And see also a marvelous explanation here: https://mcmap.net/q/324189/-why-are-new-java-util-arrays-methods-in-java-8-not-overloaded-for-all-the-primitive-types

Twitch