What is the difference between a Predicate and a Function Interface in Java8?

Question

I know it may be a very basic question on SO but I want to know what is the difference between a Predicate and a Function Interface in Java8?

Predicate<String> predicateTest  = (s)-> s.length() > 5;       
System.out.println(predicateTest.test("Predicate"));

Function<String, Boolean> functionTest = str -> str.length()> 5;      
System.out.println(functionTest.apply("Function"));

Here in my Example both are returning true.The only thing is way of calling is different ?

Answer 1

Although it is an old post but I will summaries differences between them for newbies

Predicate: To implement conditional checks we should go for Predicate.

Function: To perform certain operations and to return some result we should go for function

Predicate: Predicate can take one type parameter which represents input type or argument type.

Function: Function can take 2 type parameters First one represents input type argument type and second one represents return type.

Predicate: Predicate defines one abstract function called test(). When using predicate you can say "test this condition" or "Testing this condition"

Function: Function defines one abstract function called apply(). When using function you can say "apply this function" or "applying this function"

Predicate: Always return boolean value.

Function: Function can return any type of value.

Sometimes people call predicate specail case of Function. Another difference between them is that they contain different type of default and static methods in their respective interfaces.

Answer 2

From a technical point of view, a Predicate<T> is just a function taking in a T and returning a boolean primitive result. However, from a usage point of view, a Predicate<T> is totally a different concept than a Function<T, Boolean>.

We use a Predicate<T> to perform a filter operation, in a stream pipeline for example, we take a Stream<T> of size n, filter it using a Predicate<T> to get a stream of size less than or equal to n. Meanwhile, a Function<T, Boolean> in a stream pipeline is used to perform a mapping operation to transform a Stream<T> into a Stream<Boolean>.

As you can see, Predicate<T> and a Function<T, Boolean> are technically the same (ignoring the wrapper Boolean for simplicity), but when put in a specific context (stream pipelines for example), it is totally a different story as each one of them plays a distinct role.

Answer 3

Aominè's answer covers the basic differences. I would like to add that the two interfaces also have different specialized default methods, i.e. methods you can call on any implementing class:

• Predicate<T>
  • Predicate<T> and(Predicate<? super T> other) - Returns a composed predicate that represents a short-circuiting logical AND of this predicate and another.
  • Predicate<T> or(Predicate<? super T> other) - Returns a composed predicate that represents a short-circuiting logical OR of this predicate and another.
  • negate() - Returns a predicate that represents the logical negation of this predicate.
• Function<T,R>
  • <V> Function<T,V> andThen(Function<? super R,? extends V> after) - Returns a composed function that first applies this function to its input, and then applies the after function to the result.
  • <V> Function<V,R> compose(Function<? super V,? extends T> before) - Returns a composed function that first applies the before function to its input, and then applies this function to the result.

As you can see, Predicate has useful methods for creating complex conditions, much like the operators you would use in a regular if statement, whereas Function has methods that support simple chaining.

Answer 4

Difference between Predicate<T> and Function<T, R>

First and foremost a Predicate<T> is strictly a boolean-valued function:

         _ _ _ _ _ _ _ 
        |             |
  T --> |  predicate  | --> boolean
        |_ _ _ _ _ _ _|   

Whereas this is not necessarily true for a Function<T, R>:

         _ _ _ _ _ _ _ 
        |             |
  T --> |   function  | --> R
        |_ _ _ _ _ _ _| 

The latter consumes any type of object just as Predicate<T> enables but can vary in the return type.

Use case of Predicate<T> and Function<T, R>

The use case for Predicate<T> is when you require a function that consumes one argument of type T and returns a boolean. e.g. that may be in a situation where you want to filter a stream of elements, find the first element from a stream that satisfies a condition as such of .filter(predicate).findFirst(), or checking the presence of an element from a stream that satisfies a certain condition as such of anyMatch, noneMatch, allMatch etc.

The use case for Function<T, R> is when you require a function that consumes one argument of type T and transforms that into a type R e.g. that may be when calling stream.map(func).

Explanation of your code snippet:

In regards to the example snippet in your post Predicate<String> and Function<String, Boolean> are the same thing in terms of what they represent i.e. they both represent a function taking a String and returning a boolean. However, the former avoids boxing the returned value from boolean to Boolean whereas the latter does not.

That said, this does not necessarily mean wherever you can use a Predicate<String> you can also use a Function<String, Boolean> or vice versa.

Example:

While this compiles:

Predicate<String> predicate = p -> p.length() == 21;
Stream<String> stream = stringList().stream().filter(predicate);

This does not:

Function<String, Boolean> function = p -> p.length() == 21;
Stream<String> stream = stringList().stream().filter(function);

and vice versa:

While this works:

Function<String, Boolean> function = p -> p.length() == 21;
Stream<Boolean> stream = stringList().stream().map(function);

This does not:

Predicate<String> predicate = p -> p.length() == 21;
Stream<Boolean> stream = stringList().stream().map(predicate);

Answer 5

A Predicate can only return a boolean (result of the test()) while Function does a transformation and can return anything (result of apply()).

A Predicate is used to test a condition.

A Function is used to do a transformation.

Answer 6

There's really no difference.

In theory, there shouldn't be any functional difference between Predicate<T> and Function<T, Boolean>. A Predicate is just a function that takes an object of some type and returns a boolean. A Function is a generalization which can return any type, not just Boolean's.

There may be implementation details within Java itself that make them distinct, but they should be the same in theory.

An example would be if an interface could only accept a Predicate<String>, not a Function<String, Boolean.

Answer 7

in this case there is no difference, it matters only to the things you can apply to. So for example allMatch expects a Predicate, you can't pass a Function, even if logically they do the same thing.