Chapter 6 ■ Generics and Collections

•It is not possible to have generic exception classes; as a result, the following will not compile:

class GenericException<T> extends Throwable { } // wrong usage - compiler error

•You cannot instantiate a generic type with primitive types—in other words, List<int> cannot be instantiated. However, you can use boxed primitive types.

•The meaning of "extends" and "super" changes in the context of generics. For instance, when you say <? extends X>, you refer to all types that extend X and the type X itself.

The Collections Framework

In the first part of the chapter, we discussed generics in detail. The main use of generics is to be able to write reusable (and type-safe) data structures and algorithms. The Java library has a collections framework that makes extensive use of generics and provides a set of containers and algorithms.

In this section, we will focus on how to use the collections framework. To use collections correctly, you must understand certain related topics. To use collections like HashSet, you must override the hashCode() and equals() methods correctly. To compare objects and store them in collections, you must learn how to use Comparator, Comparable, etc. Since the collections framework uses generics extensively, you’ll revisit some of the topics related to generics in the context of the collections framework to gain a better understanding of generics.

Why Reusable Classes?

Assume that you want to write a simple program to get the extension number of a colleague in your company. For that, you have to keep a list of your colleague’s names and their extension numbers. In this simple directory you will rarely add or delete entries, but you will frequently look up entries—so the lookup should be very fast.

To implement this simple directory, you must implement a class that maps the name (a string) and an extension number (an integer or a string). You must implement methods like adding and deleting entries, looking up extension numbers given the name, etc. Additionally, you can implement methods like getting all the colleagues names, all extension numbers, etc. Implementing a class with all these features—and implementing them correctly and testing these features—takes a lot of time.

Fortunately, Java has data structures like this already implemented in the java.util package. You can just (re) use java.util.HashMap to implement your simple directory. You’ll see examples of implementations like this later, but it’s important to know that you can just use the data structures readily available in the Java library rather than implementing them yourself.

Basic Components of the Collections Framework

The Java collections framework has three main components:

•Abstract classes and interfaces: The collections framework has many abstract classes and interfaces providing general functionality. By learning them, you’ll know the offered functionality in terms of public methods.

•Concrete classes: These are the actual instances of containers that you’ll be using in the programs.

•Algorithms: The java.util.Collections implements commonly require functionality like sorting, searching, etc. These methods are generic: you can use these methods on different containers.

171

Chapter 6 ■ Generics and Collections

 Plese note that collection(s) is a generic term, while Collection and Collections are the specific APIs of the java.util package. Collections—as in java.util.Collections—is a utility class that contains only static methods. The general term collection(s) refers to a container like map, stack, queue, etc. We’ll use the term container(s) when referring to these collection(s) in this chapter to avoid confusion.

Abstract Classes and Interfaces

The type hierarchy in the java.util library consists of numerous abstract classes and interfaces that provide generic functionality. Table 6-1 and Figure 6-3 list and display a few important types in this hierarchy. We’ll cover some of these types in more detail in later sections of this chapter.

Table 6-1.  Important Abstract Classes and Interfaces in the Collections Framework

172

Chapter 6 ■ Generics and Collections

Figure 6-3.  Important high-level java.util interfaces and their inheritance relationships

Those are quite a few base types, but don’t get overwhelmed by them. You’ll see specific concrete classes and use some of these base types. We’ll only cover the Collection interface and then move on to cover concrete classes by covering each part in this collection hierarchy.

The Collection Interface

The Collection interface provides methods such as add() and remove() that are common to all containers. Table 6-2 lists the most important methods in this interface. Take a look at them before you use them.

Table 6-2.  Important Methods in the Collection Interface

Methods such as add() and remove() can fail depending on the underlying container. For example, if the container is read-only, you will not be able to add or remove elements. Apart from these methods, there are many methods in the Collection interface that apply to multiple elements in the container (Table 6-3).

173