Java Collections

Framework
Shahjahan Samoon

1
 Collections
• A collection is a structured group of objects

• Java 1.2 introduced the Collections Framework

– Collections are defined in java.util
– The Collections framework is mostly about interfaces
– There are a number of predefined implementations

• Java 5 introduced generics and “genericized” all the

existing collections
– Vectors have been redefined to implement Collection
– Trees, linked lists, stacks, hash tables, and other classes are
implementations of Collection
– Arrays do not implement the Collection interfaces

2
 The Java Collections Framework
• A collection — sometimes called a container — is simply an
object that groups multiple elements into a single unit.

• Collections are used to store, retrieve, manipulate, and

communicate aggregate data.
• Typically, they represent data items that form a natural group,
such as
– a poker hand (a collection of cards),
– a mail folder (a collection of letters), or
– a telephone directory (a mapping of names to phone numbers).

3
The Java Collections Framework
A collections framework is a unified architecture for representing and
manipulating collections.
All collections frameworks contain the following:

Interfaces: These are abstract data types that represent collections.

Interfaces allow collections to be manipulated independently of the details
of their representation. In object-oriented languages, interfaces generally
form a hierarchy.

Implementations: These are the concrete implementations of the

collection interfaces. In essence, they are reusable data structures.

Algorithms: These are the methods that perform useful computations,

such as searching and sorting, on objects that implement collection
interfaces.
The algorithms are said to be polymorphic: that is, the same method can
be used on many different implementations of the appropriate collection
interface. In essence, algorithms are reusable functionality.

4
 Benefits of the JCF

Reduces programming effort:

By providing useful data structures and algorithms, the Collections Framework
frees you to concentrate on the important parts of your program rather than on
the low-level "plumbing" required to make it work.

Increases program speed and quality:

This Collections Framework provides high-performance, high-quality
implementations of useful data structures and algorithms. you'll have more time to
devote to improving programs' quality and performance.

Reduces effort to learn and to use new APIs:

In the past, each such API had a small sub-API devoted to manipulating its
collections. There was little consistency among these ad hoc collections sub-APIs,
so you had to learn each one from scratch, and it was easy to make mistakes
when using them. With the advent of standard collection interfaces, the problem
went away.

5
 Benefits of the JCF

Reduces effort to design new APIs:

Designers and implementers don't have to reinvent the wheel each time they
create an API that relies on collections; instead, they can use standard collection
interfaces.

Fosters software reuse:

New data structures that conform to the standard collection interfaces are by
nature reusable. The same goes for new algorithms that operate on objects that
implement these interfaces.

6
 The Java Collections Framework
• An array is a very useful type in Java but it has its restrictions:
• once an array is created it must be sized, and this size is fixed;
• it contains no useful pre-defined methods.
• Java comes with a group of generic collection classes that grow
as more elements are added to them, and these classes
provide lots of useful methods.
• This group of collection classes are referred to as the Java
Collections Framework.
• The classes in the JCF are all found in the java.util
package.
• Three important interfaces from this group are:
– List;
– Set;
– Map.

7
 Types of Collection
• Java supplies several types of Collection:
– Set: cannot contain duplicate elements, order is not important
– SortedSet: like a Set, but order is important
– List: may contain duplicate elements, order is important
• Java also supplies some “collection-like” things:
– Map: a “dictionary” that associates keys with values, order is not
important
– SortedMap: like a Map, but order is important
• While you can get all the details from the Java API, you are
expected to learn (i.e. memorize):
– The signatures of the “most important” methods in each interface
– The most important implementations of each interface

8
The Collections hierarchy

9
 Collections are ADTs
• Collections are one of the best-designed parts of Java, because
– They are elegant: they combine maximum power with maximum
simplicity
– They are uniform: when you know how to use one, you almost
know how to use them all
– You can easily convert from one to another

10
 The Collection interface
• Much of the elegance of the Collections Framework
arises from the intelligent use of interfaces
• The Collection interface specifies (among many other
operations):
– boolean add(E o)
– boolean contains(Object o)
– boolean remove(Object o)
– boolean isEmpty()
– int size()
– Object[] toArray()
– Iterator<E> iterator()
• You should learn all the methods of the Collection
interface--all are important

