Term "Collections". The overall term for Java's data structure facilities is Collections, a term is is an alternative to the more common Data Structures. In addition to describing general data structure facilities, java.util.Collection is the name of an interface and java.util.Collections is the name of a class containing many data structure utility methods. Three different names would have been better.
Most data structure textbooks give students the impression that professional programmers implement basic data structures, such as linked lists, or write their own sort methods.
This is completely false! Many standard data structures and algorithms have already been written and are available in Java. Professional programmers use these library classes as building blocks for their application specific structures.
Textbooks give this distorted view because their emphasis is on understanding how data structures are build using only pointers/references and arrays. It's an excellent exercise and is necessary to becoming a good programmer. But textbooks often fail to emphasize the predefined data structure libraries that programmers actually use.
You will, of course, often write data structures that reflect the nature of your problem, but use the library versions for the basic elements. And you will have plenty of opportunities to use this basic knowledge to to beyond the basics.
To be a productive programmer, your first choice must be to use standard library data structures. In Java this means using the Collection classes and interfaces. If you can't find what you need, try one of the Alternative Data Structures libraries.
You will always have to write some of your own data structures, but you can program faster, and produce more robust and readable programs by building on the work of others.
No primitive types. Collections data structures work only with objects, not primitive values. You can use the wrapper classes (somewhat more convenient in Java 5), use alternate libraries, or write your own class equivalents. The creation and garbage collection of these extra objects may add substantial overhead. There are several non-Sun implementations of data structures using primitives.
Pre-Java 5 Downcasting from
In versions before Java 5 a problem is that an object returned
from a data structure must be downcast to whichever type you want.
This was a constant annoyance, and was a form of weak-typing, which allowed
run-time type mismatches that should be caught at compile time.
Generic types, as in C++ templates, are in Java 5
to enforce typing and remove the need for explicit casting.
For compatibility the older versions of the classes also work.
Missing facilities Many obvious additions can be found in Alternative Data Structures.