How do I convert lambda parameters to usable objects?

Question

I'm trying to stream a list of Doubles into a Map<Double, Double>, where the keys are the Doubles in the original list, and the values are some computed value.

This is what my code looks like:

// "values" is a List<Double> that was passed in
ImmutableMap<Double, Double> valueMap = values.parallelStream()
    .collect(Collectors.toMap(p -> p, p -> doThing(values, p)));

private Double doThing(List<Double>, Double p) {
    Double computedValue = 0.0;
    // Do math here with p
    return computedValue;
}

However, IntelliJ is complaining that p -> p is not a valid lambda expression - it's complaining about a cyclic inference. I'm also getting an error when I call doThing, because p is a lambda parameter and not a Double.

When I try to cast p to a Double in the call to doThing, that fails to cast.

Am I missing something really obvious? It seems like there's no way to actually do anything with my lambda parameters...

Answer 1

I think the problem here is simply that your collecting operation returns a Map<Double, Double> but the type of valueMap is ImmutableMap<Double, Double>.

You also forgot to give a name for the List<Double> parameter in doThing but I assume it was only a typo when writing the question.

Answer 2

As stated, the problem is that Collectors.toMap accumulates the element into Map<K,U> (the current implementation returns an HashMap but it's an internal detail).

If you want to collect into an ImmutableMap, you can use the collectingAndThen collector.

Use Collectors.toMap as the downstream collector and provide the function map -> ImmutableMap.copyOf(map) as a finisher.

ImmutableMap<Double, Double> valueMap = values.stream()
                .collect(collectingAndThen(toMap(p -> p, p -> doThing(values, p)), ImmutableMap::copyOf));