CODEWITHSUNDEEP
javalambdajava-8option-type
Scorpion
Scorpion

Reputation: 673

Using Java 8 Optional for List of String as output

I want to use Optional for a method which returns a List

Lets say the function is 

public Output getListOfSomething() {
    // In some cases there is nothing to return and hence it makes sense to have return 
    // type as Optional here
}

Hence the function looks like : 

public Optional<List<String>> getListOfSomething() {
    // return something only when there is some valid list
}

Now I want to do something if the list is present so something like :

Optional<List<String>> listOfSomething = getListOfSomething();

int size = 0;

listOfSomething.ifPresent(size = listOfSomething.get().size());

I am new to Optional and have gone through the articles about Optional and it seems like this should work however am getting syntax error in my IDE :

method ifPresent is not applicable for the arguments (void).

I wanted to get some help from developers who might be more fluent with lamdas in java 8.

Upvotes: 25

Views: 133039

Answers (3)

Daniel
Daniel

Reputation: 4549

It's important to think about the Semantics here.

Your method could return a List, or "no list".

If it returns a List, it could return an Empty list.

You should ask, "is there a semantic reason to distinguish between an Empty List, and No List?" Sometimes there is a good design reason to make the difference, but it is rare. Think long and hard before deciding that Empty and Null are different in your case. Part of the reason to avoid No List, is that it reduces "special cases" that the client code has to consider. For example, if they have to do something for every item returned, but you could also return null, they have to do a special check for null before going into a for each loop. A for each does nothing if the list is empty.

If a "No List" is distinct from an "Empty List" in your problem domain, then it is sometimes useful to return wrapper class that helps client code distinguish between those conditions, and handle them appropriately. Optional is one such generic class, but your domain may call for something more specific (even if it mimics the functionality of Optional, it might have better semantic definition).

Upvotes: 42

pbod
pbod

Reputation: 91

ifPresent requires a Consumer interface to work. You could do the following: 

Optional<List<String>> listOfSomething = getListOfSomething();
Integer[] size = {0};
listOfSomething.ifPresent(list -> size[0]=list.size())

But as stated by Tagir Valeev it would be better to do:

size = listOfSomething.map(List::size).orElse(0);

And it would also be better to return an empty List or even a Stream maybe.

Upvotes: 9

Tagir Valeev
Tagir Valeev

Reputation: 100189

The true functional-programming way is the following:

size = listOfSomething.map(List::size).orElse(0);

But it would be much better to return an empty List instead of Optional.

Upvotes: 26

Related Questions