Java 8和流上的聚合操作

Question

When we use methods like filter , mapToInt , sum , etc. and pass them lambda expressions I don't understand if the operations are method themselves or are the lambda that we pass.

I' d like to know the correct terminology.

I think that the lambda is the function and thus the operation that we pass to methods that use that to produce a results.

Why is also said that filter , sum , etc. are operations that use function as their arguments?

Are both correct terminology?

Answer 1

Both the Stream methods and the lambda arguments that they accept are, broadly speaking, operations. This isn't confusing once we get used to the idea that the arguments to method calls can be functions. A Stream method applies the function that it's been given to the values in its stream, either to produce a new stream (intermediate methods) or to produce some aggregated result (terminal methods).

For a more detailed explanation, see http://www.lambdafaq.org/why-are-lambda-expressions-being-added-to-java/

Answer 2

Not sure if this is commonly accepted, but I think it is thus:

A function is something that receives arguments and produces a value, ideally without side effects (though, that is not enforcable in Java). Use this if you want to emphasize the mathematical/functional aspect.

A subroutine/procedure is a named piece of code that is reused for it's side effect.

A method is how functions and subroutines are implemented/written in Java. There is no such thing as a function or procedure that does not belong to some class.

A lambda expression in Java is a way to write methods (of some anonymous class that happens to implement a functional interface) on the fly and at the same time obtain a reference to an instance of said interface.

An operation is a function or procedure.

So, depending on how you want to look at it: Since it is about Java, you could just call everything "method". But sometimes you want to emphasize different aspects. Like in your example:

filter, sum, etc. are operations that use function as their arguments

Here, we could say: " filter is a method that takes a reference to a functional interface as argument", but this somehow changes the intention of the sentence.

Answer 3

Lambda is a function/callback which is usually passed as an argument. An approach to understand this, consider you need to search for a value in a list:

Java 7:

int i = Arrays.asList(1,2,3,4,5,6).indexOf(3);

This will give a single element. Now what happens, when one needs a more dynamic request - he could collect these items with a for-loop. But if he wants to do it in a similar fashion, he could pass a lambda as an argument:

Java 8 (how it could be):

List<Integer> collect = asList(1, 2, 3, 4, 5, 6).filter(x -> x >= 2 && x < 4);

the real Java 8 API example is a bit more verbose:

List<Integer> collect = Arrays.asList(1, 2, 3, 4, 5, 6)
    .stream()
    .filter(x -> x >= 2 && x < 4)          
    .collect(Collectors.toList());

Answer 4

Remember, what we pass to the filter is as a function is just a filtering logic. While the filter function already expect a function that has the filtering logic. Filter function specifically accepts a function that returns boolean and decides whether to pass on the currently element in the stream or simply discard it.

I hope I have understood your question correctly. For more on streams here is a ongoing series of article on Java 8 Stream API amitph.com > Java 8 Streams API Tutorials