11
 The Iterator interface
• An iterator is an object that will return the elements of a
collection, one at a time
• interface Iterator<E>
– boolean hasNext()
• Returns true if the iteration has more elements
– E next()
• Returns the next element in the iteration
– void remove()
• Removes from the underlying collection the last element returned by
the iterator (optional operation)

12
 The Set interface
• A set is a collection in which:
– There are no duplicate elements (according to equals), and
– Order is not important
• interface Set<E> implements Collection, Iterable
• The methods of Set are exactly the ones in Collection
• The following methods are especially interesting:
– boolean contains(Object o) // membership test
– boolean containsAll(Collection<?> c) //subset test
– boolean addAll(Collection<? extends E> c) // union
– boolean retainAll(Collection<?> c) // intersection
– boolean removeAll(Collection<?> c) // difference
• addAll, retainAll, and removeAll return true if the receiving set
is changed, and false otherwise

13
 The List interface
• A list is an ordered sequence of elements
• interface List<E> extends Collection, Iterable
• Some important List methods are:
– void add(int index, E element)
– E remove(int index)
– boolean remove(Object o)
– E set(int index, E element)
– E get(int index)
– int indexOf(Object o)
– int lastIndexOf(Object o)
– ListIterator<E> listIterator()
• A ListIterator is like an Iterator, but has, in addition, hasPrevious and
previous methods

14
 The SortedSet interface
• A SortedSet is a Set for which the order of elements is
important
• interface SortedSet<E>
implements Set, Collection, Iterable
• Two of the SortedSet methods are:
– E first()
– E last()
• More interestingly, only Comparable elements can be added to
a SortedSet, and the set’s Iterator will return these in sorted
order
• The Comparable interface is covered in a separate lecture

15
 The Map interface
• A map is a data structure for associating keys and values
• Interface Map<K,V>
• The two most important methods are:
– V put(K key, V value) // adds a key-value pair to the map
– V get(Object key) // given a key, looks up the associated value
• Some other important methods are:
– Set<K> keySet()
• Returns a set view of the keys contained in this map.
– Collection<V> values()
• Returns a collection view of the values contained in this map

16
 The SortedMap interface
• A sorted map is a map that keeps the keys in sorted order
• Interface SortedMap<K,V>
• Two of the SortedMap methods are:
– K firstKey()
– K lastKey()
• More interestingly, only Comparable elements can be used as
keys in a SortedMap, and the method Set<K> keySet() will
return a set of keys whose iterator will return them sorted
order
• The Comparable interface is covered in a separate lecture

17
 Some implementations
• class HashSet<E> implements Set
• class TreeSet<E> implements SortedSet
• class ArrayList<E> implements List
• class LinkedList<E> implements List
• class Vector<E> implements List
– class Stack<E> extends Vector
• Important methods: push, pop, peek, isEmpty
• class HashMap<K, V> implements Map
• class TreeMap<K, V> implements SortedMap

• All of the above provide a no-argument constructor

18
 The List interface
• The List interface specifies the methods required to process
an ordered list of objects.
• Such a list may contain duplicates.

Examples of a list of objects:

– jobs waiting for a printer,
– emergency calls waiting for an ambulance
– the names of players that have won the Wimbledon tennis
tournament over the last 10 years.
• we often think of such a collection as a sequence of
objects.
• there are two implementations provided for the List
interface in the JCF.
• they are ArrayList and LinkedList.
• here we will look at the ArrayList class

19
 Using an ArrayList to store a
queue of jobs waiting for a printer

• We will represent these jobs by a series of Job ID

Strings.
• The ArrayList constructor creates an empty list:

• The stuff in angled brackets is a new feature

introduced in Java 5 that allows us to fix the type
of objects stored in a particular collection object.
• This feature is called generics.
20
 Using the interface type instead of
the implementation type

• It is considered good programming practice to declare collection objects

to be the type of the interface rather than the type of the class that
implements this collection.
• So this would be a better way to create our printQ object:

• A method that receives a printQ object, would now be declared as

follows:

