Find the key with the maximum value in a map

• Map.Entry.comparingByValue() builds a comparator that orders entries by their value.
• stream().max(comparator) scans all entries and returns Optional with the largest value.
• Collections.max(entrySet, comparator) does the same but throws on an empty collection.
• Ties: max returns one arbitrary winner; chain thenComparing on the key for determinism.

How do you find the key with the maximum value?

Stream the entrySet, take the max by value, and read the key from the winning entry.

package com.bank.products;

import java.util.*;

public class MaxValueKey {
    public static void main(String[] args) {
        Map<String, Double> revenue = Map.of(
            "Savings", 15000.0,
            "Current", 22000.0,
            "Loans",   45000.0,
            "FD",      31000.0
        );

        String topProduct = revenue.entrySet().stream()
            .max(Map.Entry.comparingByValue())
            .map(Map.Entry::getKey)
            .orElse("None");

        System.out.println("Top product: " + topProduct);
    }
}

Top product: Loans

How is the stream approach different from Collections.max?

| Feature | stream().max() | Collections.max() |
|---|---|---|
| Empty handling | Returns Optional.empty() | Throws NoSuchElementException |
| Return type | Optional | Entry |
| Null safety | Forces explicit handling | Requires manual guard |

// Stream: handles empty map safely
Optional<Map.Entry<String, Double>> opt = revenue.entrySet().stream()
    .max(Map.Entry.comparingByValue());

// Collections: throws on empty
Map.Entry<String, Double> entry = Collections.max(
    revenue.entrySet(), Map.Entry.comparingByValue());

How do you handle ties?

If two products share the maximum revenue, max returns one arbitrary winner. For deterministic selection, extend the comparator.

String deterministic = revenue.entrySet().stream()
    .max(Map.Entry.<String, Double>comparingByValue()
        .thenComparing(Map.Entry.comparingByKey()))
    .map(Map.Entry::getKey)
    .orElse("None");

How do you find the key with the minimum value?

Replace max with min.

String lowestProduct = revenue.entrySet().stream()
    .min(Map.Entry.comparingByValue())
    .map(Map.Entry::getKey)
    .orElse("None");

What are common mistakes?

Mistake: using Collections.max on a potentially empty map.

// WRONG: throws on empty map
Map<String, Double> empty = Map.of();
var entry = Collections.max(empty.entrySet(),
    Map.Entry.comparingByValue());  // NoSuchElementException!

// CORRECT: stream().max() returns Optional
String safe = empty.entrySet().stream()
    .max(Map.Entry.comparingByValue())
    .map(Map.Entry::getKey)
    .orElse("No products");

What should a senior engineer know?

• max scans every entry once, so time complexity is O(n).
• The Optional chain (max then map then orElse) is the idiomatic way to extract the key safely.
• For the top N keys by value, use sorted(comparingByValue().reversed()).limit(n) instead of max.
• comparingByValue() uses natural ordering of the value type. For custom ordering, pass a comparator argument.

What are common interview follow-up questions?

• "How do you find the top 3 keys by value?" sorted(comparingByValue().reversed()).limit(3).
• "How do you find the entry with the maximum key?" Use comparingByKey() instead.
• "What if values are null?" comparingByValue throws NPE; filter nulls first.