Java 8 Interview Questions: Streams, Lambdas & Functional Interfaces Explained

import java.util.*;
import java.util.function.*;

public class LambdaAndFunctionalInterfaces {

    public static void main(String[] args) {

        // --- Predicate<T>: takes T, returns boolean ---
        // Use this for filtering decisions
        Predicate<String> isLongName = name -> name.length() > 5;
        System.out.println(isLongName.test("Ada"));       // false
        System.out.println(isLongName.test("Alexander")); // true

        // --- Function<T, R>: takes T, returns R ---
        // Use this for data transformation
        Function<String, Integer> nameLength = String::length; // method reference
        System.out.println(nameLength.apply("Jordan")); // 6

        // --- Consumer<T>: takes T, returns nothing ---
        // Use this for side effects (logging, printing, saving)
        Consumer<String> greet = name -> System.out.println("Hello, " + name + "!");
        greet.accept("Priya"); // Hello, Priya!

        // --- Supplier<T>: takes nothing, returns T ---
        // Use this for lazy/deferred value creation
        Supplier<List<String>> freshList = ArrayList::new;
        List<String> myList = freshList.get(); // creates a new ArrayList on demand
        myList.add("item");
        System.out.println(myList); // [item]

        // --- Composing functions: the real power ---
        // andThen() chains two Functions: first apply toUpperCase, then get length
        Function<String, String> toUpper = String::toUpperCase;
        Function<String, Integer> lengthAfterUpper = toUpper.andThen(String::length);
        System.out.println(lengthAfterUpper.apply("hello")); // 5

        // --- Predicate composition ---
        Predicate<String> startsWithA = name -> name.startsWith("A");
        Predicate<String> longAndStartsWithA = isLongName.and(startsWithA);
        System.out.println(longAndStartsWithA.test("Alice"));    // false (length 5, not > 5)
        System.out.println(longAndStartsWithA.test("Alexander")); // true
    }
}

import java.util.*;
import java.util.stream.*;

public class StreamPipelineDemo {

    record Employee(String name, String department, double salary) {}

    public static void main(String[] args) {

        List<Employee> employees = List.of(
            new Employee("Alice",   "Engineering", 95000),
            new Employee("Bob",     "Marketing",   72000),
            new Employee("Carlos",  "Engineering", 110000),
            new Employee("Diana",   "Engineering", 88000),
            new Employee("Eve",     "Marketing",   91000),
            new Employee("Frank",   "HR",           65000)
        );

        // --- EXAMPLE 1: Filter + Map + Collect ---
        // Get names of Engineering employees earning over 90k, sorted alphabetically
        List<String> seniorEngineers = employees.stream()          // source
            .filter(e -> e.department().equals("Engineering"))     // intermediate: keep only engineers
            .filter(e -> e.salary() > 90_000)                      // intermediate: keep only high earners
            .map(Employee::name)                                    // intermediate: transform to names
            .sorted()                                               // intermediate: alphabetical order
            .collect(Collectors.toList());                          // terminal: materialise into a List

        System.out.println("Senior Engineers: " + seniorEngineers);

        // --- EXAMPLE 2: Grouping with Collectors.groupingBy ---
        // Group employees by department — returns Map<String, List<Employee>>
        Map<String, List<Employee>> byDepartment = employees.stream()
            .collect(Collectors.groupingBy(Employee::department));

        byDepartment.forEach((dept, empList) -> {
            System.out.println(dept + ": " + empList.stream()
                .map(Employee::name)
                .collect(Collectors.joining(", ")));
        });

        // --- EXAMPLE 3: Reduction — average salary per department ---
        Map<String, Double> avgSalaryByDept = employees.stream()
            .collect(Collectors.groupingBy(
                Employee::department,
                Collectors.averagingDouble(Employee::salary) // downstream collector
            ));

        avgSalaryByDept.forEach((dept, avg) ->
            System.out.printf("%s avg salary: $%.0f%n", dept, avg));

        // --- EXAMPLE 4: Short-circuit laziness in action ---
        // findFirst() stops processing as soon as one match is found
        Optional<Employee> firstHighEarner = employees.stream()
            .peek(e -> System.out.println("Checking: " + e.name())) // peek shows processing order
            .filter(e -> e.salary() > 100_000)
            .findFirst(); // stops after Carlos is found — doesn't check Diana, Eve, Frank

        firstHighEarner.ifPresent(e ->
            System.out.println("First high earner: " + e.name()));
    }
}

import java.util.*;

public class OptionalBestPractices {

    record User(String username, String email) {}

