Convert all employee names to uppercase

• map(String::toUpperCase) applies the instance method toUpperCase() to each string in the stream.
• Immutability: String.toUpperCase() returns a brand-new string; the original is untouched.
• Locale sensitivity: the no-argument form uses the JVM's default locale, which can produce surprising results for Turkish and similar scripts.
• Null guard: calling toUpperCase() on a null reference throws NullPointerException.
• Method reference type: String::toUpperCase is an unbound instance-method reference on the stream element.

What does map with toUpperCase do?

The map method applies a function to each element. Here the function is the String method toUpperCase, so stream.map(String::toUpperCase) converts every lowercase or mixed-case name into all capitals. The method reference String::toUpperCase is an unbound instance-method reference, meaning the compiler calls toUpperCase() on each incoming string element.

How do you convert employee names to uppercase?

package com.bank.hr;

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

public class UpperCaseNames {
    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")));

        List<String> upperNames = staff.stream()
            .map(Employee::getName)
            .map(String::toUpperCase)
            .collect(Collectors.toList());

        System.out.println(upperNames);
    }
}

[RAJESH, PRIYA, AMIT]

Why are the original strings unchanged?

Strings in Java are immutable. toUpperCase() does not change the original string; it returns a brand-new string. This means the source list of employees is completely unaffected. Map produces a separate stream of new capitalised strings that you collect into a new list.

What is the locale problem with toUpperCase?

The no-argument toUpperCase() uses the JVM's default locale, which can produce surprising results for certain languages. The classic example is the Turkish dotless letter i: in Turkish, the uppercase of 'i' is 'I with a dot above', not the plain 'I' that English expects.

import java.util.Locale;

public class LocaleDemo {
    public static void main(String[] args) {
        String name = "Rajesh";

        // Default locale (depends on server)
        System.out.println(name.toUpperCase());

        // Explicit locale (deterministic)
        System.out.println(name.toUpperCase(Locale.ROOT));
        System.out.println(name.toUpperCase(Locale.ENGLISH));
    }
}

RAJESH
RAJESH
RAJESH

In a bank that runs across regions, the safe habit is to specify a locale explicitly so the output is deterministic regardless of the server's locale.

What are common mistakes?

Mistake: calling toUpperCase on a null name, which throws NullPointerException.

// WRONG: if getName() returns null, toUpperCase crashes
List<String> names = staff.stream()
    .map(Employee::getName)
    .map(String::toUpperCase)       // NullPointerException!
    .collect(Collectors.toList());

// CORRECT: filter nulls first
List<String> safeNames = staff.stream()
    .map(Employee::getName)
    .filter(java.util.Objects::nonNull)
    .map(String::toUpperCase)
    .collect(Collectors.toList());

How is this different from toLowerCase?

| Method | Result | Use case |
|---|---|---|
| toUpperCase() | All characters uppercase | Badge printing, reference codes |
| toLowerCase() | All characters lowercase | Case-insensitive comparison keys |
| toUpperCase(Locale.ROOT) | Locale-safe uppercase | Cross-region banking systems |

What about chaining multiple maps?

You can chain as many map operations as needed. Each map transforms the stream element, and the chain runs lazily, so all transformations apply as each element flows through.

// Extract name, uppercase, trim, all in one pipeline
List<String> cleaned = staff.stream()
    .map(Employee::getName)
    .map(String::trim)
    .map(String::toUpperCase)
    .collect(Collectors.toList());

What should a senior engineer know?

• Multiple consecutive map calls can be merged into a single map with a composed function for slightly less overhead, but readability usually trumps that micro-optimization.
• For bulk text transformations, ensure the locale is pinned in the service configuration so reports are reproducible across deployment regions.
• toUpperCase() creates a new String object per call, so on very large datasets the GC pressure is proportional to the number of elements.

What are common interview follow-up questions?

• "Does toUpperCase modify the original string?" No, strings are immutable.
• "What is the locale issue?" Default locale can produce wrong results for Turkish and similar languages.
• "How do you handle null names?" Filter them out or map through a null-safe helper before calling toUpperCase.