Java interview questions on streams

Core Concepts

1. What is a Stream?
   A sequence of elements that supports sequential or parallel operations. Streams do not store data; they operate on a source (e.g., collection) and support functional-style operations such as filter, map, and reduce.

2. Stream vs. Collection

   • Collections store data, while streams process it on demand.
   • Streams are lazy, meaning operations execute only when a terminal operation is invoked.

3. Intermediate vs. Terminal Operations

   • Intermediate operations: filter, map, sorted (return a new stream, lazy).
   • Terminal operations: collect, forEach, reduce (produce a result or side effect, eager).

Common Operations

4. Filter vs. Map

   • filter(Predicate): Selects elements matching a condition.
   • map(Function): Transforms elements into another shape, such as extracting a field.

5. Reduce
   Combines elements into a single result, such as the sum of numbers:

   int sum = numbers.stream().reduce(0, (a, b) -> a + b);
   

6. FlatMap
   Flattens nested collections (e.g., List<List> to List):

   List<Integer> flatList = nestedList.stream().flatMap(List::stream).toList();
   

Advanced Concepts

7. Parallel Streams

   • Allow processing to occur in multiple threads using parallelStream().
   • Thread safety: Ensure the lambda expression is stateless or non-interfering.

8. Stateful vs. Stateless Operations

   • Stateless: filter, map (do not depend on other elements).
   • Stateful: distinct, sorted (must keep everything in memory).

9. Short-Circuiting Operations
   These operations end processing early, such as findFirst, limit, and anyMatch.

Collectors

10. Collectors.toList
    Collects the values of a stream into a list:

    List<String> names = people.stream().map(Person::getName).toList();
    

11. GroupingBy
    Groups elements by a classifier, such as grouping people by age:

    Map<Integer, List<Person>> peopleByAge = people.stream()
        .collect(Collectors.groupingBy(Person::getAge));
    

12. PartitioningBy
    Splits elements into two groups (true/false) based on a predicate:

    Map<Boolean, List<Person>> partitioned = people.stream()
        .collect(Collectors.partitioningBy(p -> p.getAge() >= 18));
    

Coding Problems

13. Find distinct elements in a list:

    List<Integer> distinct = numbers.stream().distinct().toList();
    

14. Sum all even numbers:

    int sum = numbers.stream().filter(n -> n % 2 == 0).mapToInt(n -> n).sum();
    

15. Convert a list of strings to uppercase:

    List<String> upper = strings.stream().map(String::toUpperCase).toList();
    

16. Find the longest string in a list:

    Optional<String> longest = strings.stream()
        .max(Comparator.comparingInt(String::length));
    

17. Concatenate two streams:

    Stream<String> combined = Stream.concat(stream1, stream2);
    

Best Practices & Pitfalls

18. Avoid Side Effects
    Stream operations should be stateless; avoid modifying external variables in lambdas.

19. Primitive Streams
    Performance can be improved using IntStream, LongStream, or DoubleStream for primitive types.

20. Reusing Streams
    Streams are one-time use only; create new ones if needed.

21. ForEach vs. For-Loops
    Prefer forEach for clarity, but avoid it for complex mutations or state modifications.

Scenario-Based Interview programming Questions On Java Streams

22. How to handle exceptions in streams?
    Wrap checked exceptions in a lambda with try-catch or use utility methods like Unchecked:

    List<String> result = files.stream().map(file -> { 
        try { 
            return readFile(file); 
        } catch (IOException e) { 
            throw new UncheckedIOException(e); 
        } 
    }).toList();
    

23. When to use parallel streams?
    Use for large volumes of data and CPU-bound tasks but avoid for I/O operations or small datasets.

24. Why does peek exist?
    Used for debugging/logging intermediate stream states, such as peek(System.out::println).

Advanced Coding Challenges

25. Find the second-largest number in a list:

    OptionalInt secondLargest = numbers.stream()
        .distinct()
        .sorted()
        .skip(numbers.size() - 2)
        .findFirst();
    

26. Merge two lists of objects into a map (ID → Object):

    Map<Integer, Person> idToPerson = people.stream()
        .collect(Collectors.toMap(Person::getId, Function.identity()));
    

27. Count occurrences of every word in a list:

    Map<String, Long> wordCount = words.stream()
        .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));
    

