Using optional to populate value in a Map

Question

I am new to Java, and still learning Optionals. I understood its used to avoid Null Pointer Exception.

I have a piece of code wherein I want to use optional, which is like this:

    final MetadataExtractor<FCAddress> metadataExtractor = t -> {
        final Map<String, String> metadata = new HashMap<>();
        metadata.put("senderCountryCode", t.getCountryCode());
        metadata.put("senderState", t.getState());
        metadata.put("senderPostalCode",t.getPostalCode());
        return metadata;
    };

Here, my use case is, if the SenderState is empty, i.e. t.getState() is empty, I want the map field to to be empty, that is not populated.

I tried something like this:

    final MetadataExtractor<FCAddress> metadataExtractor = t -> {
        final Map<String, String> metadata = new HashMap<>();
        metadata.put("senderCountryCode", t.getCountryCode());
        Optional<String> senderState = Optional.of(t.getState());
        senderState.ifPresent(metadata.put("senderState", t.getState());
        metadata.put("senderPostalCode",t.getPostalCode());
        return metadata;
    };

But this gives a compilation error, where am I going wrong in this? Error is: "ifPresent (java.util.function.Consumer) in Optional cannot be applied"

If you get an error (compile or runtime) then include it in your question. — Joakim Danielson, May 08 '19 at 07:21
@AxelH OP is using **if**Present, not **is**. And no, OP doesn't want `map`. — Andy Turner, May 08 '19 at 07:23
When you say "t.getState() is empty" do you mean *empty*, or do you mean *null*? They are not the same thing. — Andy Turner, May 08 '19 at 07:33

Pavel Razgovorov · Answer 1 · 2019-05-08T08:20:24.460

3

You need to pass a Consumer (a lambda) to ifPresent:

senderState.ifPresent(state -> metadata.put("state", state);
// important: the Consumer always receive a parameter.
// An empty value `() ->` is not valid!

The lambda will only get executed in case senderState is present (that means, is not null).

BTW it's very important to construct your senderState by using Optional.ofNullable(...)! Otherwise, it'll throw an NPE.

Check out an in-depth tutorial: https://www.baeldung.com/java-optional

edited May 08 '19 at 08:20

answered May 08 '19 at 07:31

Pavel Razgovorov

95
2
7

@AndyTurner once you're in the lambda you don't need to use `t.getState()`, but `state`. – Pavel Razgovorov May 08 '19 at 08:21

score 2 · Answer 2 · edited May 08 '19 at 08:30

still learning Optionals. I understood its used to avoid Null Pointer Exception.

Not necessarily. They are rather a mean that allows you to have something that represents "nothing".

Regarding your actual compile error:

senderState.ifPresent(metadata.put("senderState", t.getState());

ifPresent() wants a consumer. From the javadoc:

public void ifPresent(Consumer<? super T> consumer)

If a value is present, invoke the specified consumer with the value, otherwise do nothing.

metadata.put() isn't a consumer. That is an ordinary method call on that map! And it will return a the "value" type of your map, so a String. Strings aren't Consumers!

Long story short: if you really want to use ifPresent() here, then you would probably want to pass a lambda expression (see here for some examples).

In your case,

senderState.ifPresent(state -> metadata.put("senderState", state));

should do.

Davide Lorenzo MARINO · Accepted Answer · 2019-05-08T07:38:09.957

In this particular code the use of Optional is not useful because you don't like to add an Optional to the map, but only skip null values.

The simplest solution that doesn't create new objects is adding a check on value of t.getState() as follow:

final MetadataExtractor<FCAddress> metadataExtractor = t -> {
    final Map<String, String> metadata = new HashMap<>();
    metadata.put("senderCountryCode", t.getCountryCode());
    if (t.getState() != null) {
       metadata.put("senderState", t.getState());
    }
    metadata.put("senderPostalCode",t.getPostalCode());
    return metadata;
};

Just for studying purpose the solution of GhostCat works with an Optional:

senderState.ifPresent(() -> metadata.put("senderState", t.getState());

the complete example will be:

final MetadataExtractor<FCAddress> metadataExtractor = t -> {
    final Map<String, String> metadata = new HashMap<>();
    metadata.put("senderCountryCode", t.getCountryCode());

    // Here you create a not useful object that can be replaced with a simple if
    Optional<String> senderState = Optional.ofNullable(t.getState());

    // Here you create a second not necessary object because a lambda
    // espression is an instance of an anonimous class implementing
    // the corresponding interface
    senderState.ifPresent(() -> 
         metadata.put("senderState", t.getState()
    );
    metadata.put("senderPostalCode",t.getPostalCode());
    return metadata;
};

Note that this solution will create two unnecessary objects:

The explicit Optional senderState
and another object for the Consumer created as lambda expression inside the ifPresent method

of() will throw an exception if t.getState() is null. To make it work, ofNullable() must be used. — JB Nizet, May 08 '19 at 07:37

score 2 · Answer 4 · answered May 08 '19 at 07:42

Just to present a totally different approach to the problem:

Put everything into the map, and then remove the null values after:

metadata.values().removeIf(Objects::isNull);

This is a lot neater syntactically, but may or may not be faster because of doing something and then undoing it, as opposed to just not doing it in the first place.

Using optional to populate value in a Map

4 Answers4