It's not so simple to 'port' the core Java API to C++ as it
seams at first sight.
It depends on what you mean by "port". Just mimicing the
Java API exactly, mapping what Java calls references to C++
pointers, is really a problem, but it is stupid, even if you're
using garbage collection. The languages are different, and are
(or should be) used differently.
Java e.g. uses references to objects. The 'copy' of a
container doesn't copy objects, only references.
Do Java containers support copy? Java doesn't have copy
constructors. Java doesn't need or want copy constructors,
because Java uses reference semantics, not value semantics.
You can do this in C++ too, but it's stupid. It doesn't really
fit into the language. (And again, this is true even if you use
garbage collection.) What you want to do is to "adapt" the Java
API to C++, taking what's good in it, and adapting it to the C++
idiom. (For example, considered globally, Swing isn't bad at
all---it seems significantly better than the C++ GUI libraries
I've looked at. And adapting Swing to the C++ idiom could even
fix some of the minor flaws it has, e.g. by returning Dimension
as a value, rather than as a reference.)
For other things, you might not want to adopt Java directly.
The Java collections may be better than the C++ containers
(which a probably about the worst I've seen, from a design point
of view), but they still are far from known best practice.
There are libraries available (e.g. OSE) which are better than
both.