**Short Interview Answer** Some commonly used functional interfaces from the `java.util.function` package include: - `Predicate` - `Function` - `Consumer` - `Supplier` - `BiFunction` **Detailed Explanation** In Java, functional interfaces are interfaces that have a single abstract method, allowing them to be used as the assignment target for a lambda expression or method reference. The `java.util.function` package provides several built-in functional interfaces that are widely used in functional programming, particularly with streams and lambda expressions. 1. **Predicate**: Represents a boolean-valued function of one argument. It is often used for filtering collections. 2. **Function**: Represents a function that takes an argument of type T and produces a result of type R. It is commonly used for transforming data. 3. **Consumer**: Represents an operation that accepts a single input argument and returns no result. It is used for operations that perform actions on objects. 4. **Supplier**: Represents a supplier of results, providing a method that returns a value without taking any input. It is used for generating values on demand. 5. **BiFunction**: Represents a function that takes two arguments and produces a result. It is useful when you need to combine two inputs to produce an output. **Internal Working** Functional interfaces are designed to be implemented by lambda expressions or method references, allowing for cleaner and more concise code. When you use these interfaces, the Java compiler can infer the types of the parameters and return values, making it easier to work with functional programming concepts. For example, when using streams, you can pass these functional interfaces as parameters to methods like `filter()`, `map()`, and `forEach()`, enabling a declarative style of programming. **Real Project Example** In a project where we process user data, we might use: - `Predicate` to filter users based on their age - `Function` to transform user objects into DTOs - `Consumer` to log user information - `Supplier` to generate default user values - `BiFunction` to combine user data with additional attributes from another source **Common Follow-up Questions** - Can you explain how to create a custom functional interface? - What are the differences between `Function` and `BiFunction`? - How do you handle exceptions in functional interfaces? **Code Example** ```java Predicate isNotEmpty = str -> !str.isEmpty(); Function intToString = num -> String.valueOf(num); Consumer printConsumer = str -> System.out.println(str); Supplier randomSupplier = () -> Math.random(); BiFunction add = (a, b) -> a + b; ``` **Interview Tips** Be prepared to explain how these functional interfaces can be used in practical scenarios, especially with Java Streams. Understanding their use cases will demonstrate your familiarity with functional programming in Java.

Java 8