Overview

In Java 8, functional interfaces such as Supplier, Consumer, Function, and Predicate play a pivotal role in enabling functional programming features. These interfaces support lambda expressions and method references, making it easier to write more concise and readable code. Understanding the differences and use cases of these interfaces is crucial for leveraging Java 8's capabilities effectively.

Key Concepts

1. Functional Interfaces: An interface with exactly one abstract method, enabling lambda expressions.
2. Lambda Expressions: A concise way to represent an anonymous method that can be passed as an argument.
3. Method References: A shorthand notation for a lambda expression to call a method.

Common Interview Questions

Basic Level

1. What is a functional interface in Java 8?
2. How do you use a Predicate functional interface?

Intermediate Level

3. How can Function and Predicate interfaces be used together in a program?

Advanced Level

4. Compare and contrast the use of a Supplier with a Consumer in a complex data processing application.

Detailed Answers

1. What is a functional interface in Java 8?

Answer: A functional interface in Java 8 is an interface with exactly one abstract method. It may contain default and static methods but only one abstract method. Functional interfaces are intended to be used as the assignment target for lambda expressions and method references.

Key Points:
- Functional interfaces enable lambda expressions in Java.
- They can contain only one abstract method but multiple default or static methods.
- Examples include Runnable, Callable, Comparator, etc.

Example:

@FunctionalInterface // It's a good practice to use @FunctionalInterface annotation
public interface SimpleFunctionalInterface {
    void execute();
}

public class Test {
    public static void main(String[] args) {
        SimpleFunctionalInterface sfi = () -> System.out.println("Hello World");
        sfi.execute();
    }
}

2. How do you use a Predicate functional interface?

Answer: The Predicate<T> interface is a functional interface that represents a boolean-valued function of one argument. It is primarily used for filtering or matching objects.

Key Points:
- Predicate<T> takes one argument and returns a boolean.
- Commonly used in filtering data from collections.
- Can be combined with other predicates using methods like and(), or(), and negate().

Example:

import java.util.function.Predicate;

public class PredicateExample {
    public static void main(String[] args) {
        Predicate<Integer> isEven = x -> x % 2 == 0;

        System.out.println(isEven.test(4)); // true
        System.out.println(isEven.test(5)); // false
    }
}

3. How can Function and Predicate interfaces be used together in a program?

Answer: The Function<T,R> and Predicate<T> interfaces can be used together to perform a sequence of operations where you first apply a function to your data to transform it and then use a predicate to filter the transformed data based on a condition.

Key Points:
- Function<T,R> takes an argument of type T and returns a result of type R.
- Predicate<T> is used to evaluate a condition on the transformed result.
- This combination is useful for data processing tasks.

Example:

import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;
import java.util.function.Predicate;

public class FunctionPredicateExample {
    public static void main(String[] args) {
        List<String> names = List.of("Alice", "Bob", "Charlie");
        Function<String, Integer> nameLength = String::length;
        Predicate<Integer> isEven = length -> length % 2 == 0;

        filterAndTransform(names, nameLength, isEven).forEach(System.out::println); // Output: 3 (Bob)
    }

    static <T, R> List<R> filterAndTransform(List<T> list, Function<T, R> function, Predicate<R> predicate) {
        List<R> result = new ArrayList<>();
        for (T item : list) {
            R transformed = function.apply(item);
            if (predicate.test(transformed)) {
                result.add(transformed);
            }
        }
        return result;
    }
}

4. Compare and contrast the use of a Supplier with a Consumer in a complex data processing application.

Answer: In a complex data processing application, Supplier<T> and Consumer<T> interfaces serve different purposes. The Supplier<T> interface provides new objects, acting as a factory, while the Consumer<T> interface consumes objects, performing operations on them without returning any result.

Key Points:
- Supplier<T> does not take any arguments but returns a result of type T. It's often used to generate or supply new instances.
- Consumer<T> takes one argument of type T and returns no result, allowing side effects such as printing or storing data.
- Together, they can be used for producing, processing, and consuming data in a pipeline.

Example:

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Supplier;

public class SupplierConsumerExample {
    public static void main(String[] args) {
        Supplier<List<String>> supplier = ArrayList::new;
        Consumer<String> consumer = System.out::println;

        List<String> list = supplier.get();
        list.add("Java");
        list.add("Python");
        list.add("C++");

        list.forEach(consumer); // Consumes and prints each element
    }
}

This example demonstrates how a Supplier is used to provide a new list instance, and a Consumer is used to process (consume) each element of the list without expecting any return value.