So, my question is - are those changes to Optional adding some benefits ...

Well there are definitely advantages and disadvantages for both approaches:

Looking from the Optional side, the main "plus" is that you eliminate a major source of bugs; i.e. NPE's caused by not dealing with a possible returned null correctly. The main "minuses" are the verbosity of code that uses Optional, and that it doesn't actually eliminate all bugs; e.g. if you call Optional.get on an "empty" Optional you will get an exception.

Other Q&A's go into more detail:

• Null check vs Optional is present check
• Uses for Optional
• Optional vs. null. What is the purpose of Optional in Java 8?
• Is using Optional.ofNullable as a replacement for the ternary operator a good practice?

... or we are just following fashion without thinking.

That is a different question!

Now I imagine some people may be using Optional without thinking, but I don't see much evidence of that. It is clear that there are advantages AND disadvantages, and that thought is required.

So you should really be asking (yourself!) if >>you<< just following fashion without thinking? Or to put it another way, are you just treating this as a (so-called) "best practice", or are you making a reasoned choice between the two approaches depending on the context?

I have got a suggestion to rewrite everything [in my example] using Optional.

Here's what I suggest.

1. Create a branch in your version control system.
2. In the branch, change your API method to use Optional, and change all of the places in your code that use the API method.
3. Make a judgement: has this improved things? was the effort worth it?
4. If the API is currently or going to used by other people's code, ask their opinions too.
5. Decide whether to proceed or not, implement decision, and move on to the next issue.

If that sounds like too much work, another option is to quietly ignore that suggestion.

Either way, we (the StackOverflow community) can't decide for you. We don't have the context¹, and even if we did, there would be a range of opinions and no clear correct answer.

^{1 - For instance, what is the likelihood of there being no locale, and no determinable language. What the application as a whole should do about it? Should it bail out? Should it substitute a default? Could the default be substituted ... here? We can't see "the big picture".}

Optional harnesses the type system for doing work that you'd otherwise have to do all in your head: remembering whether or not a given reference may be null. This is good. It's always smart to let the compiler handle boring drugework, and reserve human thought for creative, interesting work.

Without Optional, every reference in your code is like an unexploded bomb. Accessing it may do something useful, or else it may terminate your program wth an exception.

With Optional and without null, every access to a normal reference succeeds, and every reference to an Optional succeeds unless it's unset and you failed to check for that. That is a huge win in maintainability.

Unfortunately, most languages that now offer Optional haven't abolished null, so you can only profit from the concept by instituting a strict policy of "absolutely no null, ever". Therefore, Optional in e.g. Java is not as compelling as it should ideally be.

An Optional always contains a non-null value or is empty, yes, but you don't have an Optional, you have a reference of type Optional pointing to null. You need to initialize testString, e.g. to Optional.empty().

Optional isn't magic, it's an object like any other, and the Optional reference itself can be null. It's the contents of the Optional that can't be null.

In practice, why is this useful?

For example let's say you have this stream of integers and you're doing a filtering:

int x = IntStream.of(1, -3, 5)
                 .filter(x -> x % 2 == 0)
                 .findFirst(); //hypothetical assuming that there's no Optional in the API

You don't know in advance that the filter operation will remove all the values in the Stream.

Assume that there would be no Optional in the API. In this case, what should findFirst return?

The only possible way would be to throw an exception such as NoSuchElementException, which is IMO rather annoying, as I don't think it should stop the execution of your program (or you'd have to catch the exception, not very convenient either) and the filtering criteria could be more complex than that.

With the use of Optional, it's up to the caller to check whether the Optional is empty or not (i.e if your computation resulted in a value or not).

With reference type, you could also return null (but null could be a possible value in the case you filter only null values; so we're back to the exception case).

Concerning non-stream usages, in addition to prevent NPE, I think it also helps to design a more explicit API saying that the value may be present or not. For example consider this class:

class Car {
   RadioCar radioCar; //may be null or not 
   public Optional<RadioCar> getRadioCar() {
        return Optional.ofNullable(radioCar);
   }
}

Here you are clearly saying to the caller that the radio in the car is optional, it might be or not there.