Between .NET and the JVM is a much wider gulf than I had imagined. Switching from C# to Clojure has meant 3 changes: imperative to functional, non-lisp to lisp and .net to jvm.
The switch from imperative to functional is a recurring theme on this blog. The reasons for switching to a Lisp will be the subject of another post (maybe posts). Switching platforms was incidental and that made it all the harder.
C# and Java are similar, but the programmers think differently. If you find yourself switching from one platform to the other, it may go more smoothly if you are aware of the differences.
.NET is punctuated equilibrium. Java is incremental evolution.
On the .NET platform, from time to time Microsoft releases a new version with new features and this becomes the new standard. Cases where Microsoft says that the new technology is an alternative, not a replacement, only mean that the transition will go a little slower.
To be a .NET developer is to be a Visual Studio developer. It is the IDE. It is also the build tool and dependency manager. Changes to the IDE are changes to the platform and changes to the platform have to be supported by the IDE to be adopted.
In the Java world, new practices come more from ideas, libraries and tools coming from the community than from the company controlling the language (first Sun, now Oracle). When a library becomes standard, it is because the community has found it useful. There are several different IDEs, and there are developers who don't use IDEs at all.
Living in the .NET world is long periods of comfort interrupted by periodic shocks. Visual Studio is a great tool, there is a standard way to do things and there is great support for the standard. Each .NET release is an epochal change from the prior version. The new versions tend to be great, but they are sudden, and often huge, changes.
Based on what I can see on the outside, it looks like it is the responsibility of each organization that uses the JVM to determine the right way to do things. It means working hard to keep up with many different projects each taking its own approach to solving an individual program.
If you work on the JVM, you have to spend more time thinking about your tools, but if you work hard to keep up do you avoid abrupt changes. Not having lived through it, I can't say, but I sure hope so!