|
|
Optimize with a SATA RAID Storage Solution
Range of capacities as low as $1250 per TB. Ideal if you currently rely on servers/disks/JBODs
When Java was born, the only data structure support built into the core libraries involved arrays, vectors (essentially dynamically-sized arrays), and hash tables (for key-value pairs). Support for such key data structures as balanced trees, generic bags of objects, and priority queues didn't exist, but could certainly be created. Thus, many developers added their own structures to the libraries.
In this article, we review some of those early attempts, how they evolved with Sun Microsystems' release of the Java Collections Framework, and how the Java Collections Framework is changing with the evolution of the early and later attempts at filling users' needs for data structure support.
Looking back at the initial alternative data structure collections available, Doug Lea, who serves on the faculty at the State
University of New York at Oswego, probably created the first most widely used collection (see Resources). It (collections) was released into the public domain in the fall of 1995.
At the time, many early Java developers were transitioning from the C++ world. These developers had worked with the Standard Template Library (STL) and found the original Java core libraries severely lacking in algorithm and data structure support. Having come from the C++ and STL worlds, a company called ObjectSpace decided to port the STL to Java. The resulting Java Generic Library (JGL) was released in June 1996, but Sun's legal department didn't like the name. ObjectSpace consequently renamed it the Generic Collection Library for Java, but the JGL acronym stuck.
Though rather large, JGL was a popular offering for some time. Through various marketing efforts, ObjectSpace convinced 10 IDE tool vendors to package the library with their tools. ObjectSpace claimed their user base was more than 100,000. (At the time, the number of Java developers was nowhere near seven figures yet.) JGL became a de facto standard during Java's early days.
After a few revisions, including dividing a single package into subpackages and integrating with ObjectSpace's Voyager Object Request Broker (ORB) product, JGL 3.1 was released in the fall of 1997.
With the impending introduction of J2SE (Java 2 Platform, Standard Edition) 1.2 and its changes to the world of data structure
support, Doug Lea abandoned his collections package and started work on a second library of utility classes. This new package was designed to improve concurrent or multithreaded
access to various data structures. Released in July 1998, these classes were called util.concurrent and offered locking, pooling, and concurrent access support (see Resources).
J2SE 1.2 was released in December 1998 and included a set of classes called the Java Collections Framework for manipulating data collections. Early comparisons pitted JGL against the Collections Framework (see Resources), even though the two were meant to serve different purposes—JGL was an STL replacement, and the Collections Framework was not. Former C++ developers tended to use JGL because JGL's sheer size required a steep learning curve that came more natural to those already familiar with the STL. JGL had approximately 130 classes and interfaces while the Collections Framework was about 20 percent of that size.