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
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
Java Collections Framework
Collections Interfaces
• Java allows Collection
Map
using:
• Lists
• Sets SortedMap
• Hash tables Set List
(maps)
SortedSet
Interface: Collection
• The Collection interface is the root public interface Collection {
of the collection hierarchy // Basic Operations
int size();
boolean isEmpty();
• Some Collection implementations boolean contains(Object element);
allow boolean add(Object element);
- duplicate elements and others do not boolean remove(Object element);
- the elements to be ordered or not Iterator iterator();
• JDK doesn't provide any direct // Bulk Operations
implementations of this interface boolean containsAll(Collection c);
boolean addAll(Collection c);
- It provides implementations of more
boolean removeAll(Collection c);
specific sub interfaces like Set and List
boolean retainAll(Collection c);
void clear();
// Array Operations
Object[] toArray();
Object[] toArray(Object a[]);
}
SEG4110 - Topic G - Java Collections
Framework
Interface: Set
• A Set is a collection that public interface Set {
// Basic Operations
cannot contain duplicate int size();
elements boolean isEmpty();
boolean contains(Object
element);
• A set is not ordered boolean add(Object element);
- however, some subsets
boolean remove(Object
maintain order using extra data element);
structures Iterator iterator();
// Bulk Operations
• This is similar to the
boolean
mathematical concept of sets containsAll(Collection c);
boolean addAll(Collection
c);
boolean removeAll(Collection
c);
boolean retainAll(Collection
c);
void clear();
// Array
SEG4110 - Topic Operations
G - Java Collections
Object[] toArray();
Framework
Interface: List
• A List is ordered (also public interface List extends
Collection {
called a sequence) // Positional Access
Object get(int index);
Object set(int index, Object
• Lists can contain duplicate element);
elements void add(int index, Object
element);
Object remove(int index);
• The user can access abstract boolean addAll(int
index, Collection c);
elements by their integer
index (position) // Search
int indexOf(Object o);
int lastIndexOf(Object o);
// Iteration
ListIterator listIterator();
ListIterator listIterator(int
index);
// Range-view
List subList(int from, int to);
SEG4110
} - Topic G - Java Collections
Framework
public interface Map {
// Basic Operations
Interface: Map Object put(Object key, Object
value);
Object get(Object key);
• A Map is an object that maps
Object remove(Object key);
keys to values boolean containsKey(Object
key);
boolean containsValue(Object
• Maps cannot contain value);
duplicate keys int size();
boolean isEmpty();
• Each key can map to at most // Bulk Operations
void putAll(Map t);
one value void clear();
// Collection Views
• Hashtables are an example of public Set keySet();
Maps public Collection values();
public Set entrySet();
// Interface for entrySet
elements
public interface Entry {
Object getKey();
Object getValue();
SEG4110 - Topic G Object
- Java setValue(Object
Collections
value);
Framework
Interface: SortedSet
• A SortedSet is a Set that public interface SortedSet
maintains its elements in an extends Set {
// Range-view
order SortedSet subSet(Object
fromElement, Object toElement);
SortedSet headSet(Object
• Several additional operations toElement);
are provided to take SortedSet tailSet(Object
advantage of the ordering fromElement);
// Endpoints
Object first();
Object last();
// Comparator access
Comparator comparator();
}
SEG4110 - Topic G - Java Collections
Framework
Interface: SortedMap
• A SortedMap is a Map that public interface SortedMap
maintains its mappings in extends Map {
Comparator comparator();
ascending key order
SortedMap subMap(Object
fromKey, Object toKey);
• The SortedMap interface is SortedMap headMap(Object
used for apps like dictionaries toKey);
and telephone directories SortedMap tailMap(Object
fromKey);
Object firstKey();
Object lastKey();
}
SEG4110 - Topic G - Java Collections
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
Framework
Java Lists: LinkedList
Collection
• Java uses a doubly-linked list
- it can be traversed from the beginning or AbstractCollection
List
the end
• LinkedList provides methods to get, AbstractList
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 queue ArrayList
• LinkedList is not synchronized LinkedList Vector
- problems if multiple threads access a list
concurrently Stack
- LinkedList must be synchronized externally
SEG4110 - Topic G - Java Collections
Framework
Java Lists: ArrayList
Collection
• Uses an array to store the elements
AbstractCollection
List
• In addition to the methods of the
interface List AbstractList
• it provides methods to manipulate the
size of the array (e.g. ensureCapacity)
AbstractSequentialList
• More efficient than LinkedList for ArrayList
methods involving indices – get(),
set() LinkedList Vector
• It is not synchronized Stack
SEG4110 - Topic G - Java Collections
Framework
Java Lists: Vector
Collection
• Same as an the class ArrayList
AbstractCollection
List
• The main difference is that:
- The methods of Vector are AbstractList
synchronized
AbstractSequentialList
ArrayList
LinkedList Vector
Stack
SEG4110 - Topic G - Java Collections
Framework
Java Lists: Stack
Collection
• The Stack class represents a 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
• Vector operations should not be LinkedList Vector
accessible in a Stack
• It is designed this way because of Stack
a historical mistake
SEG4110 - Topic G - Java Collections
Framework
Java Sets: HashSet
• HashSet uses a hash table as the data Collection
structure to represent a set
AbstractCollection
• HashSet is a good choice for representing Set
sets if order of the elements is not
important AbstractSet
• HashSet methods are not synchronized
HashSet
LinkedHashSet SortedSet
TreeSet
SEG4110 - Topic G - Java Collections
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 is maintained
AbstractSet
• Performance is below that of
HashSet, due to the expense of HashSet
maintaining the linked list
LinkedHashSet SortedSet
• Its methods are not synchronized
TreeSet
SEG4110 - Topic G - Java Collections
Framework
Java Sets: TreeSet
• Stores the elements in a balanced Collection
binary tree
- A binary tree is a tree in which each AbstractCollection
node has at most two children
Set
• TreeSet elements are sorted
AbstractSet
• Less efficient than HashSet in
insertion due to the use of a binary HashSet
tree
LinkedHashSet SortedSet
• Its methods are not synchronized
TreeSet
SEG4110 - Topic G - Java Collections
Framework
Java Maps: HashMap
Map
• Stores the entries in a hash
table AbstractMap
• Efficient in inserting (put())
and retrieving elements (get())
HashMap
• The order is not maintained
LinkedHashMap
SortedMap
• Unlike HashTable, HashMap’s
methods are not synchronized
TreeMap
SEG4110 - Topic G - Java Collections
Framework
Java Maps: LinkedHashMap
Map
• Hash table and linked list
implementation of the Map
interface AbstractMap
• LinkedHashMap differs from
HashMap in that the order is
HashMap
maintained
• Performance is below that of LinkedHashMap
HashMap, due to the expense of SortedMap
maintaining the linked list
TreeMap
• Its methods are not synchronized
SEG4110 - Topic G - Java Collections
Framework
Java Maps: TreeMap
Map
• Red-Black tree based
implementation of the SortedMap AbstractMap
interface
• The keys are sorted according to
their natural order HashMap
LinkedHashMap
• Less efficient than HashMap for
SortedMap
insertion and mapping
TreeMap
• Its methods are not synchronized
SEG4110 - Topic G - Java Collections
Framework
The class Hashtable
• Same as HashMap except that its
methods are synchronized Dictionary
Map
• The class Hashtable was
introduced in JDK 1.0 and uses Hashtable
Enumerations instead of
Iterators
SEG4110 - Topic G - Java Collections
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
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
Framework
References
The Java Collections Framework:
http://java.sun.com/j2se/1.4.2/docs/guide/collections/inde
x.html
The Java 1.4.2 APIs:
http://java.sun.com/j2se/1.4.2/docs/api/
SEG4110 - Topic G - Java Collections
Framework
