Predicate interface.

Hook: Interviewers love this one because a tiny interface reveals whether you understand lambdas, composition, and clean filtering in Java 8.

Question: Predicate interface.

Answer: Predicate<T> is a Java 8 functional interface that represents a yes/no test for one input. Its main method is test(T t), and you use it for filtering, validation, and rule checks. It also provides and, or, and negate so you can combine conditions cleanly instead of writing nested if statements.

Interview-Ready Answer: A Predicate is a Java 8 functional interface for one-argument boolean checks. I use test() to answer questions like whether a customer is eligible, and I can combine rules with and, or, and negate. A nice detail is that it works naturally with streams for filtering, and for primitive values there are specialized versions like IntPredicate to avoid boxing.

What it is

Predicate<T> is a functional interface in java.util.function introduced in Java 8. A functional interface has exactly one abstract method, so it can be implemented with a lambda or a method reference. For Predicate, that method is boolean test(T t) — it answers a simple yes/no question about one object. It also ships with useful helpers: and, or, negate, and the static helper isEqual.

How it works under the hood

1. You write a lambda such as user -> user.getAge() >= 18.
2. The compiler checks that the lambda fits the test(T) shape: one input, boolean output.
3. At runtime the JVM uses invokedynamic and LambdaMetafactory to create the implementation. You do not write a concrete class yourself.
4. If the lambda captures outside values, those values must be final or effectively final. That means the lambda closes over a stable value, not a changing local variable.
5. When you chain predicates with and or or, Java evaluates left to right and short-circuits: the second predicate runs only when needed.

Why and when to use it

• Use it for filtering collections: stream().filter(predicate).
• Use it for validation rules: active customer, valid email, allowed amount, and so on.
• Use it when you want reusable business rules that read like English instead of nested if statements.

Predicate vs nearby interfaces

Predicate is usually the best fit when you only need yes/no. Compared with Function<T, Boolean>, it says your intent clearly and avoids wrapping the result in a boxed Boolean just to represent a condition. If you work with primitive values in hot code, prefer IntPredicate, LongPredicate, or DoublePredicate to avoid boxing overhead. If you need two inputs, Java also gives you BiPredicate<T, U>.

Performance and edge cases

One predicate test is O(1); filtering n items is O(n). Composition does not change the big-O cost, but short-circuiting can save work because the right side may never run. In a list of 1,000,000 items, that still means 1,000,000 calls to test(), so boxing or expensive logic can matter. Common edge cases are null input, forgetting that the lambda can throw its own exception, and assuming Java 8 has Predicate.not — it does not; that helper appears in Java 11, so in Java 8 you use negate(). In streams, keep predicates stateless and non-interfering, especially if the stream is parallel.

Real-World Story: In a checkout service, a team used Predicate<Order> rules to decide whether a promo code could be applied: the customer had to be active, the cart total had to pass a threshold, and the account had to pass fraud checks. During a refactor, one and was accidentally changed to or, so orders that should have failed one rule still slipped through. The result was a spike in discount abuse, support tickets from finance, and logs that showed far more orders marked eligible than normal. The lesson: with predicates, the logic is compact, so a tiny boolean mistake can create a very real business outage.

Follow-up & Tricky Questions:

• Why is Predicate a functional interface? Because it has exactly one abstract method, test(T), so a lambda can stand in for the implementation.
• How is Predicate different from Function<T, Boolean>? Predicate is the right semantic type for yes/no checks, and it also gives you built-in composition methods like and, or, and negate.
• What does and do if the first predicate is false? It short-circuits, so the second predicate is not evaluated. That matters for performance and for avoiding exceptions in the right-hand predicate.
• When should I use IntPredicate instead of Predicate<Integer>? Use IntPredicate when you are working with primitive ints in hot code or primitive streams, because it avoids boxing and unboxing overhead.
• Can a Predicate change outside state? It can, but that is usually a bad idea. Predicates are easiest to reason about when they are stateless and only return true or false based on their input.
• Is Predicate.isEqual(null) valid? Yes. It creates a predicate that matches only null values, because it uses standard equality rules under the hood.
• Can a lambda used as a Predicate throw a checked exception? Not directly. You must catch it inside the lambda or wrap it in an unchecked exception, because test() does not declare checked exceptions.
• Does Predicate.not exist in Java 8? No. In Java 8 you use negate(); Predicate.not(...) arrives later in Java 11.
• Does and always evaluate both sides? No, that is the trap. It behaves like boolean &&, so it skips the right side when the left side is already false.
• Is a Predicate always safe in parallel streams? Only if it is stateless and thread-safe. If it touches shared mutable data, parallel execution can produce races and inconsistent results.

Common Mistakes

• Using Function<T, Boolean> when you really need a predicate. Correction: use Predicate<T>; it reads better and gives you and, or, and negate.
• Forgetting null checks inside the lambda. Correction: guard with Objects::nonNull or explicit null checks before dereferencing fields.
• Assuming both sides of and or or always run. Correction: they short-circuit, so order matters for performance and safety.
• Using boxed types in tight loops. Correction: prefer primitive specializations like IntPredicate when boxing cost matters.

Memory Hook

Memory Hook: Think of a Predicate as a bouncer at one door: each person gets a simple yes/no stamp, and and, or, and negate are the bouncer's rulebook.

Cheat Sheet

• Predicate<T> = one input, boolean output.
• Main method = test(T).
• Java 8 package = java.util.function.
• Composition = and, or, negate.
• Best for filtering and validation.
• Use primitive versions to avoid boxing.

Practice Tasks

• Write a Predicate<String> that checks whether a password has at least 8 characters.
• Combine two predicates to model an account rule such as active and verified.
• Refactor a nested if block into a readable predicate chain and use it in a stream filter.