Just adding a Maybe type to Java wouldn't do anything; each method would still have to handle the Nothing case in some way.
For Maybe to be useful in Java, control flow would have to change from running one line after another to "running" by applying functions, so that whether or not to run each "line of code" would be determined by a combinator that understands the semantics of Maybe. Then, of course, you just have Haskell, which already exists!
A better option for Java would be a type that could not be null. I don't think the language allows the compiler to determine this, though, which means it probably won't exist (or if it does exist, it won't be too useful).
Basically, if you want a good type system, you want to ditch Java.
Saying that this is "a monstrosity" because nulls shouldn't exist in the first place is completely unhelpful. Whether we like them or not, we're going to be stuck with them for a long while, and attempts to make them less painful to deal with aren't a bad thing.
In addition, there's no reason we can't write a language without nulls which works on the JVM.
There are languages which work (mostly) without nulls on the JVM though. Scala does something very similar to Haskell's Maybe. (Although for interoperability with Java it can deal with nulls if you insist.)
Is the inclusion of this monstrosity in a standard library more evidence that null references are a misfeature? A explicit construction like Maybe<T> seems so much of a better idea.