Java SCJP 6 Exam Download
Java SCJP 6 Exam Details

Chapter 9 

java.util package

·         A collection (a.k.a bag or multiset) allows a group of objects to be treated as a single unit. Arbitrary objects can be stored, retrieved and manipulated as elements of these collections.

·         Collections Framework presents a set of standard utility classes to manage such collections.

1.        It contains ‘core interfaces’ which allow collections to be manipulated independent of their implementations. These interfaces define the common functionality exhibited by collections and facilitate data exchange between collections.

2.        A small set of implementations that are concrete implementations of the core interfaces, providing data structures that a program can use.

3.        An assortment of algorithms to perform various operations such as, sorting and searching.

·         Collections framework is interface based, collections are implemented according to their interface type, rather than by implementation types. By using the interfaces whenever collections of objects need to be handled, interoperability and interchangeability are achieved.

·         By convention each of the collection implementation classes provide a constructor to create a collection based on the elements in the Collection object passed as argument. By the same token, Map implementations provide a constructor that accepts a Map argument. This allows the implementation of a collection (Collection/Map) to be changed. But Collections and Maps are not interchangeable.

·         Interfaces and their implementations in Java 1.2

Collection

                |

                |__ Set (no dupes, null allowed based on implementation) à  HashSet

                |                |

                |                |__ SortedSet (Ordered Set) à TreeSet

                |

                |__ List (ordered collection, dupes OK) à Vector, ArrayList, LinkedList

 Map (key-value pairs, null allowed based on implementation) à HashTable, HashMap

       |

               |__ SortedMap (Ordered Map) à TreeMap

·         Classes that implement the interfaces use different storage mechanisms.

1.        Arrays

Indexed access is faster. Makes insertion, deletion and growing the store more difficult.

2.        Linked List

Supports insertion, deletion and growing the store. But indexed access is slower.

3.        Tree

Supports insertion, deletion and growing the store. Indexed access is slower. But searching is faster.

4.        Hashing

Supports insertion, deletion and growing the store. Indexed access is slower. But searching is faster.

However, requires the use of unique keys for storing data elements.

·         Some of the operations in the collection interfaces are optional, meaning that the implementing class may choose not to provide a proper implementation of such an operation. In such a case, an UnsupportedOperationException is thrown when that operation is invoked.

·         Sorting in SortedSets and SortedMaps can be implemented in two ways.

1.        Objects can specify their natural order by implementing Comparable interface. Many if the standard classes in Java API, such as wrapper classes, String, Date and File implement this interface. This interface defines a single method:

int compareTo(Object o) – returns negative, zero, positive if the current object is less than, equal to or greater than the specified object.

In this case a natural comparator queries objects implementing Comparable about their natural order. Objects implementing this interface can be used:

·         As elements in a sorted set.

·         As keys in sorted map.

·         In lists which can be sorted automatically by the Collections.sort() method.

2.        Objects can be sorted by specific comparators, which implement Comparator interface. This interface defines the following method:

int compare(Object o1, Object o2) – returns negative, zero, positive if the first object is less than, equal to or greater than the second object. It is recommended that its implementation doesn’t contradict the semantics of the equals() method.

Specific Comparators can be specified in the constructors of SortedSets and SortedMaps.

·         All classes provide a constructor to create an empty collection (corresponding to the class). HashSet, HashMap, HashTable can also be specified with an initial capacity as well as a load factor (the ratio of number of elements stored to its current capacity). Most of the time, default values provide acceptable performance.

·         A Vector, like an array, contains items that can be accessed using an integer index. However, the size of a Vector can grow and shrink as needed to accommodate adding and removing items after the Vector has been created.

·         Vector (5,10) means initial capacity 5, additional allocation (capacity increment) by 10.

·         Stack extends Vector and implements a LIFO stack. With the usual push() and pop() methods, there is a peek() method to look at the object at the top of the stack without removing it from the stack.

·         Dictionary is an obsolete class. HashTable extends dictionary. Elements are stored as key-value pairs.

·         Vector and HashTable are the only classes that are thread-safe.

·         ArrayList (does what Vector does), HashMap(does what HashTable does), LinkedList and TreeMap are new classes in Java 1.2

·         In Java 1.2, Iterator duplicates the functionality of Enumeration. New implementations should consider Iterator.

·         Collections is a class, Collection is an interface.

·         Collections class consists exclusively of static methods that operate on or return collections.

·         Sorting and Searching algorithms in the Collections class.

static int binarySearch(List list, Object key)

static void fill(List list, Object o)

static void shuffle(List list, Object o)

static void sort(List list)

·         Factory methods to provide thread-safety and data immutability. These methods return synchronized (thread-safe) / immutable collections from the specified collections.

List safeList = Collections.synchronizedList(new LinkedList());

SortedMap fixedMap = Collections.unmodifiableSortedMap(new SortedMap());

·         Constants to denote immutable empty collections in the Collections class:

EMPTY_SET, EMPTY_LIST and EMPTY_MAP.

·         Collections class also has the following methods:

·         The class Arrays, provides useful algorithms that operate on arrays. It also provides the static asList() method, which can be used to create List views of arrays. Changes to the List view affects the array and vice versa. The List size is the array size and cannot be modified. The asList() method in the Arrays class and the toArray() method in the Collection interface provide the bridge between arrays and collections.

Set mySet = new HashSet(Arrays.asList(myArray));

String[] strArray = (String[]) mySet.toArray();

·         All concrete implementations of the interfaces in java.util package are inherited from abstract implementations of the interfaces. For example, HashSet extends AbstractSet, which extends AbstractCollection. LinkedList extends AbstractList, which extends AbstractCollection. These abstract implementations already provide most of the heavy machinery by implementing relevant interfaces, so that customized implementations of collections can be easily implemented using them.

·         BitSet class implements a vector of bits that grows as needed. Each component of the bit set has a boolean value. The bits of a BitSet are indexed by nonnegative integers. Individual indexed bits can be examined, set, or cleared. One BitSet may be used to modify the contents of another BitSet through logical AND, logical inclusive OR, and logical exclusive OR operations.

By default, all bits in the set initially have the value false. A BitSet has a size of 64, when created without specifying any size.

·         ConcurrentModificationException exception (extends RuntimeException) may be thrown by methods that have detected concurrent modification of a backing object when such modification is not permissible.

For example, it is not permssible for one thread to modify a Collection while another thread is iterating over it. In general, the results of the iteration are undefined under these circumstances. Some Iterator implementations (including those of all the collection implementations provided by the JDK) may choose to throw this exception if this behavior is detected. Iterators that do this are known as fail-fast iterators, as they fail quickly and cleanly, rather that risking arbitrary, non-deterministic behavior at an undetermined time in the future.

Java SCJP 6 Exam Download
Java SCJP 6 Exam Details

Previous                                                   Contents                                                         Next