Java: False safety provided by Optional

It's been a while from the day when Java 8 was released and the entire world get access to new API, including new class Optional.
Even if a lot of time already passed, the uncertainty on how and when to use Optional still persist.

In past days, before Java 8 the developers would create a service which would looks something like following:

public class UserRepository {

    public User findUserByName(String username) {
        // ... Code which will find user
        return user;
    }

}

The code which consumes the result of above API should verify for NULL if unwanted NullPointerException is desired.
Unfortunately the missing verification brought a lot of issues and money lose during entire Java history.

So it looked like Java 8 brought us a silver bullet, or at least so think a lot of Java developers. Today the UserRepository would look like following:

public class UserRepository {

    public Optional<User> findUserByName(String username) {
        // ... Code which will find user
        return Optional.ofNullable(user);
    }

}

So does the Optional is really save us from NullPointerException? is it a silver bullet?
The answer is NO!

Even with Optional the consumer should take in consideration that Optional may contain NULL, so what is the difference between

User user = userRepository.findUserByName("John");
return user != null ? user.getFullName() : "";

and

Optional<User> user = userRepository.findUserByName("John");
return user.map(User::getFullName).orElse("");

Well those who are for using Optional will say that in such way the API is telling to consumer that the returned object may be NULL and it should be handled, but it does not save from such usage as

userRepository.findUserByName("John").get().getFullName();

It is not right, but I already see such code, so how is it preventing from stupidity? Shouldn't each Java developer know that any method may return a NULL and verify it accordingly?

 If Optional in such case plays as documentation, then Java already for long time has

• JavaDoc - where API developer can state what a possible return values
• @Nullable/@Nonnull and other such type annotations
• Modern IDE which may tell to developer that method may return a NULL and proper handling should be done.

Still the Optional is useful a lot!

It very much simplify the code when a chain of transformations should be done, like:

Optional.ofNullable(userRepository.findUserByName("John"))

    .map(User::getFullName)

    .map(String::trim)

    .map(String::toUpperCase)

    .orElse("");