====
Java has very few original features. However, it did serve as a sort of 'feature aggregator', where it pulled in a very large pile of features from other languages and housed them all under one roof.
What I (vaguely) remember about Java from the early days as being it's (other) main advantages were:
(1) incredibly easy networking (compare sockets with C for example)
(2) applets (yes they suck(ed), but no other language had that browser adoption)
(3) it wasn't Microsoft (not such a big deal now, but back in the day Microsoft were a lot more aggressive)
(4) it was open(ish) (you could look at the library code to figure out how it was doing stuff) (compare with Visual Basic where everything either magically works or magically doesn't)
(5) Threads (compare again to semaphores)
(6) Free (as in beer)
In some cases, such as early Java, I think a feature most people don't really take into account is not what was put into the language, but what was left out. By hiding pointers behind the curtain, it made the language a lot easier. Easier to write, and easier to read. Even then it had its wrinkles, the people I know who were uber-productive in Java tended to use a small subset of the languages features.
Over the years of course feature creep has slipped in, so it now has bits of perl (regex) and bits of C++ (templates/generics). A lot more of the base code is a lot uglier than it used to be....
====
As for Lisp, I don't really buy the argument that lack of a good IDE held it back. I think the following reasons are more to the point:
A) butt ugly syntax (I'm talking about the random lengths of indents, not the ()s - to understand why this is bad, go learn you some usability)
B) greedy corporate interests (if the developer kit for Java had cost $10,000 no one would ever use it either) (early on)
C) language fracturing and speciation (there are too many 'little lisps' for any one of them to gain momentum) (later on)
D) lack of well written textbooks (compare to the veritable explosion of books for Java in its early days. Back when I was actually interested in Lisp I used to pick up books on it, and they'd invariably spend the first 2 pages showing some vague equivalency to lambda calculus and then it seemed as though they felt their teaching duty was done)
speaking of the lambdas...
E) programmers got better at naming variables and functions (having anonymous functions may be a neat party trick, but nowdays when we put on our big boy pants we like to name stuff)
F) missed the OO boat because they were too caught up in their own cleverness (early OO implementations in Lisp were butt ugly and broken (didn't do encapsulation and/or inheritance well)).
You may argue (as the author of the original article does) that currently Lisp does wonderful OO, but you have the same problem as say Java does, overcoming the slowness myth(s).
I wonder if it is possible to predict the critical junctures where the myths about a language solidify. In any case, it doesn't help to make a new lisp with more/better/faster features (in an attempt to create new myths), because that just feeds the confusion (see point C above)
edit for irony: missed a )