• The advantage of this approach is that we can change our choice of

implementation in the future without having to change the type of the
object.

21
 List methods - add
The List interface defines two add methods for inserting
into a list
– one inserts the item at the end of the list;
– the other inserts the item at a specified position in the
list.
We wish to use the first add method
This add method requires one parameter, the object to be
added into the list:

22
 List methods - toString
All the Java collection types have a toString method
defined
So we can display the entire list to the screen:

Lists are displayed as follows.

[myLetter.doc, myFoto.jpg, results.xls,
chapter.doc]

23
List methods – add revisited
The add method is overloaded to allow an item to be
inserted into the list at a particular position.

When the item is inserted into that position, the item

previously at that particular position and all items behind it
shuffle along by one place.

This add method requires two parameters, the position into

which the object should be inserted, and the object itself.

24
 List methods – set
• If we wish to overwrite an item in the list, rather
than insert a new item into the list, we can use
the set method.
• The set method requires two parameters, the
index of the item being overwritten and the new
object to be inserted at that position.
• Let us change the name of the last job from
"chapter.doc", to "newChapter.doc".

25
 List methods – size

• Lists provide a size method to return the number

of items in the list
• So we could have renamed the last job in the
queue in the following way also:

26
 List methods – indexOf

The indexOf method returns the index of the first

occurrence of a given object within the list.
It returns -1 if the object is not in the list.
Example: finding “myFoto.jpg”

27
 List methods – remove
Items can be removed either by specifying an index or an
object.
When an item is removed, items behind this item shuffle to
the left
Example : removing "myFoto.jpg"

If we used its index, the following is required

Alternatively, we could have removed the item by referring to

it directly rather than its index:
28
 List methods – get
The get method allows a particular item to be retrieved
from the list via its index position.
The following displays the job at the head of the queue:

This would display the following:

First job is importantMemo.doc

29
 List methods – contains

The contains method can be used to check whether

or not a particular item is present in the list:

30
 List methods – isEmpty
• The isEmpty method reports on whether or not the list
contains any items
Using the enhanced ‘for’ loop with collection
classes
• The enhanced for loop can be used with the List (and Set)
implementations provided in the JCF.
• For example, here an enhanced for loop is used to iterate
through the printQ list to find and display those jobs that
end with a “.doc” extension:

31
 Sets
• set: A collection of unique values (no duplicates allowed)
that can perform the following operations efficiently:
– add, remove, search (contains)

– We don't think of a set as having indexes; we just

add things to the set in general and don't worry about order

"the"
"if" "of"
set.contains("to") "to"
"down" "from" true
"by" "she"
set.contains("be") "you" false
"in"
"why" "him"

set
32
 Set implementation
• in Java, sets are represented by Set interface in java.util

• Set is implemented by HashSet and TreeSet classes

– HashSet: implemented using a "hash table" array;

elements are stored in unpredictable order

– TreeSet: implemented using a "binary search tree";

elements are stored in sorted order

33
 Set methods
List<String> list = new ArrayList<String>();
...
Set<Integer> set = new TreeSet<Integer>(); // empty
Set<String> set2 = new HashSet<String>(list);

– can construct an empty set, or one based on a given collection

add(value) adds the given value to the set

contains(value) returns true if the given value is found in this set
remove(value) removes the given value from the set
clear() removes all elements of the set
size() returns the number of elements in list
isEmpty() returns true if the set's size is 0
toString() returns a string such as "[3, 42, -7, 15]"

34
 Set operations

addAll retainAll removeAll

addAll(collection) adds all elements from the given collection to this set
containsAll(coll) returns true if this set contains every element from given set
equals(set) returns true if given other set contains the same elements
iterator() returns an object used to examine set's contents (seen later)
removeAll(coll) removes all elements in the given collection from this set
retainAll(coll) removes elements not found in given collection from this set
toArray() returns an array of the elements in this set
35
 Sets and ordering
• HashSet : elements are stored in an unpredictable order
Set<String> names = new HashSet<String>();
names.add("Jake");
names.add("Robert");
names.add("Marisa");
names.add("Kasey");
System.out.println(names);
// [Kasey, Robert, Jake, Marisa]

