Lambda Expressions.

Hook: Interviewers love this topic because a tiny arrow can replace a whole class, but only if you know the rules behind it.

Question: What are lambda expressions in Java?

Answer: A lambda expression is a short way to write a piece of behavior, usually for a functional interface (an interface with one abstract method). Instead of creating a full anonymous class, you write the logic inline, which makes code shorter and easier to read. Lambdas are most common with sorting, filtering, callbacks, and stream operations.

Interview-Ready Answer: In Java, a lambda expression is a compact way to provide the implementation of a functional interface. I use it when I want to pass behavior, like a comparator or predicate, without writing a full anonymous class. The big idea is that Java infers the target type from context, and the lambda can capture only effectively final local variables, which helps keep the code safer and more predictable.

What a lambda really is

Detailed Explanation: A lambda is not magic syntax for a new kind of object. It is a concise way to supply the body of a single-method contract. That contract is the functional interface. Common examples are Runnable, Comparator, Predicate, and Function.

1. The compiler looks at the place where the lambda is used. This is called the target type (the expected interface or method signature).
2. It checks that the target is a functional interface, meaning it has exactly one abstract method. Default and static methods do not count against that rule.
3. The compiler infers parameter types and return type from context, so you often do not need to write them explicitly.
4. At runtime, Java links the lambda through invokedynamic and LambdaMetafactory. In simple words: the JVM creates the behavior hookup lazily instead of generating a named class in your source code.
5. If the lambda captures no outside variables, the JVM can often reuse the same instance. If it captures values, those values are stored inside the generated implementation.

When to use lambdas

Use lambdas when you need to pass a small piece of behavior and the meaning is clear from the surrounding code. They are a great fit for sort, filter, map, event handlers, and small validation rules. They are less ideal when the logic is long, has many branches, or needs a named helper method for clarity.

Lambda vs anonymous class vs method reference

Important gotchas:

• Local variables captured by a lambda must be effectively final (assigned once and not changed later).
• this inside a lambda refers to the enclosing object, not a new anonymous inner class instance.
• Checked exceptions are allowed only if the target functional interface declares them.
• Lambdas are not automatically faster than everything else; a capturing lambda may allocate, while a stateless one may be cached.

Performance and complexity: A lambda invocation is generally O(1). Creation is also typically O(1), but a capturing lambda may create an object to store captured values. In real programs, the bigger cost is usually the work done inside the lambda, like sorting, filtering, or I/O. For example, sorting with a lambda comparator is still dominated by the sort itself, which is typically O(n log n).

Version note: Lambdas arrived in Java 8. Before that, developers used anonymous classes for the same job.

Memory hook: Think of a lambda as a sticky note with one instruction on it. You hand the note to the method instead of building a whole binder called a class.

Real-World Example: Imagine a checkout service for an e-commerce site. The team stores pricing rules as lambdas: one rule checks whether an order is eligible for free shipping, another computes a discount, and another blocks suspicious orders. That makes the rules easy to add and test without creating a separate class for each tiny behavior.

What goes wrong when someone misunderstands lambdas? A developer adds side effects inside a parallelStream() lambda and writes to a shared HashMap that is not thread-safe. In production, some requests start failing with intermittent ConcurrentModificationException, audit counts become wrong, and customers see checkout delays or 500 errors. Logs show noisy, inconsistent failures instead of one clean crash, which makes the bug hard to reproduce.

The lesson is simple: lambdas are best when they describe behavior, not when they hide shared mutable state. Small, pure functions are easier to reason about and much safer in concurrent code.

Follow-up & Tricky Questions:

• What is a functional interface? It is an interface with exactly one abstract method, which makes it a valid target for a lambda. It can still have any number of default or static methods.
• How is a lambda different from an anonymous inner class? A lambda is shorter and does not create a new scope for this. An anonymous class is more verbose and can be useful when you need a concrete class-like body rather than a single behavior.
• What is target typing? The compiler uses the surrounding context to decide which functional interface the lambda should implement. That is why the same lambda shape can fit different types if the method signature matches.
• Can a lambda throw checked exceptions? Yes, but only if the functional interface method declares them. If it does not, you must catch the exception inside the lambda or use a different interface.
• What does this mean inside a lambda? It refers to the enclosing instance, not a lambda object. This is a common difference from anonymous classes and often surprises people.
• Can lambdas be serialized? Sometimes, but you should not rely on it casually. Serialization of lambdas is fragile compared with serializing explicit classes or stable data objects.
• Tricky: Can I modify a local variable captured by a lambda? No. The variable must be effectively final, so you can read it but not reassign it after capture.
• Tricky: Are lambdas always faster than anonymous classes? No. The real cost depends on capture, allocation, and the work done inside the lambda. Readability is usually the first reason to choose a lambda, not raw speed.
• Tricky: Does every lambda create a brand-new object? Not necessarily. Stateless lambdas can be cached and reused, while capturing lambdas may need an object to hold captured values.

Common Mistakes:

• Mistake: Treating a lambda like a full class. Correction: Remember that it is just a compact implementation of one abstract method.
• Mistake: Trying to reassign captured local variables. Correction: Captured locals must be effectively final.
• Mistake: Putting heavy side effects inside lambdas. Correction: Keep lambdas small and prefer pure logic; move complex work into named methods.
• Mistake: Forgetting that this points to the outer object. Correction: Use that fact intentionally; do not assume a new inner instance exists.

Memory Hook: Lambda = one sticky note, one job. If the behavior is tiny, a lambda is perfect. If you need a whole binder of state and methods, use a class.

Cheat Sheet:

• Java 8 introduced lambdas.
• They work with functional interfaces only.
• They make code shorter for callbacks, sorting, filtering, and streams.
• Captured locals must be effectively final.
• this inside a lambda means the enclosing object.
• Stateless lambdas may be reused; capturing lambdas may allocate.

Practice Tasks:

• Replace an anonymous Comparator with a lambda in a small sorting example.
• Write a lambda for Predicate<String> that filters names starting with a letter.
• Create a custom functional interface and pass a lambda that validates or transforms input, then add one failure case.