流API map（）和filter（）

Question

I am trying to learn the Stream API and i came across the below code:

public class Test{
    public static void main (String[] args)
    {    
        List <Integer> a = Arrays.asList(2,3,4);
        System.out.println(a.stream().filter(i -> i < 10).average());
    }
}

It gives a

symbol "average()"not found error.

But when I change the sysout with the below it runs fine as expected

System.out.println(a.stream().filter(i -> i < 10).mapToInt(i -> i).average());

Can someone please explain the difference here?

Answer 1

A Stream<T> has no average() method, since the element type T can be any reference type, which doesn't necessarily have a meaning for calculation of the average of the Stream elements.

On the other hand, an IntStream has an average() method, since it has int elements, for which the average operation is well defined.

Therefore you must convert a Stream<Integer> to an IntStream (via mapToInt() ) in order to call average() .

Answer 2

To explain it a bit more in detail:

This is giving you a List of Integer (the arguments are boxed from int to Integer ):

List <Integer> a = Arrays.asList(2,3,4);

The following statement is converting your List<Integer> into a Stream<Integer>

a.stream()

Now filtering still preserves the type Stream<Integer> , and Stream doesn't provide a method called average() (as it can consist of any generic type).

Calling mapToInt(i -> i) converts your Stream<Integer> into an IntStream , which does have a method called average() . Note that i -> i is a ToIntFunction<Integer> , which converts an Integer back to an int due to auto-unboxing.

Another way to fix that would be

System.out.println(IntStream.of(2,3,4).filter(i -> i < 10).average());

Answer 3

Expressing calculations as chains is convenient, but sometimes it hides type information that might be useful to understanding what's going on. Try rewriting

List <Integer> a = Arrays.asList(2,3,4);
System.out.println(a.stream().filter(i -> i < 10).average());

where every result has an explicit type (your IDE should help you.) Then you get:

List <Integer> a = Arrays.asList(2,3,4);
Stream<Integer> s1 = a.stream();
Stream<Integer> s2 = s1.filter((Integer i) -> i < 10);
double average = s2.average();

When you write it this way, you'll see that you're trying to invoke a nonexistent method on Stream<Integer> . You want an IntStream , which does have an average() method. So you can rewrite as:

List<Integer> a = Arrays.asList(2,3,4);
Stream<Integer> s1 = a.stream();
IntStream s2 = s1.mapToInt((Integer i) -> i);
IntStream s3 = s2.filter((Integer i) -> i < 10);
double average = s3.average();

and everything is good. Then you can roll it back up with chaining and implicit lambdas:

double average = a.stream()
                  .mapToInt(i -> i)
                  .filter(i -> i<10)
                  .average();

The lesson here is: when you're confused, unroll complex expressions into simpler ones with manifest types. Often, this helps you spot the problem immediately; if not, it generally results in a more informative compiler error.

(If you use IntelliJ, you can use the "extract variable" refactor to pull a subexpression into a local variable with its inferred type.)

Answer 4

Arrays.asList(2,3,4).stream() would given you Stream<Integer> which is of type Stream and it does not have any average() method, hence the error.

Arrays.asList(2,3,4).mapToInt() would return IntStream which is one of the four primitive specialized classes provided by Stream API and it has average() method, hence it works.