First, where to find a Java compiler. Sun Microsystems is the premier source. The Java Developers Kit (JDK) is free for download at http://java.sun.com/javase/downloads/
If you need an entire development environment, Eclipse.org or the Netbeans IDE (http://www.netbeans.org/downloads/) are worth the effort.
I've developed in both C++ and Java for many years (actually decades). They are both good tools and each has its strengths. C++ is more complex than some other programming languages; the ISO standard itself is 310 pages long. Because of its large feature set, it is difficult to fully master C++. The main advantages of C++ are speed of execution and tighter control over the machine. If those factors aren't paramont, then Java may win by default. For instance, professional games are almost always C/C++ based applications since performance and control are important to meet consumer demands.
Java is a much newer language and was designed with many advanced features from the start. For instance, C++ has its roots in C but has evolved greatly over the years. Both Java and C++ are object-oriented. However, C++ critics cite the ability of C++ to mix styles and programming disciplines rather than enforce a single style. By sheer numbers, Java has a much larger base of knowledgable developers than C++; by this alone, Java could be considered more popular and thereby preferred. In a manner of speaking, Java brought object-orientation to the masses and this has helped speed the productive development of software.
For business, Java is preferred over C++ (depending on the industry and purpose). At its root, Java is much simpler even though it has grown considerably over the years. Java is easier to parse and actually enables more advanced tools for analysis, refactoring, etc. Java is generally easier to learn and is regarded as more productive for most business purposes. It can also be more difficult to find skilled C++ workers than those with decent Java experience.
Java is also superior with cross-platform support, architecture neutrality and portability. While it is possible to write C++ to be portable, it takes considerable effort, skill and testing to pull it off successfully. If anything, small tweaks to Java code are usually all that is needed to support multiple environments. Even bytecode compatibility works fairly well with Java's runtime environment. This enables Java to run without change in Internet browsers worldwide. C++ can't claim this ability. Java bytecode can run in embedded systems, such as, cell phones. Java also has some built-in security features.
Before the hotspot/JIT compiler, Java was considered too slow to compete with C/C++ applications. At that time, Java was targeted at the desktop or GUI frontend. The hotspot compiler now narrows C++'s speed advantage enough that business is much less concerned. In fact, Java performs well enough now that server-side computing is often ruled by Java (J2EE) application servers. Clusters of computer servers (even running with different OSes and/or virtualization) can work seamlessly together to execute the same programs or protocol compatible Java applications. Interoperability has always been difficult to accomplish soley with C++ (though web services and C++ third-party libraries have finally made inroads); CORBA was the only thing C++ had going for some time but it generally sucked in the real world. Built-in threads have also contributed to Java's responsiveness.
Java offers far more workable options for system interoperability. Therefore, Java quickly finds a home where scalability becomes important. Sometimes, it is cheaper to get something to run faster or support more users by simply adding another (physical or logical) box. If things are architected properly, just throwing more resources at the trouble spot can solve a performance problem; business often likes this situation where additional money can actually take care of an issue if only to buy time until a better solution is in place. This often wasn't the case with C++ applications mostly due to interoperability constraints and architectures lacking flexibility.
More specific to the language, pointers in C have always been a debugging challenge for developers. Since C++ includes C as a subset, many of its issues continue to plague. Java avoided the use of pointers all together and insisted upon garbage collection/automatic memory management for its primary use of memory. By design, this simplified developers' mastery of Java and avoided the source of many C/C++ troubles.