Convert OptionalDouble to Optional

Question

I have a method that builds a list and I want it to return the average of the list as an Optional value.

However, when I calculate the average value using Java 8, I always get the return value as an OptionalDouble.

How do I convert

OptionalDouble to Optional<Double>?

Below are my code for average calculation:

private static Optional<Double> averageListValue() {
     // Build list
     List<Double> testList = new ArrayList<>();
     testList.add(...);
     ...
     ...


     return testList.stream().mapToDouble(value -> value).average();
}

Thanks.

How about `getAsDouble` on OptionalDouble which will get you the average in `double` which is what you will finally want. — VHS, Feb 13 '17 at 18:28
An OptionalDouble is more efficient; nearer to `double`, so transforming the using code from `Optional` to `OptionalDouble` would seem better. But then, I think you know that and have your reason. — Joop Eggen, Feb 13 '17 at 18:55
If the code builds a list like shown, you already know that it will never be empty. So why returning an `Optional` at all? — Holger, Feb 13 '17 at 19:52
@VHS Thanks for the suggestion. Apparently this method is reaching a consensus here as well. — 000000000000000000000, Feb 13 '17 at 20:29
@Holger There are some details I am skipping here, but the actual usage might lead an empty List. — 000000000000000000000, Feb 13 '17 at 20:31

score 12 · Answer 1 · edited May 11 '21 at 17:39

12

I'd go for this approach:

private static Optional<Double> convert(OptionalDouble od) {
    return od.isPresent() ? 
        Optional.of(od.getAsDouble()) : Optional.empty();
}

edited May 11 '21 at 17:39

Naman

27,789
26
218
353

answered Feb 13 '17 at 20:23

Marco13

53,703
9
80
159

score 7 · Answer 2 · edited May 23 '17 at 11:54

7

A slight variation on @Andremoniy's answer is to skip the DoubleStream and use the averagingDouble() collector:

if (testList.isEmpty()) {
    return Optional.empty();
}
return Optional.of(testList.stream().collect(Collector.averagingDouble()));

Or consider whether 0 is a valid return value for an empty list, and possibly skip the Optional entirely.

edited May 23 '17 at 11:54

Community

1
1

answered Feb 13 '17 at 21:06

shmosel

49,289
6
73
138

score 5 · Answer 3 · answered Feb 13 '17 at 20:37

5

BTW, I found another solution, which has most simple form.

I've started thinking about: when result of average can be empty? Only when list it self is empty, right? So if we are sure that list is not empty, than we can safely do getAsDouble():

return Optional.ofNullable(testList.isEmpty() ? null : 
        testList.stream().mapToDouble(v -> v).average().getAsDouble())

(from performance point of view this could be more efficient than creating additional lambda wrappers, as was suggested in similar answers.)

answered Feb 13 '17 at 20:37

Andremoniy

34,031
20
135
241

3

This is a double-test, first `isEmpty()`, then a `null` test within `ofNullable`. There is no need for the second test: `return testList.isEmpty()? Optional.empty(): Optional.of(testList.stream().mapToDouble(v -> v).average().getAsDouble());` – Holger Feb 14 '17 at 11:37
4

I thought about it, but I specifically put ternary operation inside `Optional.ofNullable`. It is more stylish thing, while I agree that it has one more comparison operation – Andremoniy Feb 14 '17 at 11:39

score 4 · Answer 4 · answered Oct 07 '20 at 07:54

This is quite an old question, but in newer versions of Java you can:

// Given an OptionalDouble
var myOptionalDouble = OptionalDouble.of(3.0d);

// Convert to Optional<Double>
var myOptional = myOptionalDouble.stream().boxed().findFirst();

The reverse is similarly easy:

var myOptional = Optional.of(Double.valueOf(3.0d));

var myOptionalDouble = myOptional.stream().mapToDouble(t -> t).findFirst();

Calculator · Answer 5 · 2017-02-13T18:45:05.540

0

I don't know if there exists a neat solution, but ths should work:

OptionalDouble optionalDouble = testList.stream().mapToDouble(value -> value).average();
return Optional.ofNullable(optionalDouble.isPresent() ? optionalDouble.getAsDouble() : null);

edited Feb 13 '17 at 18:45

answered Feb 13 '17 at 18:38

Calculator

2,769
1
13
18

score 0 · Answer 6 · answered Feb 13 '17 at 19:58

Just for fun, I wanted to see if it could be written in a single statement, without any need for an OptionalDouble temp variable. Here is the best I came up with:

return testList.stream().collect(Collectors.collectingAndThen(
    Collectors.summarizingDouble(Double::doubleValue),
    stat -> Optional.ofNullable(stat.getCount()>0 ? stat.getAverage() : null)));

Andremoniy · Answer 7 · 2017-02-13T20:25:03.640

I came to this "one line" (single statement) solution:

    return ((Function<OptionalDouble, Optional<Double>>) od
            -> od.isPresent() ? Optional.of(od.getAsDouble()) : Optional.empty())
            .apply(testList.stream().mapToDouble(v -> v).average());

BTW, just for sake of minimalism, if you will do static import:

import static java.util.Optional.*;

you can omit Optional., what makes it a little bit less messy.

Convert OptionalDouble to Optional

7 Answers7

Linked