• TreeSet : elements are stored in their "natural" sorted order

Set<String> names = new TreeSet<String>();
...
// [Jake, Kasey, Marisa, Robert]

• LinkedHashSet : elements stored in order of insertion

Set<String> names = new LinkedHashSet<String>();
...
// [Jake, Robert, Marisa, Kasey] 36
 The "for each" loop
for (type name : collection) {
statements;
}

• Provides a clean syntax for looping over the elements of a Set,

List, array, or other collection

Set<Double> grades = new HashSet<Double>();

...

for (double grade : grades) {

System.out.println("Student's grade: " + grade);
}

– needed because sets have no indexes; can't get element i

37
 Maps vs. sets
• A set is like a map from elements to boolean values.
– Set: Is "Marty" found in the set? (true/false)

"Marty" true
Set
false

– Map: What is "Marty" 's phone number?

"Marty" "206-685-2181"
Map

38
 keySet and values
• keySet method returns a Set of all keys in the map
– can loop over the keys in a foreach loop
– can get each key's associated value by calling get on the map

Map<String, Integer> ages = new TreeMap<String, Integer>();

ages.put("Marty", 19);
ages.put("Geneva", 2); // ages.keySet() returns Set<String>
ages.put("Vicki", 57);
for (String name : ages.keySet()) { // Geneva -> 2
int age = ages.get(age); // Marty -> 19
System.out.println(name + " -> " + age); // Vicki -> 57
}

• values method returns a collection of all values in the map

– can loop over the values in a foreach loop
– no easy way to get from a value to its associated key(s)
39
 Problem: opposite mapping
• It is legal to have a map of sets, a list of lists, etc.

• Suppose we want to keep track of each TA's GPA by name.

Map<String, Double> taGpa = new HashMap<String, Double>();
taGpa.put("Jared", 3.6);
taGpa.put("Alyssa", 4.0);
taGpa.put("Steve", 2.9);
taGpa.put("Stef", 3.6);
taGpa.put("Rob", 2.9);
...
System.out.println("Jared's GPA is " +
taGpa.get("Jared")); // 3.6

• This doesn't let us easily ask which TAs got a given GPA.
– How would we structure a map for that?
40
 Reversing a map
• We can reverse the mapping to be from GPAs to names.
Map<Double, String> taGpa = new HashMap<Double, String>();
taGpa.put(3.6, "Jared");
taGpa.put(4.0, "Alyssa");
taGpa.put(2.9, "Steve");
taGpa.put(3.6, "Stef");
taGpa.put(2.9, "Rob");
...
System.out.println("Who got a 3.6? " +
taGpa.get(3.6)); // ???

• What's wrong with this solution?

– More than one TA can have the same GPA.
– The map will store only the last mapping we add.
41
 Proper map reversal
• Really each GPA maps to a collection of people.
Map<Double, Set<String>> taGpa =
new HashMap<Double, Set<String>>();
taGpa.put(3.6, new TreeSet<String>());
taGpa.get(3.6).add("Jared");
taGpa.put(4.0, new TreeSet<String>());
taGpa.get(4.0).add("Alyssa");
taGpa.put(2.9, new TreeSet<String>());
taGpa.get(2.9).add("Steve");
taGpa.get(3.6).add("Stef");
taGpa.get(2.9).add("Rob");
...
System.out.println("Who got a 3.6? " +
taGpa.get(3.6)); // [Jared, Stef]

– must be careful to initialize the set for a given GPA before adding
42
Iterators

43
 Examining sets and maps
• elements of Java Sets and Maps can't be accessed by index
– must use a "foreach" loop:
Set<Integer> scores = new HashSet<Integer>();
for (int score : scores) {
System.out.println("The score is " + score);
}

– Problem: foreach is read-only; cannot modify set while looping

for (int score : scores) {
if (score < 60) {
// throws a ConcurrentModificationException
scores.remove(score);
}
}
44
 Iterators
• iterator: An object that allows a client to traverse the
elements of any collection.
– Remembers a position, and lets you:
• get the element at that position
• advance to the next position
• remove the element at that position

