I wouldn't call Java especially beautiful. When I learned about Java, I thought: "Hey, everything has its place! It is clear what kind of concepts to use. Interfaces, abstract classes, classes, enums ..." and I thought it was beautiful. This was however my own limited view on programming languages at the time. In hindsight, this system was quite stunted and held me back, by forcing everything into that shape. Later I learned other languages, which include language concepts for things, which I needed to write extra files and classes for in Java. One such example: Decorators.
Java has moved on nowadays, to include concepts, which other languages have had for decades, finally coming around to it. It did "modernize" a bit, one could say. Lambda expressions, namespaces, not having to put everything in a class (how silly that would be, to still have to do that). However, that doesn't make it beautiful, because those concepts are bolted on, for backwards compatibility reasons. It is not like there has been a redesign of the language or anything. It is going a similar way C++ is or has been going. Adding new syntax. It has to go that way, because there is no good extensible concept of Java syntax. Its syntax is always only a snapshot of the current state, that says "this is what is valid syntax right now", instead of offering a flexible way to extend the language.
I want to use languages, which have incorporated concepts, which traditionally Java did not even have or use alternative concepts, which make things possible and in this way shorten my code significantly. Then I don't have to write 10000 lines for simple things.
No language, however beautiful it may be, will solve a problem of overlooked use-cases, which cannot be solved using the concepts implemented in a library or program. For me beautiful code is code, which implements the simplest concept one can think of, in the simplest way, to make all intended use-cases possible. This is what I call flexibility. It is about implementing the least amount of limitations, not hard-coding assumptions, which are not justified, but all invariants, which are necessary. Not programming oneself into a corner.