CE203 - Application Programming
Part 3
Autumn 2015
CE203 Part 3
1
Sorted Sets 1
The SortedSet interface extends the Set interface by adding
methods that can be applied efficiently to sets whose
elements are stored in order. These extra methods are:
public
public
public
public
public
public
Autumn 2015
Object first();
Object last();
SortedSet headSet(Object o);
SortedSet tailSet(Object o);
SortedSet subSet(Object o1, Object o2);
Comparator comparator();
CE203 Part 3
2
Sorted Sets 2
The iterator for a sorted set will visit the elements in
ascending order.
The first method returns the smallest element, whereas
last returns the largest element. Each of these will throw a
NoSuchElementException if the set is empty.
The headSet method returns a sorted set containing all of the
elements of the set that are less than to the object supplied as
an argument. If there are no such elements an empty set will
be returned. The tailSet method is similar but the result
contains elements greater than or equal to the argument.
Autumn 2015
CE203 Part 3
3
Sorted Sets 3
The subSet method returns a set containing all of the
elements that are greater than or equal to the first argument
and
less
than
the
second
argument.
An
IllegalArgumentException will be thrown if the first
argument is greater than the second. An empty set will be
returned if the arguments are equal.
Autumn 2015
CE203 Part 3
4
Sorted Sets 4
The sets returned by headSet, tailSet and subSet are
views of part of the original set, rather than copies, so if any
additions or removals are applied to the subset the contents of
the original set will also be changed.
Hence, for example, we could remove all elements less than
10 from a sorted set of integers using
mySet.headSet(10).clear();
Autumn 2015
CE203 Part 3
5
Sorted Sets 5
When a sorted set is created it is necessary to specify the
ordering that will be used to compare elements. The usual
choice is to use the compareTo method from the Comparable
interface. In this case all elements that are inserted into the set
must be objects of classes that implement this interface.
An alternative approach, to be used when we wish to sort
elements according to some other ordering, is to supply a
Comparator object.
The comparator method from the SortedSet interface will
return the Comparator object for the set if one has been
supplied; otherwise it will return null.
Autumn 2015
CE203 Part 3
6
The TreeSet Class 1
The TreeSet class implements the SortedSet interface
using a tree structure.
Note that if we use a set of type TreeSet or
TreeSet<Object> methods such as add, addAll, remove,
removeAll and contains can throw an exception of type
ClassCastException if the arguments are of inappropriate
types for comparisons. Wherever possible specific types such
as TreeSet<Integer> should be used so that the compiler
can check that the arguments are of the correct type.
Autumn 2015
CE203 Part 3
7
The TreeSet Class 2
The TreeSet class has four constructors.
The first constructor has no arguments and creates an
initially-empty set that will be ordered using the compareTo
method.
The second constructor has an argument of type SortedSet
and creates a set containing the same elements as its
argument, ordered using the same ordering.
Autumn 2015
CE203 Part 3
8
The TreeSet Class 3
The third constructor has an argument of type Collection
and creates a set containing all of the elements of the
argument, ordered using compareTo.
Note that a ClassCastException may be thrown if the
collection contains objects from classes that do not
implement Comparable or contains a pair of objects that
cannot be compared, for example a number and a string.
(This problem cannot arise if we used a parameterised type
that implements Comparable since the constructor for
TreeSet<T> takes an argument of type Collection<T>).
Autumn 2015
CE203 Part 3
9
The TreeSet Class 4
The fourth constructor has an argument of type Comparator
and creates an initially-empty set that will be ordered using
that comparator. If the set has type TreeSet<T> the argument
must be of type Comparator<T>.
Autumn 2015
CE203 Part 3
10
Lists 1
The List interface extends the Collection interface by
adding additional methods appropriate for use with lists.
public
public
public
public
public
public
public
public
public
public
Autumn 2015
Object get(int i);
int indexOf(Object o);
int lastIndexOf(Object o);
void add(int i, Object o);
void addAll(int i, Collection c);
Object remove(int i);
void set(int i, Object o);
List subList(int i, int j);
ListIterator listIterator();
ListIterator listIterator(int i);
CE203 Part 3
11
Lists 2
The methods indexOf and lastIndexOf behave in the same
way as already described for the Vector class; as with arrays
and vectors, indexing starts at 0.
The methods get, add, set and remove take a location as the
first argument and return, insert, replace or remove the
element at that location; if the argument is out of range an
exception of type IndexOutOfBoundsException will be
thrown; the result returned by the remove method is a
reference to the object that has been removed.
Autumn 2015
CE203 Part 3
12
Lists 3
We can of course also use the inherited add and remove
methods which take a single argument of type Object. The
former adds to the end of the list and the latter removes the
first instance.
The addAll method will insert all of the elements of the
argument collection into the list, starting at the position
specified by the first argument. The order in which the
elements are added is the order in which they would be
visited by an iterator returned by the argument’s iterator
method.
Autumn 2015
CE203 Part 3
13
Lists 4
The subList method returns a view of part of the list to
which it is applied; the portion returned by
myList.subList(i,j) will run from position i to position
j-1. An IndexOutOfBoundsException will be thrown if
either of the arguments is out of range or if i is greater than
j; an empty sub-list will be returned if i and j are equal.
Changes to the sub-list will affect the original list in a similar
way to changes to subsets of sorted sets.
Autumn 2015
CE203 Part 3
14
Lists 5
The two listIterator methods return iterators of type
ListIterator; the version without an argument will return
an iterator whose place-marker starts in front of the first
element of the list, whereas the other will return an iterator
whose place-marker is initially positioned in front of the item
whose index is specified by its argument.
The ListIterator interface extends the Iterator interface
so we can use the iterators returned by these methods in the
same way as iterators for sets; however, the ListIterator
interface provides additional methods that can be used when
traversing the list.
Autumn 2015
CE203 Part 3
15
Lists 6
There are three classes in the Java library that implement the
List interface: Vector (as already seen), ArrayList and
LinkedList .
The ArrayList class is very similar to the Vector class but
has an extra method called ensureCapacity that takes an
argument of type int and increases the capacity if it is
currently smaller than the argument. This class does not have
…elementAt methods – the methods of the List interface
can be used to perform the same tasks
For large collections the ArrayList class will perform more
efficiently than the Vector class.
Autumn 2015
CE203 Part 3
16
Lists 7
The LinkedList class provides an implementation of the
List interface using a doubly-linked list (i.e. a list in which
each cell has references to both the next and previous cells).
This class can provide more efficient insertion and removal
than the ArrayList class since items do not have to be
shifted. However, the need to locate the appropriate position
when these operations are performed means that much of this
efficiency benefit is lost if the position is near the middle of
the list.
Autumn 2015
CE203 Part 3
17
Lists 8
The LinkedList class provides six extra methods for
programming convenience (although all of their operations
can be performed using methods specified by the List
interface).
These methods are getFirst, getLast,
removeFirst and removeLast (all of which have no
argument and return a result of type Object), and addFirst
and addLast (which are void and have an argument of type
Object).
Autumn 2015
CE203 Part 3
18
Lists 9
The LinkedList class has just two constructors, one with no
argument and one with an argument of type Collection.
The latter copies the elements of the collection into the new
list in the order in which an iterator would visit them.
The ArrayList class has three constructors, two as described
above and a third which takes an initial capacity as an
argument.
Autumn 2015
CE203 Part 3
19
List Iterators 1
The ListIterator interface extends the Iterator interface
adding additional methods that can be used when traversing
lists. These methods are
public
public
public
public
public
public
Autumn 2015
boolean hasPrevious();
Object previous();
int nextIndex();
int previousIndex();
void set(Object o);
void add(Object o);
CE203 Part 3
20
List Iterators 2
A list iterator, like any other iterator, has a place-marker that
is located between two adjacent elements; we can move this
place-marker in either direction so in addition to the hasNext
and next methods there are previous and hasPrevious
methods.
The nextIndex and previousIndex methods can be used to
obtain the positions in the list of the elements on either side
of the place-marker.
Autumn 2015
CE203 Part 3
21
List Iterators 3
The add method adds an object to the list immediately in
front of the item to the right of the place-marker (i.e. the item
that would be returned if next were called); if the placemarker is at the end of the list the item will be added to the
end of the list.
Autumn 2015
CE203 Part 3
22
List Iterators 4
The set method changes the contents of the list, replacing
the item that was returned by the last call to either next or
previous by the item supplied as an argument. An exception
of type IllegalStateException will be thrown if there has
been no call to either next or previous, and also if either of
the add or remove methods has been called since the last call
to next or previous.
Autumn 2015
CE203 Part 3
23
List Iterators 5
We can make use of the set method of the ListIterator
class to write a method that replaces all the strings in a list by
upper-case versions.
public static void upperCase(List<String> l)
{ ListIterator<String> it = l.listIterator();
while (it.hasNext())
String s = it.next().toUpperCase();
it.set(s);
}
Autumn 2015
CE203 Part 3
24
The Collections Class 1
The Collections class provides a number of static methods
that can perform useful operations on collections.
These include min and max to find the smallest or largest
element in a collection and frequency, which returns the
number of occurrences of an object.
Since these methods are static we have to supply the identity
of the collection as the first argument, e.g.
int n = Collections.frequency(mySet, 7);
Integer small = Collections.min(myIntgrList);
Autumn 2015
CE203 Part 3
25
The Collections Class 2
The Collections class also provides several methods that
operate only on lists.
These include sort to sort the contents of the list into
ascending order, reverse to reverse the order of the elements
and shuffle to rearrange the elements randomly.
These methods change the contents of the list to which they
are applied and do not return a new copy, e.g.
Collections.sort(myList);
Autumn 2015
CE203 Part 3
26
The Collections Class 3
The min, max and sort methods normally use compareTo to
compare elements so the elements of the collection should be
of a class that implements Comparable. However there are
also versions that take as a second argument an object that
implements the Comparator interface allowing an ordering
other than the natural one to be used for comparison.
Assuming that a Person class has a compareTo method
based on names but if we wish to sort a list by dates of birth
we could use the code on the following slide (which assumes
that the Date class has a compareTo method).
Autumn 2015
CE203 Part 3
27
The Collections Class 4
class DOBComp implements Comparator<Person>
{ public int compare(Person p1, Person p2)
{ int x = p1.dateOfBirth().compareTo
(p2.dateOfBirth());
if (x!=0)
return x;
else
return p1.compareTo(p2);
// must not return 0 if different people
// have same date of birth
}
}
……
Collections.sort(personList, new DOBComp());
Autumn 2015
CE203 Part 3
28
The Map Interface 1
The Java Collections Framework provides a further kind of
collection. A map is a collection of pairs of entries each
comprising a key and a value. Elements of a map must have
unique keys, but there may be more than one element with
the same value.
The Map interface does not extend the Collection interface
but provides similar methods.
The interface is shown on the following slides.
Autumn 2015
CE203 Part 3
29
The Map Interface 2
public interface Map
{ public boolean isEmpty();
public int size();
public boolean containsKey(Object k);
public boolean containsValue(Object v);
public Object get(Object key);
public void clear();
public Object put(Object k, Object v);
public void putAll(Map m);
public Object remove(Object key);
// continued on next slide
Autumn 2015
CE203 Part 3
30
The Map Interface 3
// public interface Map continued
}
public
public
public
public
public
Autumn 2015
Set<Map.Entry> entrySet();
Set keySet();
Collection values();
boolean equals(Object o);
int hashCode();
CE203 Part 3
31
The Map Interface 4
The behaviour of many of the methods is similar to the
corresponding Collection methods and will not be
described here.
The get method returns the value associated with the key
supplied as an argument; null will be returned if there is no
entry with that key.
The put method will add a new entry to the map. If there
was an existing entry with the same key this will be replaced,
and its previous value returned; otherwise null will be
returned.
Autumn 2015
CE203 Part 3
32
The Map Interface 5
The argument to the remove method is a key; the value
returned will be the value in the entry that has been removed,
or null if there was no entry with that key.
The Map interface has no methods that return iterators;
however we can iterate through the contents of the map using
an iterator for the set returned by entrySet or keySet or for
the collection returned by values. These return views of the
map rather than new sets so any changes made while iterating
will alter the contents of the map. If a key or value is
removed from the collection the entry will be removed from
the map.
Autumn 2015
CE203 Part 3
33
The Map Interface 6
The values method returns an object of type Collection
rather than Set since there may be duplicate elements.
The elements of the set returned by entrySet are of type
Map.Entry. This interface has methods getKey, getValue
and setValue.
To print the contents of a map m we could use code such as
Set<Map.Entry> s = m.entrySet();
Iterator<Map.Entry> it = s.iterator();
while (it.hasNext())
{ Map.Entry e = it.next();
System.out.println(
e.getKey()+":"+e.getValue());
}
Autumn 2015
CE203 Part 3
34
The Map Interface 7
The parameterised-type version of Map uses two type
parameters, the types of the keys and of the values. If m2 is of
of type Map<Character,Integer> we could use the
following code to remove all entries whose values are
negative.
Collection<Integer> c = m2.values();
Iterator<Integer> it = c.iterator();
while (it.hasNext())
if (it.next().intValue()<0)
it.remove();
Autumn 2015
CE203 Part 3
35
The Map Interface 8
To modify the values of entries we can apply the setValue
method from Map.Entry; to replace all the negative values
in m2 with zero we could use
Set<Map.Entry<Character,Integer>> s =
m2.entrySet();
Iterator<Map.Entry<Character,Integer>> it =
s.iterator();
while (it.hasNext())
{ Map.Entry<Character,Integer> e = it.next();
if (e.getValue().intValue()<0)
e.setValue(0);
}
Autumn 2015
CE203 Part 3
36
Map Classes 1
The Java Collections framework contains two classes that
implement the Map interface, HashMap and TreeMap. These
are similar to HashSet and TreeSet and arrange the entries
according to their keys.
For efficient use of HashMap the key class should have a
suitable hashCode method. The class has four constructors:
three correspond to three of the HashSet constructors
(described earlier) and behave in the same way, and the
fourth is a constructor with an argument of type Map, which is
provided instead of the one with an argument of type
Collection.
Autumn 2015
CE203 Part 3
37
Map Classes 2
TreeMap class implements an interface called
SortedMap that extends the Map interface by defining six
methods similar to those of SortedSet; these are called
firstKey, lastKey, headMap, tailMap, subMap and
comparator. Since the class sorts the entries according to
The
their keys the methods that take objects as arguments use
these object as keys.
The class has four constructors similar to those of the
TreeSet class. In order to use TreeMap when a constructor
with a comparator argument has not been used the keys must
be of a type that implements Comparable.
Autumn 2015
CE203 Part 3
38