Is it possible to transform this code to a Java 8 Optional one-line expression?
long lastPollTime; if (object != null) { lastPollTime = object.getTime(); } else { lastPollTime = 0; }
i.e. if some object is not null, I need to call an object method and return its result, or else return 0. Optional.ofNullable().orElse()
is not suitable, as it returns the object of the same type, but i need the result of the method call or some default value.
i.e. if some object is not null, I need to call an object method and return its result, or else return 0. Optional. ofNullable().
Optional isn't magic, it's an object like any other, and the Optional reference itself can be null. It's the contents of the Optional that can't be null.
Optional ofNullable() method in Java with examples If the specified value is null, then this method returns an empty instance of the Optional class. Parameters: This method accepts value as parameter of type T to create an Optional instance with this value. It can be null.
Java 8 – Optional orElse() and orElseGet() methods These two methods orElse() and orElseGet() returns the value of Optional Object if it is no empty, if the object is empty then it returns the default value passed to this method as an argument.
A few forms:
long lastPollTime = Optional.ofNullable(object).map(o -> o.getTime()).orElse(0L); long lastPollTime = Optional.ofNullable(object).map(YouObjectClass::getTime).orElse(0L); long lastPollTime = Optional.ofNullable(object).isPresent() ? object.getTime() : 0; long lastPollTime = object != null ? object.getTime() : 0;
Of these, the last one, which doesn't use Optional (and therefore doesn't strictly answer your question!) is simpler to read and has fewer runtime overheads, and so should be preferred.
Arguably, it's even simpler if you reverse the options:
long lastPollTime = object == null ? 0 : object.getTime();
... although you might prefer to have the default last -- it's a matter of personal taste.
If you really can't use ternary operators, and you're doing this a lot, you could write your own utility method:
public <T,U> U mapWithFallback(T obj, Function<T,U> function, U fallback) { if(obj == null) { return fallback; } else { return function.apply(obj); } }
... callable as:
long lastPollTime = mapWithFallback(object, o -> o.getTime(), 0);
... or make a complete mockery of your no-ternaries check using:
public <T,U> U ifElse( Supplier<Boolean> a, Supplier<U> ifTrue, Supplier<U> ifFalse) { if(a.get()) { return ifTrue.get(); } else { return ifFalse.get(); } } long lastPollTime = ifElse( () -> object == null, () -> object.getTime(), () -> 0);
It's in even better taste to avoid null references altogether, so that this kind of check isn't needed -- for example using the Null Object pattern.
... or by writing methods that return Optional
rather than potential nulls. Optional
is a great class; use it. Just don't convert something to Optional
purely so you can immediately check whether it's empty.
long lastPollTime = Optional.ofNullable(object).map(YouObjectClass::getTime).orElse(0L);
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With