These questions cover fundamental programming concepts, best practices, and optimization strategies. Senior developers may also focus on parallel stream effectiveness and custom collectors.

 Java 8 coding questions:

This table properly structures the Java 8 coding problems with their corresponding solutions. Let me know if you need any modifications! 

Java 8 Coding Interview Questions and Answers

This document contains a collection of Java 8 coding interview questions along with their answers. These questions focus on key Java 8 features such as Streams, Lambda Expressions, Functional Interfaces, and Method References.

1. Filtering a List and Summing Even Numbers using Streams

Question: Given a list of integers, write a Java 8 program to filter out even numbers and calculate their sum.

Answer:

import java.util.Arrays;
import java.util.List;

public class SumOfEvenNumbers {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        int sum = numbers.stream()
                         .filter(n -> n % 2 == 0) // Filter even numbers
                         .mapToInt(Integer::intValue) // Convert to IntStream
                         .sum(); // Calculate sum

        System.out.println("Sum of even numbers: " + sum);
    }
}

Output:

Sum of even numbers: 30

2. Sorting a List of Strings in Ascending and Descending Order

Question: Write a Java 8 program to sort a list of strings in both ascending and descending order.

Answer:

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class SortStrings {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("John", "Alice", "Bob", "Charlie");

        // Ascending order
        List<String> ascendingOrder = names.stream()
                                           .sorted()
                                           .collect(Collectors.toList());

        // Descending order
        List<String> descendingOrder = names.stream()
                                            .sorted((s1, s2) -> s2.compareTo(s1))
                                            .collect(Collectors.toList());

        System.out.println("Ascending Order: " + ascendingOrder);
        System.out.println("Descending Order: " + descendingOrder);
    }
}

Output:

Ascending Order: [Alice, Bob, Charlie, John]
Descending Order: [John, Charlie, Bob, Alice]

3. Finding the Maximum and Minimum Values in a List

Question: Write a Java 8 program to find the maximum and minimum values in a list of integers.

Answer:

import java.util.Arrays;
import java.util.List;
import java.util.Optional;

public class MaxMinValues {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(10, 20, 5, 30, 15);

        Optional<Integer> max = numbers.stream().max(Integer::compareTo);
        Optional<Integer> min = numbers.stream().min(Integer::compareTo);

        System.out.println("Max Value: " + max.orElse(0));
        System.out.println("Min Value: " + min.orElse(0));
    }
}

Output:

Max Value: 30
Min Value: 5

4. Grouping Objects by a Specific Property using Streams

Question: Given a list of Employee

Answer:

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

class Employee {
    private String name;
    private String department;

    public Employee(String name, String department) {
        this.name = name;
        this.department = department;
    }

    public String getDepartment() {
        return department;
    }

    @Override
    public String toString() {
        return name;
    }
}

public class GroupByDepartment {
    public static void main(String[] args) {
        List<Employee> employees = Arrays.asList(
            new Employee("John", "HR"),
            new Employee("Alice", "IT"),
            new Employee("Bob", "HR"),
            new Employee("Charlie", "IT")
        );

        Map<String, List<Employee>> groupedByDepartment = employees.stream()
            .collect(Collectors.groupingBy(Employee::getDepartment));

        System.out.println("Employees grouped by department: " + groupedByDepartment);
    }
}

Output:

Employees grouped by department: {HR=[John, Bob], IT=[Alice, Charlie]}

5. Removing Duplicates from a List using Streams

Question: Write a Java 8 program to remove duplicates from a list of integers.

Answer:

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class RemoveDuplicates {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 4, 4, 5);

        List<Integer> uniqueNumbers = numbers.stream()
                                             .distinct()
                                             .collect(Collectors.toList());

        System.out.println("Unique Numbers: " + uniqueNumbers);
    }
}

Output:

Unique Numbers: [1, 2, 3, 4, 5]

6. Counting the Frequency of Characters in a String using Streams

Question: Write a Java 8 program to count the frequency of each character in a string.

Answer:

import java.util.Map;
import java.util.stream.Collectors;

public class CharacterFrequency {
    public static void main(String[] args) {
        String input = "java8";

        Map<Character, Long> frequencyMap = input.chars()
            .mapToObj(c -> (char) c)
            .collect(Collectors.groupingBy(c -> c, Collectors.counting()));

        System.out.println("Character Frequency: " + frequencyMap);
    }
}

Output:

Character Frequency: {a=2, v=1, j=1, 8=1}