Vrftsjtryk

I'm making a service call and trying to handle response.
Response might have a list of something. That list might be null.

Moreover, if list not null or not empty, then
it needs to be filtered.
In the code "entry" reference might be null if filtering gives nothing or response list is empty or null.

Currently i'm getting NPE when i try to use stream() on a null response list.
How can i handle this situation?

@Getter

public class ServiceResponse {  

    List<ResponseEntry> entryList;

}



@Getter

public class ResponseEntry {

    String value;

}





ServiceResponse serviceResponse = service.getServiceResponse();

ResponseEntry entry = serviceResponse.getEntryList()

    .stream()

    .filter(e -> "expectedValue".equals(e.getValue()))

    .findFirst()

    .orElse(null);



if (entry == null) { ... }

In Java 9, you could use the new method Objects.requireNonNullElse(T,T):

Objects.requireNonNullElse(serviceResponse.getEntryList(),

                           Collections.emptyList())

Apache Commons Collections actually has a method ListUtils.emptyIfNull(List<T>) which returns an empty list if the argument list is null. That's even better, but Objects.requireNonNullElse is the closest thing to it in Java SE.

If you're restricted to just Java 8, then I agree with Aomine's answer that trying to do something like go through Optional is worse than an if statement.

Stream.ofNullable (Java-9)

Returns a sequential Stream containing a single element, if non-null,
otherwise returns an empty Stream.

Current Code

ResponseEntry entry = serviceResponse.getEntryList() // List<ResponseEntry>

        .stream() // NPE here   // Stream<ResponseEntry>

        .filter(e -> "expectedValue".equals(e.getValue())) // filter

        .findFirst() // Optional<ResponseEntry>

        .orElse(null); // or else null

Updated Code

ResponseEntry entry = Stream.ofNullable(serviceResponse.getEntryList()) // Stream<List<ResponseEntry>>

        .flatMap(List::stream) // Stream<ResponseEntry>

        .filter(e -> "expectedValue".equals(e.getValue())) // filter here

        .findFirst() // Optional<ResponseEntry>

        .orElse(null); // or else null

Optional.stream (Java-9)

returns a sequential Stream containing only that value, otherwise
returns an empty Stream.

ResponseEntry entry = Optional.ofNullable(serviceResponse.getEntryList())

        .stream() // Stream<List<ResponseEntry>>

        .flatMap(List::stream) // Stream<ResponseEntry>

        .filter(e -> "expectedValue".equals(e.getValue())) // filter here

        .findFirst() // Optional<ResponseEntry>

        .orElse(null); // or else null

Optional.isEmpty(Java-11)

If a value is not present, returns true, otherwise false

Optional<ResponseEntry> entry = Optional.ofNullable(serviceResponse.getEntryList()) // Optional<List<ResponseEntry>>

        .orElseGet(Collections::emptyList) // or else empty List

        .stream() // Stream<ResponseEntry>

        .filter(e -> "expectedValue".equals(e.getValue())) // filter

        .findFirst(); // Optional<ResponseEntry>



if (entry.isEmpty()) { // !entry.isPresent in java-8

   // Do your work here

}

if list not null or not empty, then it needs to be filtered.

No need for Optional here, as it's not intended to replace simple if checks.

ResponseEntry entry = null;

List<ResponseEntry> responseEntries = serviceResponse.getEntryList();

if(responseEntries != null && !responseEntries.isEmpty()){

    entry = responseEntries.stream()

                .filter(e -> "expectedValue".equals(e.getValue()))

                .findFirst()

                .orElse(null);

}

• reads "if responseEntries is not null and responseEntries is not empty then apply the filter operation and find the first item or else null". Very readable.

On the other hand, the optional approach:

ResponseEntry entry = Optional.ofNullable(serviceResponse.getEntryList())

                              .orElseGet(() -> Collections.emptyList())

                              .stream()

                              .filter(e -> "expectedValue".equals(e.getValue()))

                              .findFirst();



if(!entry.isPresent()){ ... } // or entry.ifPresent(e -> ...) depending on the logic you're performing inside the block

• unnecessarily creates objects that could be avoided and not really the intention of optional to be used as a substitute for simple "if" checks.

You could simply use the ternary operator:

ServiceResponse serviceResponse = service.getServiceResponse();

List<ResponseEntry> list = serviceResponse.getEntryList();



ResponseEntry entry = (list == null ? Collections.emptyList() : list)

    .stream()

    .filter(e -> "expectedValue".equals(e.getValue()))

    .findFirst()

    .orElse(null);



if (entry == null) { ... }

Sometimes, traditional is better IMO.

Optional is container object which may or may not contain a non-null value. If a value is present, isPresent() will return true and get() will return the value, and it is not used for replacing if else.

You can use ternary operator

(Objects.nonNull(serviceResponse.getEntryList()) ? serviceResponse.getEntryList() : new ArrayList<T>()).stream().filter(e -> "expectedValue".equals(e.getValue()))

    .findFirst()

    .orElse(null);

Have you tried much simpler approaches like using try catch for null pointer exception