Extract a list of unique departments from the employee list

• map(Employee::getDepartment) projects each employee to its department string.
• distinct() removes duplicates by calling equals() and hashCode(), keeping only the first occurrence.
• Stateful operation: distinct() internally maintains a Set of seen values.
• Order: preserves encounter order on sequential streams; on parallel, unordered() is faster.
• Alternative: collect(Collectors.toSet()) gives uniqueness without a separate distinct() call.

What does map plus distinct do?

First you project each employee to its department with map(Employee::getDepartment), turning the stream of employees into a stream of department strings. That stream will contain repeats because many employees share a department. The distinct() intermediate operation then removes duplicates, keeping only the first occurrence of each value in encounter order.

How do you extract unique departments?

package com.bank.hr;

import java.math.BigDecimal;
import java.util.List;
import java.util.stream.Collectors;

public class UniqueDepartments {
    public static void main(String[] args) {
        List<Employee> staff = List.of(
            new Employee("Rajesh",  "Loans",   new BigDecimal("95000")),
            new Employee("Priya",   "IT",      new BigDecimal("120000")),
            new Employee("Amit",    "Finance", new BigDecimal("85000")),
            new Employee("Kavita",  "Loans",   new BigDecimal("78000")),
            new Employee("Suresh",  "IT",      new BigDecimal("110000")));

        List<String> departments = staff.stream()
            .map(Employee::getDepartment)
            .distinct()
            .collect(Collectors.toList());

        System.out.println(departments);
    }
}

[Loans, IT, Finance]

How does distinct() decide uniqueness?

distinct() uses equals() and hashCode() to decide whether two elements are the same. For strings this works out of the box because String has well-defined equals and hashCode. If you were distinct-ing custom objects you would have to override both methods correctly, otherwise distinct would treat every object as unique by identity.

How is distinct() different from toSet()?

| Approach | Result type | Preserves order? | Extra operation? |
|---|---|---|---|
| distinct() + toList() | List | Yes (sequential) | distinct is stateful |
| toSet() | Set | No (HashSet) | Inherent uniqueness |
| toCollection(LinkedHashSet::new) | Set | Yes (insertion order) | Inherent uniqueness |

// Using toSet() instead of distinct
import java.util.Set;

Set<String> deptSet = staff.stream()
    .map(Employee::getDepartment)
    .collect(Collectors.toSet());

System.out.println(deptSet); // unordered

What are common mistakes?

Mistake: forgetting to override equals and hashCode on custom objects used with distinct.

// WRONG: Department class without equals/hashCode
// distinct() compares by identity, so duplicates survive
List<Department> unique = deptList.stream()
    .distinct()
    .collect(Collectors.toList());
// All objects survive because they are different references!

// CORRECT: override equals and hashCode in Department
@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (!(o instanceof Department d)) return false;
    return Objects.equals(name, d.name);
}

@Override
public int hashCode() {
    return Objects.hash(name);
}

What about parallel streams and distinct?

distinct() is stateful because it must remember the values it has already seen. On a sequential stream it preserves encounter order. On a parallel stream maintaining order is more expensive, so if order does not matter you can call unordered() before distinct to let the engine drop the ordering constraint and run faster.

// Parallel with unordered for better performance
List<String> depts = staff.parallelStream()
    .map(Employee::getDepartment)
    .unordered()
    .distinct()
    .collect(Collectors.toList());

What about null department values?

If any employee has a null department, distinct() itself does not crash, but the null will appear in the result list. Filter it out if that is not desired.

List<String> safeDepts = staff.stream()
    .map(Employee::getDepartment)
    .filter(java.util.Objects::nonNull)
    .distinct()
    .collect(Collectors.toList());

What should a senior engineer know?

• distinct() internally uses a LinkedHashSet on sequential streams to maintain insertion order.
• On very large datasets with many duplicates, the internal set can consume significant memory.
• If you only need to check membership or count unique values, toSet() or Collectors.toUnmodifiableSet() is simpler.
• The choice between distinct-then-toList and toSet depends on whether you need encounter order.

What are common interview follow-up questions?

• "What does distinct use internally?" An internal Set based on equals and hashCode.
• "Does distinct preserve order?" Yes on sequential streams; on parallel it depends on the unordered flag.
• "When is toSet better than distinct plus toList?" When you do not need ordered output.