Using Java Predicate and Lambda

Question

Why does the below code return Predicate<String> and not boolean?

My understanding is that the !s.isEmpty() check here is going against the Predicate boolean test(T t); The return type here is boolean.

So in my lambda should my nonEmptyStringPredicate not be of type boolean? Obviously, it's not, I'm just trying to understand why it's not.

Predicate<String> nonEmptyStringPredicate = (String s) -> !s.isEmpty();

It seems you are confusing what lambdas *does/returns*, with what type of functional interface it *implements* (as instance of what type it can be used). — Pshemo, Dec 05 '18 at 13:53

score 11 · Accepted Answer · edited Dec 05 '18 at 13:41

11

A Predicate gets in this case a String as parameter and returns a boolean. In case we don't write it as lambda it would look like this:

Predicate<String> somePredicate = new Predicate<String>() {
    @Override
    public boolean test(String string) {
        return !string.isEmpty();
    }
};

edited Dec 05 '18 at 13:41

Oleksandr Pyrohov

14,685
6
61
90

answered Dec 05 '18 at 13:12

CodeMatrix

2,124
1
18
30

Thanks! - So if I am to use a Predicate it will always return with Predicate of what I pass in, in this case String. – Taobitz Dec 05 '18 at 13:34
You're welcome. If you need more information about lambdas check [this](https://dzone.com/articles/functional-interface-and-lambda-expression). Btw, you shouldn't forget to accept an answer to show others the problem is solved. – CodeMatrix Dec 05 '18 at 14:14

score 6 · Answer 2 · answered Dec 05 '18 at 13:11

If you really are willing to get a boolean though from the Predicate, you can use its test method:

Predicate<String> nonEmptyStringPredicate = s -> !s.isEmpty();
boolean val = nonEmptyStringPredicate.test("any"); // true

Predicate on the other hand is just a FunctionalInterface, that you've represented using a lambda expression.

score 4 · Answer 3 · edited Jan 28 '20 at 19:51

4

Lambda is like an anonymous class, so this:

Predicate<String> nonEmptyStringPredicate = (String s) -> !s.isEmpty();

Is like:

Predicate<String> nonEmptyStringPredicate = new Predicate<String>() {
    public boolean test(String s) {
        return !s.isEmpty();
    }
}

edited Jan 28 '20 at 19:51

Dave Jarvis

30,436
41
178
315

answered Dec 05 '18 at 13:13

M314

925
3
13
37

1

Lambdas and AIC are *similar* but not the same. They have some slight differences (i.e. what `this` means) and they are implemented in a total different way. – fps Dec 05 '18 at 14:27
You are right, but I do think It is a good way to visualize lambdas or explain to one how should he use them. – M314 Dec 05 '18 at 14:34

Ousmane D. · Answer 4 · 2018-12-05T13:56:44.137

Why does the below code return Predicate and not boolean?

This is because the type of the function (String s) -> !s.isEmpty() is a Predicate<String>, at this point you're simply defining a function (which says "given a String as input return a boolean value indication whether it's empty or not).

Note that at this point you're not evaluating anything hence the result is not a boolean but rather a function.

Definition of FI from the doc:

Functional interfaces provide target types for lambda expressions and method references. Each functional interface has a single abstract method, called the functional method for that functional interface, to which the lambda expression's parameter and return types are matched or adapted. Functional interfaces can provide a target type in multiple contexts, such as assignment context, method invocation, or cast context:

in order to get the "boolean result" you're seeking, you must first invoke the "functional method". example:

Predicate<String> nonEmptyStringPredicate = s -> !s.isEmpty();
boolean result = nonEmptyStringPredicate.test("");

score 0 · Answer 5 · answered Dec 05 '18 at 13:11

0

A predicate always returns a boolean so the only interesting value here is the input parameter which is a String.

See: https://docs.oracle.com/javase/8/docs/api/java/util/function/Predicate.html

answered Dec 05 '18 at 13:11

comrad

105
7

score 0 · Answer 6 · answered Aug 12 '21 at 06:54

It returns a predicate because on the left hand side you declared predicate as return type, and on the right side you are returning the implementation of Predicate's test() method. When your code returns an object which is the inplementation of a functional interface (like in your case) you simply return the logic of its single abstract method, in this case test() So basically is as ifyou are returning this: Predicate<String> nonEmptyStringPredicate = new Predicate { @Override boolean test(String input) { return input.isEmpty() } } When you write the code as you wrote it, the compiler 'knows' that !s.isEmpty() is the logic of method test, it basically tells you "hey give me just the logic, i dont need the boilerplate code" Btw is good practice to use method reference, you can replace !s.isEmpty() with !String::isEmpty

Using Java Predicate and Lambda

6 Answers6

Linked