SEG4110 – Advanced Software Design

and Reengineering

TOPIC G

Java Collections Framework

Collections Frameworks
•A collection is an object that represents a
group of objects

•A collections framework is a unified

architecture for representing and manipulating
collections
- the manipulation should be independent of the
implementation details

•Advantages of having a collections framework

- reduces programming effort by providing useful data
structures and algorithms
- increases performance by providing high-performance data
structures and algorithms
- interoperability between the different collections
- Having a common language for manipulating the collections

SEG4110 - Topic G - Java Collections 2

Framework
The components of Java Collections Framework
from the user’s perspective
• Collection Interfaces: form the basis of the
framework
- such as sets, lists and maps

• Implementations Classes: implementations of the

collection interfaces

• Utilities - Utility functions for manipulating

collections such as sorting, searching…

• The Java Collections Framework also includes:

- algorithms
- wrapper implementations
- add functionality to other implementations such as
synchronization
SEG4110 - Topic G - Java Collections 3
Framework
Collections Interfaces
•Java allows Collection
Map
using:
• Lists
• Sets SortedMap
• Hash tables Set List
(maps)

SortedSet

SEG4110 - Topic G - Java Collections 4

Framework
Interface: Collection
• The Collection interface public interface Collection {
is the root of the // Basic Operations
collection hierarchy int size();
boolean isEmpty();
boolean contains(Object element);
• Some Collection boolean add(Object element);
implementations allow boolean remove(Object element);
- duplicate elements and Iterator iterator();
others do not
- the elements to be // Bulk Operations
ordered or not boolean containsAll(Collection c);
boolean addAll(Collection c);
boolean removeAll(Collection c);
• JDK doesn't provide any boolean retainAll(Collection c);
direct implementations of void clear();
this interface
- It provides implementations // Array Operations
of more specific sub Object[] toArray();
interfaces like Set and Object[] toArray(Object a[]);
List }

SEG4110 - Topic G - Java Collections 5

