Java streams optional with null check on two items

Question

I have the following code which works on two values viz. a List of String and a String. Both the List and String can be null.

List<String> myStringList = getMyStringList(); // may return null
String myString = "abc"; // may be null

List<String> finalStringList = Optional.ofNullable(myStringList)
            .map(strings -> strings.stream()
                    .filter(obj -> StringUtils.isEmpty(myString)
                            || myString.equals(obj))
                    .collect(Collectors.toList()))
            .orElseGet(ArrayList::new);

Idea is: If myStringList is null, then result in an empty ArrayList. If myString is null, then return myStringList as is. If myString is not null, then loop through the list and return all items matching myString.

Problem is, with solution above, I still loop through the whole list (strings.stream) even when myString is null.

Assuming myStringList is very big, how can I avoid looping the list for the case when myString is null?

That is,

1) do a null check on the list. If null, return a new empty list.

2) do a null check on myString. If null, return the list as is WITHOUT LOOPING.

3) if myString is not null, loop through the list and return the filtered list.

Best solution: fix getMyStringList() to return an empty list instead of null. — Anonymous
– Anonymous, Commented Nov 6, 2019 at 5:11
Related and a very good read: How to best create a Java 8 stream from a nullable object? (I suggest that this question is partially a duplicate of that one) — Anonymous
– Anonymous, Commented Nov 6, 2019 at 5:18
@Vicky The question would be really clear if you could draw the expectation with all 4 possible combinations of myString and myStringList 's presence and absence. — Naman
– Naman, Commented Nov 6, 2019 at 9:19

Elliott Frisch · Accepted Answer · 2019-11-06 05:08:55Z

2

You could use a ternary like,

List<String> finalStringList = myString == null ?
        Collections.emptyList()
        : Optional.ofNullable(myStringList)
        .map(strings -> strings.stream()
                .filter(obj -> StringUtils.isEmpty(myString)
                        || myString.equals(obj))
                .collect(Collectors.toList()))
        .orElseGet(ArrayList::new);

Or a basic if and default to an empty list. Like,

List<String> finalStringList = Collections.emptyList();
if (myString != null) {
    finalStringList = Optional.ofNullable(myStringList)
            .map(strings -> strings.stream()
                    .filter(obj -> StringUtils.isEmpty(myString)
                            || myString.equals(obj))
                    .collect(Collectors.toList()))
            .orElseGet(ArrayList::new);
}

answered Nov 6, 2019 at 5:08

Elliott Frisch

202k20 gold badges166 silver badges265 bronze badges

Sign up to request clarification or add additional context in comments.

3 Comments

Vicky Over a year ago

So you reckon I will have to use a ternary.. I thought of that.. but wanted to be sure if that is the only way and it can not be done using Streams and Optional..

Elliott Frisch Over a year ago

The if does not use a ternary; so you don't "have to use a ternary". But you can.

lczapski Over a year ago

As this requirement says: "2) do a null check on myString. If null, return the list as is WITHOUT LOOPING." than this Collections.emptyList() should be rather myStringList

ernest_k · Accepted Answer · 2019-11-06 09:55:06Z

1

This may work for you (with Java 9+):

List<String> result2 = Optional.ofNullable(myString)
  .filter(Objects::nonNull)
  .map(mystr -> Optional.ofNullable(myStringList)
                        .filter(Objects::nonNull)
                        .or(() -> Optional.of(new ArrayList<>()))
                        .stream()
                        .flatMap(List::stream)
                        .filter(mystr::equals)
                        .collect(Collectors.toList())) //ArrayList not guaranteed
    .orElse(myStringList);

If you're using Java 8, the following should work, but it looks a little harder to read:

List<String> result = Optional.ofNullable(myString)
  .filter(Objects::nonNull)
  .map(mystr -> Optional.ofNullable(myStringList)
                .filter(Objects::nonNull)
                .map(list -> list.stream()
                            .filter(mystr::equals)
                            .collect(Collectors.toList()))
                .orElseGet(ArrayList::new))
  .orElse(myStringList);

edited Nov 6, 2019 at 9:55

answered Nov 6, 2019 at 5:49

ernest_k

45.5k5 gold badges58 silver badges107 bronze badges

7 Comments

Vicky Over a year ago

I am on Java 8. But your solution with Java 8 is not working.

Vicky Over a year ago

It throws NullPointerException when myStringList is null.

ernest_k Over a year ago

@Vicky. No, I get an empty list when I test it. You may need to share your snippet.

Vicky Over a year ago

added snippet in the answer

ernest_k Over a year ago

@Vicky Your requirements stated * If myString is null, then return myStringList as is*. In your example, myString is null, and therefore the result is null. But you're calling System.out.println(result.size()); without checking if result is null. That explains your NPE. Right?

|

lczapski · Accepted Answer · 2019-11-06 11:04:05Z

Other solution

List<String> myStringList = Arrays.asList("abc", "aef"); // may return null
String myString = "abc"; // may be null

Map<Predicate, Supplier<List<String>>> predicateMap = Map.of(
      (v) -> myStringList == null, () -> new ArrayList<>(), // do a null check on the list. If null, return a new empty list.
      (v) -> myString == null, () -> myStringList, // do a null check on myString. If null, return the list as is WITHOUT LOOPING.
      (v) -> true, () -> myStringList.stream() // if myString is not null, loop through the list and return the filtered list.
                .filter(myString::equals)
                .collect(Collectors.toList())
      );
List<String> outputList = predicateMap.entrySet().stream()
      .filter(p -> p.getKey().test(null))
      .findFirst().get().getValue().get();

System.out.println(outputList);

user_3380739 · Accepted Answer · 2023-01-08 04:07:01Z

0

Personally, I think the code by if-else will be much more readable/maintainable/efficient:

if (myStringList == null || myStringList.size() == 0) {
    return Collections.emptyList();
} else if (StringUtils.isEmpty(myString)) {
    return new ArrayList<>(myStringList); // or return myStringList;
} else {
    return myStringList.stream().filter(e -> myString.equals(e))
                                .collect(Collectors.toList());
}

Okay, if you really want to avoid writing a few lines of code, try my library: abacus-common

return N.isNullOrEmpty(myString) ? N.newArrayList(myStringList) 
                                 : N.filter(myStringList, e -> myString.equals(e));

edited Jan 8, 2023 at 4:07

answered Nov 10, 2019 at 3:39

user_3380739

1,32416 silver badges15 bronze badges

Collectives™ on Stack Overflow

Java streams optional with null check on two items

4 Answers 4

3 Comments

7 Comments

Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

3 Comments

7 Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related