Why not simply:

Copyreturn Optional.ofNullable(myMap.get(myKey));

JavaDocs

Edit

After watching Stuart Marks' (who works for the core libraries team in the JDK group at Oracle) talk "Optional – The Mother of All Bikesheds" from Devoxx 2016, you should jump to 54:04:

Why Not Use Optional in Fields?

• More a style issue than a correctness issue
  • usually there's a better way to model absence of a value
  • use of Optional in fields often arises from slavish desire to eliminate nullable fields
  • remember, eliminating nulls isn't a goal of Optional
• Using Optional in fields...
  • creates another object for every field
  • introduces a dependent load from memory on every field read
  • clutters up your code
  • to what benefit? ability to chain methods?

Original Post

According to IntelliJ's inspector (Preferences > Editor > Inspections > 'Optional' used as field or parameter type):

Optional was designed to provide a limited mechanism for library method return types where there needed to be a clear way to represent "no result". Using a field with type java.util.Optional is also problematic if the class needs to be Serializable, which java.util.Optional is not.

This also applies to collections in case you have to serialize them. Furthermore, have a look at these links:

• Java 8 Optional: What's the Point?

  So to recap - in an attempt to get rid of NullPointerExceptions we have a new class that:
  
  

  • Throws NullPointerExceptions
  • Can itself be null, causing a NullPointerException
  • Increases heap size
  • Makes debugging more difficult
  • Makes serializing objects, say as an XML or JSON for an external client, much more difficult

• Why java.util.Optional is broken

  The final irony is that by attempting to discourage nulls, the authors of this class have actually encouraged its use. I'm sure there are a few who will be tempted to simply return null from their functions in order to "avoid creating an unnecessary and expensive Optional reference", rather than using the correct types and combinators.

If you care about readability, you could also use @Nullable (available in Eclipse as well as in IntelliJ):

class ConnectionBox {
    @Nullable
    Connection connection;
    // ...
}

Alternatively, you can create an optional getter:

class ConnectionBox {
    Connection connection;
    // ...
    Optional<Connection> getConnection() {
        return Optional.ofNullable(connection);
    }
}

The whole chain of operations returns a String:

• The first step (map(...)) maps the Optional<User> to an Optional<String>.
• The second step (orElseThrow(...)) unwraps the Optional<String>, thus returning a String (or throwing an IllegalArgumentException, if empty).

We can find the source code of Optional::map here.

Given the example you've provided, it seems that you want to apply the operation foo.add if bar is present otherwise return foo:

Foo foobar = bar.isPresent() ? foo.add(bar.get()) : foo;

Thus, I'd say it's so short that it's not worthy of creating a utility method for it.

Foo foobar = optBar.map(f::add).orElse(f); // map to Foo if bar is present else return `f`

• if optBar has a present state, we apply the map operation and orElse returns that mapped value.
• if optBar has an absent state, the orElse method returns the supplied default value f.

Another thing, are you getting the result as an Optional<Bar> in the first place or are you manually wrapping Bar into an Optional? if it's the latter I'd probably just use a simple if statement which would be the ideal solution, i.e.

Foo foo = new Foo();
if(bar != null) foo = foo.add(bar);

Use map if the function returns the object you need or flatMap if the function returns an Optional. For example:

public static void main(String[] args) {
  Optional<String> s = Optional.of("input");
  System.out.println(s.map(Test::getOutput));
  System.out.println(s.flatMap(Test::getOutputOpt));
}

static String getOutput(String input) {
  return input == null ? null : "output for " + input;
}

static Optional<String> getOutputOpt(String input) {
  return input == null ? Optional.empty() : Optional.of("output for " + input);
}

Both print statements print the same thing.

Here's an example of pure stream solution (without ifs and ternary operators)

final Map<MyCoolKey, Optional<MyCoolValue>> myCoolMap = new HashMap<>();

Optional<Map<MyCoolKey, MyCoolValue>> output = Optional.of(myCoolMap)
    .filter(map -> map.values().stream().allMatch(Optional::isPresent))
    .map(map -> map
        .entrySet()
        .stream()
        .collect(toMap(
            Map.Entry::getKey,
            entry -> entry.getValue().get()
        ))
    );

It's not over-complicating - filtering and mapping are what's streams are for!