为何Stream.mapToInt方法不处理NullPointerException？代码抛NPE疑问

Great question! Let's unpack exactly what's happening here and why you're seeing that NPE.

First, let's look at the root cause in your code:

List<Integer> list = Arrays.asList(null, null);
OptionalDouble op = list.stream().mapToInt(val->val).average();

The mapToInt(val -> val) part is doing something subtle: since val is an Integer (from your list), using it directly as the return value for mapToInt triggers auto-unboxing—converting the Integer wrapper type to the primitive int. When val is null, this unboxing operation throws a NullPointerException—this isn't caused by mapToInt itself, but by the unboxing in your lambda expression.

Now, why doesn't mapToInt handle this NPE? It boils down to Java's core design principles and the Stream API's philosophy:

• Fail-fast behavior: Java prioritizes exposing errors early rather than hiding them. If mapToInt silently swallowed the NPE or defaulted to some value (like 0), you might not realize your list contains nulls, leading to hidden bugs in your logic.
• Responsibility separation: The mapToInt method's job is only to convert a Stream<Integer> to an IntStream by applying your provided ToIntFunction. It doesn't (and shouldn't) interfere with the logic inside your function—handling nulls is your responsibility as the developer, since only you know what the correct behavior should be for null values (skip them? replace with a default? throw a custom error?).

How to fix your code #

Here are two common approaches to avoid this NPE:

1. Filter out null values first (if nulls shouldn't be part of the average calculation):

import java.util.Arrays;
import java.util.List;
import java.util.OptionalDouble;
import java.util.Objects;

public class Main {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(null, null);
        OptionalDouble op = list.stream()
                .filter(Objects::nonNull) // Remove null elements before processing
                .mapToInt(Integer::intValue)
                .average();
        // op will be empty since all elements were filtered out
    }
}

2. Replace nulls with a default value (if you want to treat nulls as, say, 0 in the average):

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

public class Main {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(null, null);
        OptionalDouble op = list.stream()
                .map(val -> val != null ? val : 0) // Replace null with 0
                .mapToInt(Integer::intValue)
                .average();
        // op will be OptionalDouble[0.0]
    }
}

In short: mapToInt doesn't handle NPE because it's not its job—your lambda's unboxing is the culprit, and Java expects you to explicitly handle null cases that are specific to your application's logic.

内容的提问来源于stack exchange，提问作者Alexander Tukanov