Right.

public static Optional<String> getFileMd5(String filePath)
        throws NoSuchAlgorithmException, IOException {

        return Optional.empty(); // I.o. null

    return Optional.of(nonnullString);
}

Usage:

getFileMd5(filePath).ifPresent((s) -> { ... });

or (less nice as undoing the Optional)

String s = getFileMd5(filePath).orElse("" /* null */);

To return the value of an optional, or a default value if the optional has no value, you can use orElse(other).

public String longestName() {
    Optional<String> longNameOpt = someList.stream().max(Comparator.comparingInt(String::length));
    return longNameOpt.orElse("not present");
}

Note that I rewrote your code for finding the longest name: you can directly use max(comparator) with a comparator comparing the length of each String. One such comparator can be obtained by calling Comparator.comparingInt(keyExtractor) with the key extractor being the method reference String::length.

It depends.

A class List can have a method firstElement which should return an Optional to indicate there may be no elements.

A data or value class like eg class User with name and birthdate should use constructor injection that enforces all attributes are provided and are not null. Then there's no need to wrap anything in Optional.

Since there are a lot more pitfalls to take into account when it comes to data or value classes, it makes sense to use Google Immutables to have them generated for you according to best practices so you only have to worry about what attributes they should have and not how they should work.

If you find yourself adding Optional attributes to data or value classes, eg Optional memberNumber to the User class, you're probably doing something wrong. Instead, create a Member class that has a user and a memberNumber.

Actually what you are searching is: Optional.map. Your code would then look like:

Copyobject.map(o -> "result" /* or your function */)
      .orElseThrow(MyCustomException::new);

I would rather omit passing the Optional if you can. In the end you gain nothing using an Optional here. A slightly other variant:

Copypublic String getString(Object yourObject) {
  if (Objects.isNull(yourObject)) { // or use requireNonNull instead if NullPointerException suffices
     throw new MyCustomException();
  }
  String result = ...
  // your string mapping function
  return result;
}

If you already have the Optional-object due to another call, I would still recommend you to use the map-method, instead of isPresent, etc. for the single reason, that I find it more readable (clearly a subjective decision ;-)).