为何Java Stream的一种实现可操作静态Map，另一种却失败？

Understanding the Issue & Fix #

First, let’s clarify a key context: Your SOME_MAP must be of type Map<SomeObject, Collection<AnotherObject>> (not Map<SomeObject, AnotherObject>) for your first code snippet to make sense—since you’re using flatMap to flatten collections of AnotherObject into a single list. That’s critical to understanding why one approach works and the other throws an error.

Why the First Code Works

Stream.of(SOME_MAP.values()) creates a Stream<Collection<AnotherObject>> (because SOME_MAP.values() returns a Collection<Collection<AnotherObject>>). The method reference Collection::stream here acts as a function that takes each Collection<AnotherObject> instance and calls its instance method stream() on it. This is valid because every element in the stream is a Collection, so we’re invoking the method on an actual instance of the type.

Why the Second Code Throws the Error

Wait a minute—if your map is correctly typed as Map<SomeObject, Collection<AnotherObject>>, then SOME_MAP.values().stream() should create the exact same Stream<Collection<AnotherObject>> as Stream.of(SOME_MAP.values()), and flatMap(Collection::stream) should work without issue. The "non-static method cannot be referenced from a static context" error points to one of these common issues:

1. Naming Conflict with Custom Collection Class: If you have your own class named Collection in your project (instead of using java.util.Collection), Collection::stream refers to an instance method of your custom class. The compiler can’t resolve this properly in a static context because it expects an instance of your custom Collection to call the method on. Double-check your imports to ensure you’re using java.util.Collection.
2. Accidental Typo in Method Reference: If you mistakenly used AnotherObject::stream instead of Collection::stream, and AnotherObject has a non-static stream() method, you’d get this error—since you’re trying to reference an instance method without an instance of AnotherObject.
3. Raw Map Type: If you didn’t specify generics for SOME_MAP (e.g., private static final Map SOME_MAP = ...), the compiler loses type information. SOME_MAP.values().stream() would return a Stream<Object>, and Collection::stream would try to cast each Object to Collection—though this usually throws a different error, it’s worth ruling out.

The Correct Fix

Assuming you’re using java.util.Collection and your map is properly typed, the second code should work if written correctly:

List<AnotherObject> list = SOME_MAP.values().stream()
    .flatMap(Collection::stream)
    .collect(Collectors.toList());

If your map is actually Map<SomeObject, AnotherObject> (and you don’t need flatMap at all), you can simplify things entirely:

// No streams needed
List<AnotherObject> list = new ArrayList<>(SOME_MAP.values());

// Or with streams
List<AnotherObject> list = SOME_MAP.values().stream().collect(Collectors.toList());

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