Section 12.2
List and Set Classes
IN THE PREVIOUS SECTION, we looked at the general properties
of collection classes in Java. In this section, we look at some specific collection
classes and how to use them. These classes can be divided into two
categories: lists and sets. A list consists of a sequence
of items arranged in a linear order. A list has a definite order, but is not necessarily
sorted into ascending order. A set is a collection that has no duplicate entries.
The elements of a set might or might not be arranged into some definite order. As with
all of Java's collection classes, the items in a list or set are of type Object.
The ListArray and LinkedList Classes
There are two obvious ways to represent a list: as a dynamic array and as
a linked list. We've encountered these already in Sections 8.3 and
11.2. Both of these options are available in generic
form as the collection classes java.util.ListArray and java.util.LinkedList. That is,
a ListArray represents an ordered sequence of objects stored in an array that will
grow in size as new items are added, and a LinkedList represents an ordered sequence
of objects stored in nodes that are linked together with pointers. Both of these
classes implement an interface java.util.List, which specifies operations that
are available for all lists.
Both list classes support the basic list operations, and an abstract data type is
defined by its operations, not by its representation. So why two classes? Why not a
single List class with a single representation? The problem is that there is
no single representation of lists for which all list operations are efficient. For
some operations, linked lists are more efficient than arrays. For others, arrays are
more efficient. In a particular application of lists, it's likely that only a few
operations will be used frequently. You want to choose the representation for which
the frequently used operations will be as efficient as possible.
Broadly speaking, the LinkedList class is more efficient in applications where
items will often be added or removed at the beginning of the list or in the middle of the list.
In an array, these operations require moving a large number of items up or down one
position in the array, to make a space for a new item or to fill in the hole left by
the removal of an item. In a linked list, nodes can be added or removed at any position
by changing a few pointer values. The ArrayList class is more efficient when
random access to items is required. Random access means
accessing the n-th item in the list, for any integer n. This is trivial for an array,
but for a linked list it means starting at the beginning of the list and moving from
node to node along the list for n steps. Operations that can be done efficiently for
both types of lists include sorting and adding an item at the end of the list.
All lists implement the Collection methods discussed in the
previous section, including size(), isEmpty(),
add(Object), remove(Object), and clear(). The
add(Object) method adds the object at the end of the list. The remove(Object)
method involves first finding the object, which is not very efficient for any list
since it involves going through the items in the list from beginning to end until the
object is found. The List interface adds some methods for accessing list
items according to their numerical positions in the list. For an object, list,
of type List, these methods include:
- list.get(index) -- returns the Object
at position index in the list, where index is an integer. Items
are numbered 0, 1, 2, ..., list.size()-1. The parameter must be in this
range, or an IndexOutOfBoundsException is thrown.
- list.set(index,obj) -- stores an object obj
at position number index in the list, replacing the object that was there
previously. This does not change the number of elements in the list or move any
of the other elements.
- list.add(index,obj) -- inserts an object obj
into the list at position number index. The number of items in the list
increases by one, and items that come after position index move up one
position to make room for the new item. The value of index can be
in the range 0 to list.size(), inclusive.
- list.remove(index) -- removes the object at
position number index. Items after this position move up one space in the
list to fill the hole.
- list.indexOf(obj) -- returns an int
that gives the position of obj in the list, if it occurs. If it does not
occur, the return value is -1. If obj occurs more than once in the
list, the index of the first occurrence is returned.
These methods are defined in both the ArrayList class and in the LinkedList
class, although they are only efficient for ArrayLists.
The LinkedList class adds a few additional methods, which are not defined
for an ArrayList. If linkedlist is an object of type LinkedList,
then
- linkedlist.getFirst() -- returns the Object
that is the first item in the list. The list is not modified.
- linkedlist.getLast() -- returns the Object
that is the last item in the list. The list is not modified.
- linkedlist.removeFirst() -- removes the first item
from the list, and returns that Object as its return value.
- linkedlist.removeLast() -- removes the last item
from the list, and returns that Object as its return value.
- linkedlist.addFirst(obj) -- adds the Object, obj,
to the beginning of the list.
- linkedlist.addLast(obj) -- adds the Object, obj,
to the end of the list. (This is exactly the same as linkedlist.add(obj) and is apparently
defined just to keep the naming consistent.)
These methods are apparently defined to make it easy to use a LinkedList as
if it were a stack or a queue. (See Section 11.3.) For
example, we can use a LinkedList as a queue by adding items onto one
end of the list (using the addLast() method) and removing them from the
other end (using the removeFirst() method).
If list is an object of type List, then the method
list.iterator(), defined in the Collection interface,
returns an Iterator that can be used to traverse the list from
beginning to end. However, for Lists, there is a special type
of Iterator, called a ListIterator, which offers additional
capabilities. The method list.listIterator() returns a ListIterator
for list.
A ListIterator has the usual Iterator methods
hasNext() and next(), but it also has methods hasPrevious()
and previous() that make it possible to move backwards in the list.
To understand how these work, its best to think of an iterator as pointing
to a position between two list elements, or at the beginning or
end of the list. In this diagram, the items in a list are represented by squares,
and arrows indicate the possible positions of an iterator:
If iter is a ListIterator(), iter.next() moves the
iterator one space to the right along the list and returns the item that the iterator passes
as it moves. The method iter.previous() moves the iterator one space
to the left along the list and returns the item that it passes. The method
iter.remove() removes an item from the list; the item that is removed is the item that
the iterator passed most recently in a call to either iter.next() or iter.previous().
There is also a
method iter.add(Object) that adds the specified object to the list
at the current position of the iterator. This can be between two existing
items or at the beginning of the list or at the end of the list.
(By the way, the lists that are used in the LinkedList class are
doubly linked lists. That is, each node in the
list contains two pointers -- one to the next node in the list and one to
the previous node. This makes it possible to implement effeciently
both the next() and previous() methods of a ListIterator.
Also, to make the addLast() and getLast() methods of a LinkedList
efficient, the LinkedList class includes an instance variable that points
to the last node in the list.)
As an example of using a ListIterator, suppose that we want to maintain a list of items that
is always sorted into increasing order. When adding an item to the list,
we can use a ListIterator to find the position in the list
where the item should be added. The idea is to start at the beginning
of the list and to move the iterator forward past all the items that
are bigger than the item that is being inserted. At that point, the
iterator's add() method can be used to insert the item at its
correct position in the list. In order to say
what it means for one item to be "bigger" than another, we assume
that the items in the list implement the Comparable interface
and define the compareTo() method. (This interface was
discussed in the previous section.)
Here is a method that will do this:
static void orderedInsert(List list, Comparable newItem) {
// Precondition: The items in list are sorted into ascending
// order, according to the compareTo method.
// newitem.compareTo(item) must be defined for
// each item in the list.
//
// Postcondition: newItem has been added to the list in its
// correct position, so that the list is still
// sorted into ascending order.
ListIterator iter = list.listIterator();
// Move the iterator so that it points to the position where
// newItem should be inserted into the list. If newItem is
// bigger than all the items in the list, then the while loop
// will end when iter.hasNext() becomes false, that is, when
// the iterator has reached the end of the list.
while (iter.hasNext()) {
Object item = iter.next();
if (newItem.compareTo(item) <= 0) {
// newItem should come BEFORE item in the list.
// Move the iterator back one space so that
// it points to the correct insertion point,
// and end the loop.
iter.previous();
break;
}
}
iter.add(newItem);
} // end orderedInsert()
Since the parameter in this method is of type List, it can be applied
to both ArrayLists and LinkedLists, and it will be about equally
efficient for both types of lists. You would probably find it easier to write
an orderedInsert method using array-like indexing with the methods
get(index) and add(index,obj). However, that method would
be horribly inefficient for LinkedLists because get(index) is
so inefficient for such lists. You can find a program that tests
this method in the file ListInsert.java.
Sorting
Sorting a list is a fairly common operation, and there should really be a
sorting method in the List interface. For some reason, there is not,
but methods for sorting Lists are available as static
methods in the class java.util.Collections. This class contains
a variety of static utility methods for working with collections. The command
Collections.sort(list);
can be used to sort a list into ascending order. The items in the list
must implement the Comparable interface. This method will work, for
example, for lists of Strings. If a Comparator is provided
as a second argument:
Collections.sort(list,comparator);
then the comparator will be used to compare the items in the list.
As mentioned in the previous section, a Comparator is an object
that defines a compare() method that can be used to compare
two objects. We'll see an example of using a Comparator in
Section 4.
The Collections class has at least two other useful methods
for modifying lists. Collections.shuffle(list) will rearrange
the elements of the list into a random order. Collections.reverse(list)
will reverse the order of the elements, so that the last element is moved
to the beginning of the list, the next-to-last element to the second position,
and so on.
Since an efficient sorting method is provided for Lists, there is
no need to write one yourself. You might be wondering whether there is an
equally convenient method for standard arrays. The answer is yes.
Array-sorting methods are available as static methods in the class
java.util.Arrays. The command:
Arrays.sort(A);
will sort an array, A, provided either that the base type of
A is one of the primitive types (except boolean) or that A is an array
of Objects that implement the Comparable interface.
You can also sort part of an array. This is important since arrays
are often only "partially filled." The command:
Arrays.sort(A,fromIndex,toIndex);
sorts the elements A[fromIndex], A[fromIndex+1], ..., A[toIndex-1]
into ascending order. You can use Arrays.sort(A,0,N) to sort
a partially filled array which has elements in the first N positions.
Java does not support generic programming for primitive types.
In order to implement the command Arrays.sort(A), the Arrays
class contains eight methods: one method for arrays of Objects and
one method for each of the primitive types byte, short, int,
long, float, double, and char.
The TreeSet and HashSet Classes
A set is a collection of Objects in which no object occurs
more than once. Objects obj1 and obj2 are considered
to be the same if obj1.equals(obj2) is true, as discussed in
the previous section. Sets implement all the general Collection
methods, but do so in a way that ensures that no element occurs twice
in the set. For example, if set is an object of type Set,
then set.add(obj) will have no effect on the set if obj is
already an element of the set. Java has two classes that implement the
Set interface: java.util.TreeSet and java.util.HashSet.
In addition to being a Set, a TreeSet has the property
that the elements of the set are arranged into ascending sorted order.
An Iterator for a TreeSet will always visit the elements
of the set in ascending order.
A TreeSet cannot hold arbitrary objects, since
there must be a way to determine the sorted order of the objects it contains.
Ordinarily, this means that the objects in a TreeSet should implement
the Comparable interface and that obj1.compareTo(obj2) should
be defined in a reasonable way for any two objects obj1 and obj2
in the set. Alternatively, a Comparator can be provided as a parameter
to the constructor when the TreeSet is created. In that case, the
Comparator will be used to compare objects that are added to the set.
In the implementation of a TreeSet, the elements are stored in
something like a binary sort tree. (See Section 11.4.)
The actually type of tree that is used is balanced in
the sense that all the leaves of the tree are at about the same distance from the
root of the tree. The number of operations required to find an item in a sorted tree
is the same as the distance from the root of the tree to the item. Using a balanced
tree ensures that all items are as close to the root as possible. This makes
finding an item very efficient. Adding and removing elements are equally efficient.
The fact that a TreeSet sorts its elements and removes duplicates
makes it very useful in some applications. In Section 10.3,
I presented a program, WordList.java, that
reads all the words in a file and outputs a list of the words it found. The list
is sorted and duplicates have been removed. In that program, I used a linked list to
store the words and had to write a subroutine to make sure that the list was
sorted and contained no duplicates. By using a TreeSet instead of a list,
that part of the programming is taken care of automatically. An algorithm for
the program, using a TreeSet, would be:
TreeSet words = new TreeSet();
while there is more data in the input file:
Let word = the next word from the file.
words.add(word);
Iterator iter = words.iterator();
while (iter.hasNext()):
Write iter.next() to the output file.
If you would like to see a complete, working program, you can find it
in the file WordListWithTreeSet.java.
As another example, suppose that coll is any Collection of
Strings (or any other type for which compareTo() is properly
defined). We can use a TreeSet to sort the items of coll and
remove the duplicates simply by saying:
TreeSet set = new TreeSet();
set.addAll(coll);
The second statement adds all the elements of the collection to the
set. Since it's a Set, duplicates are ignored. Since it's a
TreeSet, the elements of the set are sorted. If you would like
to have the data in some other type of data structure, it's easy to copy the
data from the set. For example, to place the answer in an ArrayList,
you could say:
TreeSet set = new TreeSet();
set.addAll(coll);
ArrayList list = new ArrayList();
list.addAll(set);
Now, in fact, every one of Java's collection classes has a constructor
that takes a Collection as an argument. All the items in that
Collection are added to the new collection when it is created.
So, new TreeSet(coll) creates a TreeSet
that contains the same elements as the Collection, coll.
This means that we can abbreviate the four lines in the above example
to the single command:
ArrayList list = new ArrayList( new TreeSet(coll) );
This makes a sorted list of the elements of coll with no duplicates.
A nice example of the power of generic programming. (It seems, by the way,
there is no equally easy way to get the list with duplicates. To do
this, we would need something like a TreeSet that allows duplicates.
The C++ programming language has such a thing and refers to it as a
multiset. The Smalltalk language has something
similar and calls it a bag. Java, for the time
being at least, lacks this data type.)
A HashSet stores its elements in a hash table,
a type of data structure that I will discuss in the next section.
The operations of finding, adding, and removing elements are implemented very
efficiently in hash tables, even more so than for TreeSets. The elements
of a HashSet are not stored in any particular order. An Iterator
for a HashSet will visit its elements in what seems to be a completely
arbitrary order, and it's possible for the order to change if a new element is
added. Because the elements of a HashSet are not ordered, they do
not have to implement the Comparable interface. Use a HashSet
instead of a TreeSet when the elements it contains are not comparable,
or when the order is not important, or when the small advantage in efficiency
is important.
