java 8 optional to replace return null

Question

I am refactoring the code to Java 8 and I want to replace null checks with Optional.

public Employee findEmployeeById(String id) {
    List<Employee> empList = .. //some db query
    return (empList.isEmpty() ? null : empList.get(0));
}

Optional.ofNullable(empList.get(0)) won't work as when it will throw IndexOutofBoundException

Or should I ideally replace null with Optional.empty()?

Why doesn't your query only return a single result in the first place? — Marvin, May 13 '17 at 09:57
That is a complex logic ....of left joins and all....I understand you point but cant really change that — coder25, May 13 '17 at 09:58
`return empList.isEmpty() ? Optional.empty() : Optional.of(empList.get(0));` — Jesper, May 13 '17 at 09:58
When I replace this code and inspect Optiona.empty() ,it shows null then what is the use to use Optional — coder25, May 13 '17 at 10:23
Optional wraps a reference to an object, or nothing. Of course, inside the Optional, it it wraps nothing, the reference to the object is null. What else could it be? What matters is that what your method returns is an Optional, which is never null, and which forced the caller to think about and deal with an empty value. — JB Nizet, May 13 '17 at 11:17

score 10 · Accepted Answer · edited May 23 '17 at 12:34

As @Jesper already mentioned in the comments, you have to check whether the list is empty and then return an empty Optional.

public Optional<Employee> findEmployeeById(String id) {
    List<Employee> empList = .. //some db query
    return empList.isEmpty() ? Optional.empty() : Optional.of(empList.get(0));
}

An Optional is a wrapper around a potentially null value that allows you to avoid explicitly checking for null when you use it.

Have a look at the Optional documentation to see what functionality it provides.

For example you can get an employee's name or "unknown" if it's absent, without checking for null:

Optional<Employee> emp = findEmployeeById(id);
String name = emp.map(Employee::getName).orElse("unknown");

You may read this post about Uses for Optional to see if it makes sense for you to use Optional.

Isn't it bad to return Optional.of instead of Optional.ofNullable as a practice? — Bilbo Baggins, Mar 31 '20 at 07:50
@BilboBaggins if the value can be null, then yes, you have to use `Optional.ofNullable()`. — Floern, Apr 01 '20 at 07:45

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

6

To me the natural solution would be to keep your ? : construct as in Floern’s answer. If, however, you want to get rid of that, there is also an elegant solution without it:

public Optional<Employee> findEmployeeById(String id) {
    List<Employee> empList = .. //some db query
    return empList.stream().findFirst();
}

This gives you what you want because findFirst() returns an Optional. If you don’t care which element you get — or you know there’s never more than one — you may alternatively use findAny(), it too returns an Optional.

edited May 23 '17 at 11:54

Community

1
1

answered May 13 '17 at 20:57

Ole V.V.

81,772
15
137
161

Good one, didn't think about that – Floern May 14 '17 at 00:39
2

Nice! You don't even need the `empList` local, so this can be reduced to `return someDbQuery().stream().findFirst()`. – Stuart Marks May 14 '17 at 04:13

score 3 · Answer 3 · edited May 13 '17 at 13:13

Why don't you simply replace your method with:

public Optional<Employee> findEmployeeById(String id) {
    List<Employee> empList = .. //some db query
    return (empList.isEmpty() ? Optional.empty() : 
              Optional.ofNullable(empList.get(0)));
}

I suggest you wrap the empList.get(0) in a Optional.ofNullable in case it might still be null.

As far as why that is better: think about the caller of the method. Whomever is now calling your method has to think what to actually do when the result is empty.

Besides you are now forced into writing code like:

Optional<Employee> emp = findEmployeeById("12");

if (emp.isPresent()) {

} else {
    ....
}

You can also chain this to become more fluent like:

emp.orElseThrow(RuntimeException::new)

Or other Optional methods.

That is simply not the case when you return an Employee. You are not even thinking (usually) to check if the reference is null.

That makes your code less error-prone and easier to understand.

score 2 · Answer 4 · answered May 13 '17 at 13:59

Another possibility would be to do it as follows:

return Optional.of(empList).filter(list -> !list.isEmpty()).map(list -> list.get(0));

This will automatically return an empty Optional in case the list is empty or empList.get(0) returns null.

If empList can be null, consider using Optional.ofNullable(empList) instead of Optional(empList).

java 8 optional to replace return null

4 Answers4

Linked