Set – This interface defines methods available to any collection without any defined sequence or ordering of the contained elements.

List – This interfaces defines behavior for collections which use a numeric index to define an element's position.

SortedSet – This interface is used to describe collections that use ‘natural ordering” to organize elements. The elements of a SortedSet must implement the interface Comparable, which defines a compareTo method. The compareTo method returns a numeric result used to organize the objects within the SortedSet.

Map has a subinterface, as well—the SortedMap. Like SortedSet, this interface is used for maps with natural ordering. The collections that implement this interface must have a way to compare keys of the elements that will indicate whether one is greater than, equal to or less than the other. The keys must implement the Comparable interface.

Pattern Use

A number of patterns figure heavily in the Collections Framework. In the general framework, there is strong use of the Prototype and Iterator patterns. The Collections class also has a pattern associated with it—the Decorator.

Prototype (see page 28): The Prototype pattern uses one object as a template or basis for the creation of a new object. Given the purpose of the collection classes, it's not surprising that they all support a copy operation clone. That copy operation returns a new copy of the current collections. All of the collection classes implement the Cloneable interface and provide a shallow copy when their clone method is called. In this case, a shallow copy means that a new collection instance is returned, but all of the internally stored elements are the same objects as those stored in the original collection.

Iterator (see page 69): All Collection implementors give you the ability to retrieve an object to easily (and generically) cycle through the elements of the collection. The Iterator pattern, too, enables simpler cycling through the elements of a collection. The Collection interface defines a method called iterator, and the List interface has a listIterator method. These methods return interface implementors that allow users to move through a collection. The Iterator interface is for forward-only navigation, and the ListIterator provides both forward and backward movement within a collection. The names are a not-so-subtle giveaway. Actually, both interfaces fall a bit short of the classic Iterator pattern, since they don't define all of the core methods—specifically, neither interface provides an explicit first method. The goal is to abstract navigational functionality from the underlying collection implementation, though. So, the central intent of these interfaces is the same as for the Iterator pattern.

Collection classes use inner classes to provide concrete Iterators. When you call iterator or listIterator, the collection creates an inner class object and returns it to the caller.

Decorator (see page 166): The Collections class uses the Decorator pattern to extend the functionality of collections by providing objects that modify the behavior of the collections without changing the collections. The class has three groups of methods that generate classes with additional capabilities. Table 6-2 shows the groups of methods and what they produce:

Calling any of the methods from these groups produces an object that enhances the capabilities of the collection that you pass in and adds to what it can do.

The Collections class actually has a set of inner classes that it uses to provide these added capabilities. So, calling synchronizedCollection will generate a wrapper object around the inner collection which will ensure that methods belonging to the Collection interface will be synchronized.

Note:

193

There's one exception to that rule. Creating a synchronized collection will not give you a synchronized iterator method—you have to manually synchronize the Iterator and ListIterator.

It's tempting to think that the methods prefixed with the word singleton represent the Singleton design pattern. However, the intent of the methods is quite different. These methods do not ensure that you can have only one instance of the collection object—they ensure that the collection can only contain a single element. Any attempt to add or remove elements from the resulting collection will result in an UnsupportedOperationException.

194