Java Backend Developer Interview Questions (Level-2)

12. What Are the Different Types of Streams in Java 8?

Java 8 introduced two types of streams for functional-style data processing:

• Sequential Stream:
  
  • Processes elements one by one in a single thread.
    
  • Example: .stream()
    
• Parallel Stream:
  
  • Utilizes multiple threads to divide processing for better performance.
    
  • Example: .parallelStream()
    

---

13. Can You Use Multiple Filters in a Single Stream?

Yes, you can chain multiple filters using Java 8 Stream API.

java

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

numbers.stream()

    .filter(n -> n > 2)

    .filter(n -> n % 2 == 0)

    .forEach(System.out::println); // Output: 4

---

14. Explain reduce() in Java 8 Streams With Example

The reduce() method is used to aggregate stream elements (e.g., sum, product, concatenation).

java

List<Integer> numbers = Arrays.asList(1, 2, 3, 4);

int sum = numbers.stream()

    .reduce(0, Integer::sum);

System.out.println(sum); // Output: 10

---

15. How Does Java 8 Handle Default Methods in Multiple Inheritance?

When a class implements multiple interfaces with the same default method, it must override it to resolve the conflict.

java

interface A {

    default void display() {

        System.out.println(“A”);

    }

}

interface B {

    default void display() {

        System.out.println(“B”);

    }

}

class C implements A, B {

    public void display() {

        A.super.display(); // Resolving conflict by choosing A’s method

    }

}

---

16. Best Practices for Using Java 8 Streams

• Avoid Streams for small datasets—use for large collections.
  
• Use parallelStream() wisely for performance improvement.
  
• Prefer method references over complex lambdas.
  
• Always consume streams with terminal operations like collect(), forEach(), reduce().
  

---

17. Remove Duplicates Using Stream.distinct()

java

List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 4, 4, 5);

List<Integer> distinct = numbers.stream()

    .distinct()

    .collect(Collectors.toList());

System.out.println(distinct); // Output: [1, 2, 3, 4, 5]

---

18. Filter Strings Starting With “A”

java

List<String> names = Arrays.asList(“Alice”, “Bob”, “Annie”, “Alex”);

List<String> filtered = names.stream()

    .filter(name -> name.startsWith(“A”))

    .collect(Collectors.toList());

System.out.println(filtered); // Output: [Alice, Annie, Alex]

---

19. Sort List Alphabetically and in Reverse

java

List<String> names = Arrays.asList(“Charlie”, “Alice”, “Bob”);

// Ascending

List<String> sorted = names.stream()

    .sorted()

    .collect(Collectors.toList());

System.out.println(sorted); // [Alice, Bob, Charlie]

// Descending

List<String> reversed = names.stream()

    .sorted(Comparator.reverseOrder())

    .collect(Collectors.toList());

System.out.println(reversed); // [Charlie, Bob, Alice]

---

20. Flatten a Nested List Using flatMap()

java

List<List<Integer>> nested = Arrays.asList(

    Arrays.asList(1, 2, 3),

    Arrays.asList(4, 5),

    Arrays.asList(6, 7, 8)

);

List<Integer> flat = nested.stream()

    .flatMap(List::stream)

    .collect(Collectors.toList());

System.out.println(flat); // Output: [1, 2, 3, 4, 5, 6, 7, 8]

---

21. Separate Even and Odd Numbers With partitioningBy()

java

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);

Map<Boolean, List<Integer>> partitioned = numbers.stream()

    .collect(Collectors.partitioningBy(n -> n % 2 == 0));

System.out.println(partitioned);

// Output: {false=[1, 3, 5], true=[2, 4, 6]}

---

22. Group Employees by Department Using groupingBy()

java

class Employee {

    String name, department;

    Employee(String name, String department) {

        this.name = name;

        this.department = department;

    }

}

List<Employee> employees = Arrays.asList(

    new Employee(“Alice”, “HR”),

    new Employee(“Bob”, “IT”),

    new Employee(“Charlie”, “HR”),

    new Employee(“David”, “IT”)

);

Map<String, List<Employee>> grouped = employees.stream()

    .collect(Collectors.groupingBy(emp -> emp.department));

grouped.forEach((dept, emps) -> {

    System.out.println(dept + “: ” +

        emps.stream().map(e -> e.name).collect(Collectors.toList()));

});

// Output:

// HR: [Alice, Charlie]

// IT: [Bob, David]

👉The Next 10 Questions-3: JAVA BACKENDS