Framework
Interface: Set
• A Set is a public interface Set {
// Basic Operations
collection that int size();
cannot contain boolean isEmpty();
duplicate elements boolean contains(Object
element);
boolean add(Object element);
• A set is not ordered boolean remove(Object
- however, some subsets element);
maintain order using Iterator iterator();
extra data structures
// Bulk Operations
boolean
• This is similar to containsAll(Collection c);
boolean addAll(Collection
the mathematical c);
concept of sets boolean removeAll(Collection
c);
boolean retainAll(Collection
c);
void clear();

// Array
SEG4110 - Topic Operations
G - Java Collections 6
Framework Object[] toArray();
Interface: List
• A List is ordered public interface List extends
Collection {
(also called a // Positional Access
sequence) Object get(int index);
Object set(int index, Object
element);
• Lists can contain void add(int index, Object
element);
duplicate elements Object remove(int index);
abstract boolean addAll(int
index, Collection c);
• The user can access
elements by their // Search
int indexOf(Object o);
integer index
int lastIndexOf(Object o);
(position)
// Iteration
ListIterator listIterator();
ListIterator listIterator(int
index);

// Range-view
List subList(int from, int to);
SEG4110
} - Topic G - Java Collections 7
Framework
 public interface Map {
// Basic Operations
Interface: Map Object put(Object key, Object
value);
Object get(Object key);
• A Map is an object Object remove(Object key);
that maps keys to boolean containsKey(Object
values key);
boolean containsValue(Object
value);
int size();
• Maps cannot contain
boolean isEmpty();
duplicate keys
// Bulk Operations
void putAll(Map t);
• Each key can map to void clear();
at most one value
// Collection Views
public Set keySet();
public Collection values();
• Hashtables are an public Set entrySet();
example of Maps
// Interface for entrySet
elements
public interface Entry {
Object getKey();
Object getValue();
SEG4110 - Topic G Object setValue(Object 8
- Java Collections
Frameworkvalue);
Interface: SortedSet
• A SortedSet is a Set public interface SortedSet
that maintains its extends Set {
// Range-view
elements in an order SortedSet subSet(Object
fromElement, Object toElement);
SortedSet headSet(Object
• Several additional toElement);
operations are SortedSet tailSet(Object
fromElement);
provided to take
advantage of the // Endpoints
ordering Object first();
Object last();

// Comparator access
Comparator comparator();
}

SEG4110 - Topic G - Java Collections 9

Framework
Interface: SortedMap
• A SortedMap is a Map public interface SortedMap
that maintains its extends Map {
Comparator comparator();
mappings in
ascending key order SortedMap subMap(Object
fromKey, Object toKey);
SortedMap headMap(Object
• The SortedMap toKey);
SortedMap tailMap(Object
interface is used fromKey);
for apps like
dictionaries and Object firstKey();
Object lastKey();
telephone }
directories

SEG4110 - Topic G - Java Collections 10

Framework
Java
Collections
Object
(java.lang)

Collection Map

AbstractCollection AbstractMap
List Set

Dictionary

AbstractList AbstractSet
Map
HashMap

AbstractSequentialList Hashtable
HashSet
LinkedHashMap
ArrayList
SortedMap
LinkedHashSet SortedSet

LinkedList
TreeMap

Vector TreeSet

Stack

SEG4110 - Topic G - Java Collections 11

Framework
Java Lists: LinkedList
Collection

• Java uses a doubly-linked list

- it can be traversed from the
AbstractCollection
beginning or the end List

• LinkedList provides methods to AbstractList

get, remove and insert an
element at the beginning and
end of the list AbstractSequentialList

- these operations allow a linked

list to be used as a stack or a ArrayList

queue
LinkedList Vector
• LinkedList is not synchronized
- problems if multiple threads
Stack
access a list concurrently
- LinkedList must be synchronized
externally

SEG4110 - Topic G - Java Collections 12

Framework
Java Lists: ArrayList
Collection

• Uses an array to store the

elements List
AbstractCollection

• In addition to the methods AbstractList

of the interface List

• it provides methods to
manipulate the size of the AbstractSequentialList

array (e.g. ensureCapacity)

ArrayList

• More efficient than

LinkedList for methods
LinkedList Vector

involving indices – get(),

set() Stack

• It is not synchronized

SEG4110 - Topic G - Java Collections 13

Framework
Java Lists: Vector
Collection

• Same as an the class

ArrayList List
AbstractCollection

• The main difference is AbstractList

that:
- The methods of Vector are
synchronized AbstractSequentialList

ArrayList

LinkedList Vector

Stack

SEG4110 - Topic G - Java Collections 14

Framework
Java Lists: Stack
• The Stack class represents a
Collection

last-in-first-out (LIFO) stack

of objects
AbstractCollection
List

• The common push and pop

operations are provided
AbstractList

• As well as a method to peek at

the top item on the stack is
also provided AbstractSequentialList

ArrayList
• Note: It is considered bad
design to make Stack a Subclass
of vector LinkedList Vector
• Vector operations should not
be accessible in a Stack
• It is designed this way Stack

because of a historical
mistake

SEG4110 - Topic G - Java Collections 15

Framework
Java Sets: HashSet
• HashSet uses a hash table as Collection

the data structure to

represent a set AbstractCollection

Set

• HashSet is a good choice for

representing sets if order AbstractSet

of the elements is not

important
HashSet

• HashSet methods are not synchronized

LinkedHashSet SortedSet

TreeSet

SEG4110 - Topic G - Java Collections 16

Framework
Java Sets: LinkedHashSet
Collection
• Hash table and linked list
implementation of the Set
interface AbstractCollection

Set

• LinkedHashSet differs from

HashSet in that the order AbstractSet

is maintained

• Performance is below that HashSet

of HashSet, due to the

expense of maintaining the LinkedHashSet SortedSet
linked list

• Its methods are not

TreeSet

synchronized

SEG4110 - Topic G - Java Collections 17

Framework
Java Sets: TreeSet
• Stores the elements in a Collection

balanced binary tree

- A binary tree is a tree in AbstractCollection
which each node has at
most two children Set

• TreeSet elements are AbstractSet

sorted

• Less efficient than HashSet

HashSet in insertion due

to the use of a binary LinkedHashSet SortedSet
tree
TreeSet
• Its methods are not
synchronized

SEG4110 - Topic G - Java Collections 18

Framework
Java Maps: HashMap
• Stores the entries in
Map

a hash table AbstractMap

• Efficient in
inserting (put()) and
retrieving elements HashMap

(get())
LinkedHashMap

• The order is not SortedMap

maintained
TreeMap

• Unlike HashTable,
HashMap’s methods are
not synchronized

SEG4110 - Topic G - Java Collections 19

Framework
Java Maps: LinkedHashMap
• Hash table and linked
Map

list implementation of
the Map interface AbstractMap

• LinkedHashMap differs
from HashMap in that
the order is HashMap

maintained
LinkedHashMap

• Performance is below SortedMap

that of HashMap, due

to the expense of
maintaining the linked
TreeMap

list

• Its methods are not

synchronized

SEG4110 - Topic G - Java Collections 20

Framework
Java Maps: TreeMap
• Red-Black tree based
Map

implementation of the
SortedMap interface
AbstractMap

• The keys are sorted

according to their HashMap

natural order
LinkedHashMap

• Less efficient than

SortedMap

HashMap for insertion

and mapping
TreeMap

• Its methods are not

synchronized

SEG4110 - Topic G - Java Collections 21

Framework
The class Hashtable
• Same as HashMap except
that its methods are Dictionary

synchronized
Map

• The class Hashtable Hashtable

was introduced in JDK

1.0 and uses
Enumerations instead
of Iterators

SEG4110 - Topic G - Java Collections 22

Framework
The Iterator Interface
• JCF provides a uniform way to iterate through the
collection elements using the Iterator Interface

• The Iterator interface contains the following

methods
- boolean hasNext(): returns true if the iteration has more
elements.
- Object next(): returns the next element in the iteration.
- void remove(): removes from the collection the last element
returned by the iterator

• Iterator replaces Enumeration in the Java

Collections Framework. Iterators differ from
enumerations in two ways:
- They allow the caller to remove elements from the
collection during the iteration with well-defined semantics
(a major drawback of Enumerations)
- Method names have been improved

SEG4110 - Topic G - Java Collections 23

Framework
The class Arrays
• This class contains various static methods for
manipulating arrays such as:
- Sorting, comparing collections, binary searching…

• Refer to:
http://java.sun.com/j2se/1.4.2/docs/api/ for a
complete list of utilities

SEG4110 - Topic G - Java Collections 24

Framework
References
The Java Collections Framework:

http://java.sun.com/j2se/1.4.2/docs/guid
e/collections/index.html

The Java 1.4.2 APIs:

http://java.sun.com/j2se/1.4.2/docs/api/

SEG4110 - Topic G - Java Collections 25

Framework