TL;DR: Apart from the legal/business issues others already mentioned, there are indeed technical limitations. Roughly speaking, creating a reasonably good JVM is harder than a reasonably good C compiler. So while theoretically possible, many ports are not created simply due to the effort required.
So what are the challenges? There are at least three important elements of a working Java implementation: support for parsing and compiling the language itself, implementing the standard library, and making the JVM which offers an environment in which compiled applications run.
As for the language, Java has lots of features which C lacks, such as object orientation, lots of validation enforced by the language spec (array bounds checking, bytecode validation before classes are loaded, etc.), a security manager, run-time class loading, a memory model which says quite precisely how multi-threaded code is supposed to behave, and some other obscure features which many develops don't even realize are there but which the language spec describes in great detail. All this causes different Java implementations to be much more similar to each other in terms of program behavior than different C compilers, but it comes at the cost of having to understand and implement lots and lots of features.
Then, there is the standard library which is also quite rich. Most of it is written in Java but there is also some native code used either for performance reasons or because the library works at a low level which is not available directly from pure Java were it not for the libraries (for example the low-level concurrency code).
And finally there is the JVM which is one heck of a monster. It performs lots of operations which are very complex to implement and even harder to implement correctly: garbage collection, just-in-time compilation, class loading and unloading, interfacing with native code while still preserving the JVM's integrity. Have a look at A JVM does that? for a partial list. Implementing all of this while keeping high performance is a very difficult task and there are very few people actually capable of doing it.
Apart from the complexity of implementation, there are also some performance costs. While Java programs can be really fast nowadays, this is possible only thanks to lots of very smart tricks implemented by the JVM. Implementing a JVM without there optimizations would make all programs run slow and thus make the whole port rather pointless. There is also some memory overhead which is hard to avoid. This is not a big problem for a PC or server but for more restricted environments it is. There is also a lot of data that the JVM itself needs: the whole complex standard library. Or the Unicode database which is at least several megabytes in size if I'm not mistaken.
Of course if it is not so easy to make a JVM for a new platform, it is also about as hard to make a transpiler or something that compiles Java to native binaries, as the binaries effectively have to contain the JVM or large parts thereof.
In Java 9, the main focus was modularization which means that for the first time your hello world program might not need to include 50 MB of libraries just for the JVM to start. This is an important step in the right direction but there is still a long way to go before real Java can run in as restricted environments as C. J2ME is actually just a subset of the full Java stack.