There are several differences between HashMap
and Hashtable
in Java:
Hashtable
is synchronized, whereas HashMap
is not. This makes HashMap
better for non-threaded applications, as unsynchronized Objects typically perform better than synchronized ones.
Hashtable
does not allow null
keys or values. HashMap
allows one null
key and any number of null
values.
One of HashMap's subclasses is LinkedHashMap
, so in the event that you'd want predictable iteration order (which is insertion order by default), you could easily swap out the HashMap
for a LinkedHashMap
. This wouldn't be as easy if you were using Hashtable
.
Since synchronization is not an issue for you, I'd recommend HashMap
. If synchronization becomes an issue, you may also look at ConcurrentHashMap
.
From the Java Tutorial:
Nested classes are divided into two categories: static and non-static. Nested classes that are declared static are simply called static nested classes. Non-static nested classes are called inner classes.
Static nested classes are accessed using the enclosing class name:
OuterClass.StaticNestedClass
For example, to create an object for the static nested class, use this syntax:
OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();
Objects that are instances of an inner class exist within an instance of the outer class. Consider the following classes:
class OuterClass {
...
class InnerClass {
...
}
}
An instance of InnerClass can exist only within an instance of OuterClass and has direct access to the methods and fields of its enclosing instance.
To instantiate an inner class, you must first instantiate the outer class. Then, create the inner object within the outer object with this syntax:
OuterClass outerObject = new OuterClass()
OuterClass.InnerClass innerObject = outerObject.new InnerClass();
see: Java Tutorial - Nested Classes
For completeness note that there is also such a thing as an inner class without an enclosing instance:
class A {
int t() { return 1; }
static A a = new A() { int t() { return 2; } };
}
Here, new A() { ... }
is an inner class defined in a static context and does not have an enclosing instance.
Best Answer
I've had both installed together without problems. In fact I had the JDT, CDT, PyDev all working side by side sometimes I even had projects containing code from all three languages and it all worked just dandy. All the bits that were supposed to be ready for the others were provided you order your builders correctly. (I had an API implemented in C++ with support for Java, Python and C++ all in the same project).
However since you already have your set-up running just the way you want I would strongly recommend that you would backup your installation of Eclipse AND your .metadata folder in your workspace (I usually just zip the whole workspace when I tinker with Eclipse like that)
Then you can just get in your plugin manager and get the JDT plugin to install itself from the update site. Frankly I do not anticipate that you will get any problems. You can use different workspaces to separate CDT and Java but unless you really need this clear separation I would recommend that you do everything under the same workspace. Switching workspace in Eclipse pretty much means you have to launch a new instance of it with all the loading and waiting this implies.
Mixing language types in the same project might require that you tinker with the eclipse project files manually. Sometimes the gui will not offer you to have multiple aspects for the same projects. Otherwise switching from one language to the other is transparent. You can switch perspective or you can build your own perspective with just the views you want. Again there was no problem mix-matching views from CDT with views from other languages/plugins.
This is probably the biggest strength of Eclipse, Provide a unified development environment regardless of the work you are doing. This being said, not all language are supported equally, good news for you is that the Java plugin is a lot more rich and mature than the CDT.