index 0 1 2 3 4 5 6 7 8 9 "the"
list value 3 8 9 7 5 12 0 0 0 0 set "to" "we"
size 6 "from"

current element: 9 current element: "from"

iterator iterator
current index: 2 next element: "the"

45
 Iterator methods
hasNext() returns true if there are more elements to examine
next() returns the next element from the collection (throws a
NoSuchElementException if there are none left to examine)
remove() removes the last value returned by next() (throws an
IllegalStateException if you haven't called next() yet)

• Iterator interface in java.util

– every collection has an iterator() method that returns an
iterator over its elements

Set<String> set = new HashSet<String>();

...
Iterator<String> itr = set.iterator();
...
46
 Iterator example
Set<Integer> scores = new TreeSet<Integer>();
scores.add(94);
scores.add(38); // Kim
scores.add(87);
scores.add(43); // Marty
scores.add(72);
...

Iterator<Integer> itr = scores.iterator();

while (itr.hasNext()) {
int score = itr.next();

System.out.println("The score is " + score);

// eliminate any failing grades

if (score < 60) {
itr.remove();
}
}
System.out.println(scores); // [72, 87, 94]
47
 Iterator example 2
Map<String, Integer> scores = new TreeMap<String, Integer>();
scores.put("Kim", 38);
scores.put("Lisa", 94);
scores.put("Roy", 87);
scores.put("Marty", 43);
scores.put("Marisa", 72);
...

Iterator<String> itr = scores.keySet().iterator();

while (itr.hasNext()) {
String name = itr.next();
int score = scores.get(name);
System.out.println(name + " got " + score);

// eliminate any failing students

if (score < 60) {
itr.remove(); // removes name and score
}
}
System.out.println(scores); // {Lisa=94, Marisa=72, Roy=87}
48
 The Map
• map: Holds a set of unique keys and a collection of values,
where each key is associated with one value.
– a.k.a. "dictionary", "associative array", "hash"

• basic map operations:

– put(key, value ): Adds a
mapping from a key to
a value.
– get(key ): Retrieves the
value mapped to the key.
– remove(key ): Removes
the given key and its
mapped value.
myMap.get("Juliet") returns "Capulet"
49
 Map implementation
• in Java, maps are represented by Map interface in java.util

• Map is implemented by the HashMap and TreeMap classes

– A map requires 2 type parameters: one for keys, one for values.

// maps from String keys to Integer values

Map<String, Integer> votes = new HashMap<String, Integer>();

50
 Map methods
put(key, value) adds a mapping from the given key to the given value;
if the key already exists, replaces its value with the given one
get(key) returns the value mapped to the given key (null if not found)
containsKey(key) returns true if the map contains a mapping for the given key
remove(key) removes any existing mapping for the given key
clear() removes all key/value pairs from the map
size() returns the number of key/value pairs in the map
isEmpty() returns true if the map's size is 0
toString() returns a string such as "{a=90, d=60, c=70}"

keySet() returns a set of all keys in the map

values() returns a collection of all values in the map
putAll(map) adds all key/value pairs from the given map to this map
equals(map) returns true if given map has the same mappings as this one

51
 Using maps
• A map allows you to get from one half of a pair to the other.
– Remembers one piece of information about every index (key).

// key value
put("Marty", "206-685-2181")
Map

– Later, we can supply only the key and get back the related value:
Allows us to ask: What is Marty's phone number?

get("Marty")
Map
"206-685-2181"

52
 keySet and values
• keySet method returns a set of all keys in the map
– can loop over the keys in a foreach loop
– can get each key's associated value by calling get on the map

Map<String, Integer> ages = new HashMap<String, Integer>();

ages.put("Marty", 19);
ages.put("Geneva", 2);
ages.put("Vicki", 57);
for (String name : ages.keySet()) { // Geneva -> 2
int age = ages.get(age); // Marty -> 19
System.out.println(name + " -> " + age); // Vicki -> 57
}

• values method returns a collection of all values in the map

– can loop over the values in a foreach loop
– there is no easy way to get from a value to its associated key(s)
53
 Further Readings
• http://docs.oracle.com/javase/tutorial/collections

54