Casting type inside Optional

Question

I have the following:

class Foo implements Inter {
    void doSomething();
}

Optional<Inter> getPossible() {
    Optional<Foo> possible = ...;
    possible.ifPresent(Foo::doSomething);
    return possible.map(f -> f);
}

getPossible needs to return an Optional<Inter> because it's overriding a superclass's implementation.

That map at the end of the method is purely to convert the type. Is there a more elegant option?

Is there a reason for `possible` not being of `Optional` type in the first place? — Eran, Dec 04 '17 at 12:21
Yes. The code in `ifPresent` needs the type. Will expand to demonstrate. — sprinter, Dec 04 '17 at 12:29
You could return an Optional extends Inter>, and remove the map(). — JB Nizet, Dec 04 '17 at 13:08
See also: https://stackoverflow.com/questions/44852936/how-to-upcast-object-contained-in-java-8-optional — M. Justin, Feb 15 '21 at 23:10

score 9 · Answer 1 · answered Nov 21 '19 at 11:39

9

To make clear that you only need casting, you can use Class::cast with .map:

class Foo implements Inter {
    void doSomething();
}

Optional<Inter> getPossible() {
    Optional<Foo> possible = ...;
    possible.ifPresent(Foo::doSomething);
    return possible.map(Inter.class::cast);
}

answered Nov 21 '19 at 11:39

Christian

13,285
2
32
49

The small downside of this approach is that it does unnecessary casting at runtime for a cast that will never fail. That said, casting should be pretty cheap these days. It also makes it seem like the casting is necessary (i.e. there may be a chance where it could fail), when it's just working around a compile-time limitation. Mapping using the identity instead of casting is just odd enough to call out that something weird is happening (or there's some redundant code that can be removed). – M. Justin Feb 15 '21 at 23:07

score 2 · Answer 2 · answered Dec 04 '17 at 13:13

2

Return a Optional<? extends Inter> instead of an Optional<Inter>.

answered Dec 04 '17 at 13:13

sprinter

27,148
6
47
78

4

If "getPossible needs to return an Optional because it's overriding a superclass's implementation" is true, changing the return type in a subclass to `Optional extends Inter>` shouldn't compile, unless you can also change the superclass – Chirlo Dec 04 '17 at 13:48
4

Besides that, having return types with wildcards is strongly discouraged. – Holger Dec 04 '17 at 15:06
@Holger appreciate an alternative then – sprinter Dec 04 '17 at 19:06
1

First of all, you should clarify why your solution works. As @Chirlo correctly pointed out, if the superclass declaration truly is `Optional getPossible()`, you can’t override it with a method having the signature `Optional extends Inter> getPossible()`. If that works, there must be an error in your premise, which would void your entire question. Once we know your true setup, we can suggest a solution. – Holger Dec 05 '17 at 09:07

score 1 · Answer 3 · answered Dec 04 '17 at 19:12

1

One alternative would be to edit the method signature in Foo to become the following:

class Foo implements Inter {
    Inter doSomething() {
        ...
        return this;
    }
}

Now, you can simplify getPossible to the following:

Optional<Inter> getPossible() {
    Optional<Foo> possible = ...;
    return possible.map(Foo::doSomething);
}

answered Dec 04 '17 at 19:12

Jacob G.

28,856
5
62
116

Instead of changing the signature of `doSomething()`, you could resort to a lambda expression, `return possible.map(foo -> { foo.doSomething(); return foo; });` – Holger Dec 05 '17 at 09:15

Casting type inside Optional

3 Answers3