All 15 Functional Interfaces & Method References questions
More in Functional Interfaces & Method References
What are the four kinds of method references in Java (static, instance-bound, instance-unbound, and constructor), and how does the compiler determine which form applies? How do the default methods andThen() and compose() on Function work, and what's the difference between them for chaining transformations? What is the difference between UnaryOperator<T> and Function<T,T>, and why does UnaryOperator exist as a separate, more specific interface? How do the primitive-specialized functional interfaces (IntFunction, ToIntFunction, IntPredicate, IntUnaryOperator, etc.) avoid the performance cost of autoboxing, and when should you prefer them over the generic equivalents? What is the difference between a Consumer<T> and a BiConsumer<T,U>, and how would you use BiConsumer for operations needing two inputs but no return value, such as Map.forEach()? How would you convert a checked-exception-throwing method into a lambda usable with a standard functional interface (which doesn't declare any checked exceptions), given standard interfaces like Function don't permit checked exceptions in their abstract method signature? How does a lambda expression capture variables from its enclosing scope, and why must captured local variables be effectively final? How would you implement a custom functional interface with generic type parameters, and what considerations apply when designing one instead of reusing a built-in java.util.function interface? How would you implement memoization (caching function results) as a higher-order function wrapping an existing Function, and what thread-safety considerations apply for a memoized function used concurrently? How would you use BiFunction combined with Stream's reduce() to implement a custom aggregation, and how does this relate to the more general concept of a fold operation in functional programming?
Advertisement
Java › Functional Interfaces & Method References

How does the Predicate interface's default methods and(), or(), and negate() enable composing complex boolean conditions from simpler ones?

Intermediate

Answer

and(other) creates a composed predicate that's true only if both the original and the other predicate are true (with short-circuit evaluation, matching && semantics); or(other) is true if either is true (short-circuiting like ||); negate() inverts the predicate's result -- these default methods let you build complex, readable filtering conditions by composing small, well-named predicates together rather than writing one large, harder-to-read boolean expression inline.
Predicate<String> isLongEnough = s -> s.length() >= 8;
Predicate<String> hasDigit = s -> s.chars().anyMatch(Character::isDigit);
Predicate<String> hasUpperCase = s -> s.chars().anyMatch(Character::isUpperCase);

Predicate<String> isStrongPassword = isLongEnough.and(hasDigit).and(hasUpperCase);
System.out.println(isStrongPassword.test("Password1"));  // true
Real-world example A password validation system composes several small, individually-named predicates (isLongEnough, hasDigit, hasUpperCase, hasSpecialChar) into one final isStrongPassword predicate using and(), making the overall validation logic self-documenting and each individual rule independently testable, rather than one large inline boolean expression.

Common follow-ups: How does short-circuit evaluation in and()/or() affect performance when the predicates involve expensive checks?;How would you build a list of predicates and combine them all with and() dynamically at runtime?

Streams & Lambdas;Testing Strategy
All 15 Functional Interfaces & Method References questions