Predicate "and" default method

[Ioanna Katsanou]

Hello everyone,

I am currently studying the SYBEX OCP book by Selikoff and Boyarsky.  On page 178, the book has an explanation of how to use the default method and from the Predicate Functional Interface:

Suppose that we have these two Predicates:

Predicate<String> egg = s -> s.contains("egg");
Predicate<String> brown = s -> s.contains("brown");

Now we want a Predicate for brown eggs and another for all other colors of eggs. We
could write this by hand:

Predicate<String> brownEggs = s -> s.contains("egg") && s.contains("brown");
Predicate<String> otherEggs = s -> s.contains("egg") && ! s.contains("brown");

This works, but it’s not great. It’s a bit long to read, and it contains duplication. What if
we decide the letter e should be capitalized in eggs? We’d have to change it in three variables:
egg, brownEggs, and otherEggs.

A better way to deal with this situation is to use two of the default methods on
Predicate:

Predicate<String> brownEggs = egg.and(brown);
Predicate<String> otherEggs = egg.and(brown.negate());

Neat! Now we are reusing the logic in the original Predicates to build two new ones.

I cannot seem to understand the use of the and method here. Can anyone explain???
Thanks !!
Ioanna

[Campbell Ritchie]

Have you read the documentation for Predicate#and()? What it does is create another Predicate object which represents
egg && brown.
It would be possible to create separate Predicates for egg and Egg with the Predicate#or() method, too. Try the two operations separately before you try anything like this:-

Predicate brown = s<String> -> s.contains("brown");
Predicate<String> egg = s -> s.contains("egg");
Predicate<String> eggCap = s -> s.contains("Egg");
Predicate brownEggs = egg.or(eggCap).and(brown);

Duplicating discussion in our Java8 and OCP fora.

[Campbell Ritchie]

Beware: In classical logic you would write that as
(egg ∨ eggCap) ∧ brown
because the precedence of ∧ is higher than ∨. In the case of method calls, the dot operator has the same precedence as itelf throughout, but associates to the left, so the expresssion I showed you would be equivalent to

Predicate brownEggs = (egg.or(eggCap)).and(brown);

That happens to give the same as the classical logic expression, with or without () in the Java®, but if you have something like
egg ∨ eggCap ∧ brown
that is a different expression, possibly incorrect, which you would write as

Predicate brownEggs = egg.(or(eggCap).and(brown));

or

Predicate rottenEggs = eggCap.and(brown).or(egg);

in order to maintain the precedences. That is why I said to try simpler expressions first.