    // A repository that might not find a user — Optional makes that explicit
    static Optional<User> findUserByUsername(String username) {
        Map<String, User> database = Map.of(
            "alice99", new User("alice99", "alice@example.com"),
            "bob42",   new User("bob42",   "bob@example.com")
        );
        // Returns Optional.ofNullable — wraps value if present, empty if null
        return Optional.ofNullable(database.get(username));
    }

    public static void main(String[] args) {

        // --- BAD pattern (don't do this): ---
        // Optional<User> result = findUserByUsername("unknown");
        // User user = result.get(); // throws NoSuchElementException if empty!

        // --- GOOD pattern 1: orElseThrow with a meaningful exception ---
        try {
            User alice = findUserByUsername("alice99")
                .orElseThrow(() -> new RuntimeException("User not found in system"));
            System.out.println("Found: " + alice.email());
        } catch (RuntimeException e) {
            System.out.println(e.getMessage());
        }

        // --- GOOD pattern 2: map() to transform the value inside Optional ---
        // We want the email, but only if the user exists
        String email = findUserByUsername("bob42")
            .map(User::email)          // transforms User -> String inside the Optional
            .orElse("no-reply@example.com"); // fallback if user not found
        System.out.println("Email: " + email);

        // --- GOOD pattern 3: ifPresent for side effects ---
        findUserByUsername("ghost")
            .ifPresent(u -> System.out.println("This won't print: " + u.username()));
        System.out.println("Ghost user not found — nothing printed above.");

        // --- orElse vs orElseGet: the performance difference ---
        // orElse: the expensive default is ALWAYS evaluated (even if value exists!)
        User userA = findUserByUsername("alice99")
            .orElse(createExpensiveDefaultUser()); // createExpensiveDefaultUser() RUNS even here

        // orElseGet: the supplier only runs if the Optional is empty
        User userB = findUserByUsername("alice99")
            .orElseGet(() -> createExpensiveDefaultUser()); // NOT called — alice99 exists

        System.out.println("userA: " + userA.username());
        System.out.println("userB: " + userB.username());
    }

    static User createExpensiveDefaultUser() {
        System.out.println("[Creating expensive default user]"); // shows when this runs
        return new User("guest", "guest@example.com");
    }
}

import java.util.*;
import java.util.stream.*;

public class DefaultAndStaticInterfaceMethods {

    // Two interfaces with the same default method signature — the diamond scenario
    interface Flyable {
        default String describe() {
            return "I can fly";
        }
    }

    interface Swimmable {
        default String describe() {
            return "I can swim";
        }
    }

    // Duck implements both — must resolve the conflict explicitly
    static class Duck implements Flyable, Swimmable {
        @Override
        public String describe() {
            // Explicitly delegate to Flyable's version using InterfaceName.super
            return Flyable.super.describe() + " and " + Swimmable.super.describe();
        }
    }

    // A practical default method example: an interface that adds logging behaviour
    interface DataValidator<T> {
        boolean isValid(T value); // abstract — implementors must define this

        // Default method: built on top of isValid — no need to override
        default boolean isInvalid(T value) {
            return !isValid(value);
        }

        // Static utility: creates a validator that rejects nulls before delegating
        static <T> DataValidator<T> nonNull(DataValidator<T> delegate) {
            return value -> value != null && delegate.isValid(value);
        }
    }

    public static void main(String[] args) {

        // --- Diamond problem resolution ---
        Duck duck = new Duck();
        System.out.println(duck.describe()); // uses our explicit override

        // --- DataValidator with default and static methods ---
        DataValidator<String> emailValidator = email ->
            email.contains("@") && email.contains(".");

        // isInvalid() comes from the default method — we never wrote it
        System.out.println(emailValidator.isValid("user@example.com"));  // true
        System.out.println(emailValidator.isInvalid("not-an-email"));     // true

        // Static factory method wraps our validator with null protection
        DataValidator<String> safeValidator = DataValidator.nonNull(emailValidator);
        System.out.println(safeValidator.isValid(null));                  // false (no NPE!)
        System.out.println(safeValidator.isValid("user@example.com"));    // true

        // --- Real-world default method: Comparator chaining ---
        List<String> names = new ArrayList<>(List.of("Charlie", "Alice", "Bob", "Alice"));

        // thenComparing is a default method on Comparator added in Java 8
        names.sort(
            Comparator.comparing(String::length)          // sort by length first
                      .thenComparing(Comparator.naturalOrder()) // then alphabetically
        );
        System.out.println(names); // [Bob, Alice, Alice, Charlie]
    }
}