Using nullable objects in Optional methods after covering it with ofNullable

This is probably a mistake/not intended and doing something like that can cause issues during refactoring. When you see something like that, you should probably replace it with something using the lambda parameter (or a method reference).

For example, you could decide you want to perform some transformations returning a different object before:

String value = Optional.ofNullable(obj)
   .map(x -> createOtherObjectOfSameTypeForFurtherProcessing(x))
   .map(x -> obj.doSomething())
   .orElse(MyObject.DEFAULT_VALUE);

In this case, obj.doSomething() will still operate on the old object.

Alternatively, if obj is actually a field and not a parameter or local variable like in your example (thanks to user85421 in the comments for pointing out this isn't the case in this example), it would be possible that obj is modified before the map call:

//WARNING: questionable code
String value = Optional.ofNullable(obj)
   .filter(x -> {
      obj = null;//weird stuff done here, probably better don't do that in production
      return true;
   })
   .map(x -> obj.doSomething())
   .orElse(MyObject.DEFAULT_VALUE);

Something like that could also happen to another thread (which can (not always) be reasonable if obj is e.g. immutable and volatile)

And as obj is a parameter in your example, you can also not use your code if obj was modified at some point (as also pointed out by this comment), your code wouldn't compile.

//DOES NOT COMPILE
public void method(MyObject obj) {
    if(someEdgeCase()){
        obj = null;//makes obj not effectively final
    }
    String value = Optional.ofNullable(obj)
       .map(x -> obj.doSomething())//compiler error because obj is not effectively final
       .orElse(MyObject.DEFAULT_VALUE);

}