Object-Oriented Programming
Lecture 8 – Collections Framework
Ralph Tambala
MUST . CSIT
Lecture 8 1 / 24
Outline
1 Overview
Collections Framework
Lists and Sets
Stacks and Queues
Maps
2 The Collection Interface
3 Linked Lists
List Iterators
4 Sets
Hash Table Concept
Tree Concept
Iterators and Sets
5 Maps
6 Additional Info
Lecture 8 2 / 24
Overview Collections Framework
Collections Framework
In this lecture, you will learn about the Java collection framework, a
hierarchy of interface types and classes for collecting objects.
We will take a closer look at the following collections:
Linked Lists
Sets
Maps
Collections are used when you need to organize multiple objects in your
program, you can place them into a collection.
A collection groups together elements and allows them to be accessed and
retrieved later.
Lecture 8 3 / 24
Overview Collections Framework
Collections Framework
Each collection class implements an interface from a hierarchy.
Each class is designed for a specific type of storage.
Figure 1: Collections framework
Each interface type is implemented by one or more classes.
Lecture 8 4 / 24
Overview Lists and Sets
Lists and Sets
A list is a collection that maintains the order of its elements.
ArrayList – Stores a list of items in a dynamically sized array
LinkedList – Allows speedy insertion and removal of items from the
list
Figure 2: Ordered vs unordered
A set is an unordered collection of unique elements.
HashSet – Uses hash tables to speed up finding, adding, and
removing elements
TreeSet – Uses a binary tree to speed up finding, adding, and
removing elements
Lecture 8 5 / 24
Overview Stacks and Queues
Stacks and Queues
Another way of gaining efficiency in a collection is to reduce the number of
operations available.
Two examples of such collections are:
Stack
◦ Remembers the order of its elements, but it does not allow you to
insert elements in every position
◦ You can only add and remove elements at the top
Queues
◦ Add items to one end (the tail)
◦ Remove them from the other end (the head)
◦ Example: A line of people waiting for a bank teller
Figure 3: Stack (left) vs queue (right)
Lecture 8 6 / 24
Overview Maps
Maps
A map keeps associations between key and value objects.
A good example is barcode keys and books.
Keys
◦ Provides an easy way to represent an object (such as a numeric bar
code, or a Student Identification Number)
Values
◦ The actual object that is associated with the key
Lecture 8 7 / 24
The Collection Interface
The Collection Interface
The Collection interface (shown in Figure 1) is used to pass around
collections of objects where maximum generality is desired. For example,
by convention all general-purpose collection implementations have a
constructor that takes a Collection argument.
List, Queue and Set are specialized interfaces that inherit from the
Collection interface. This means that they all share the commonly used
methods.
Lecture 8 8 / 24
The Collection Interface
The Collection Interface
Lecture 8 9 / 24
Linked Lists
Linked Lists
Linked lists use references to maintain an ordered lists of ‘nodes’
The ‘head’ of the list references the first node
Each node has a value and a reference to the next node
Linked lists can be used to implement List interface and Queue interface
as shown in Figure 1.
Lecture 8 10 / 24
Linked Lists
Linked Lists
Important methods
Table 2 lists some of the important methods in Linked List class.
Lecture 8 11 / 24
Linked Lists List Iterators
List Iterators
When traversing a LinkedList, use a ListIterator to keep track of
where you are in the list.
1 LinkedList < String > employeeNames = . . .;
2 ListIterator < String > iter = employeeNames . listIterator ()
Think of an iterator as pointing between two elements (think of cursor in
word processor)
Note that the generic type for the ListIterator must match the generic
type of the LinkedList. In the example above, the generic type we have
used is String.
Lecture 8 12 / 24
Linked Lists List Iterators
Iterator and ListIterator Methods (1)
Iterators allow you to move through a list easily. Similar to an index
variable for an array.
Iterators are often used in while and “for-each” loops
hasNext returns true if there is a next element
next returns a reference to the value of the next element
Lecture 8 13 / 24
Linked Lists List Iterators
Iterator and ListIterator Methods (2)
In a while loop:
1 while ( iterator . hasNext () ) {
2 String name = iterator . next () ;
3 // Do something with name
4 }
In a for-each loop:
1 for ( String name : employeeNames )
2 {
3 // Do something with name
4 }
Lecture 8 14 / 24
Sets
Sets
A set is an unordered collection which does not support duplicate
elements.
The collection does not keep track of the order in which elements
have been added.
◦ Therefore, it can carry out its operations more efficiently than an
ordered collection
The HashSet and TreeSet classes both implement the Set interface
(as shown in Figure 1).
◦ HashSet: Stores data in a hash table.
◦ TreeSet: Stores data in a binary tree.
◦ Both implementations arrange the set elements so that finding, adding,
and removing elements is efficient.
Lecture 8 15 / 24
Sets Hash Table Concept
Sets
Hash Table Concept
Set elements are grouped into smaller collections of elements that
share the same characteristic.
◦ It is usually based on the result of a mathematical calculation on the
contents that results in an integer value
◦ In order to be stored in a hash table, elements must have a method
(called a hash function) to compute their integer values.
Lecture 8 16 / 24
Sets Tree Concept
Sets
Tree Concept (1)
Set elements are kept in sorted order.
◦ Nodes are not arranged in a linear sequence but in a tree shape.
In order to use a TreeSet, it must be possible to compare the
elements and determine which one is “larger”.
Lecture 8 17 / 24
Sets Tree Concept
Sets
Tree Concept (2)
Use TreeSet for classes that implement the Comparable interface
String and Integer, for example
The nodes are arranged in a ‘tree’ fashion so that each ‘parent’ node
has two child nodes.
◦ The node to the left always has a ‘smaller’ value
◦ The node to the right always has a ‘larger’ value
Lecture 8 18 / 24
Sets Iterators and Sets
Sets
Iterators and Sets
Iterators are also used when processing sets
hasNext returns true if there is a next element
next returns a reference to the value of the next element
add via the iterator is not supported for TreeSet and HashSet
Note that the elements are not visited in the order in which you
inserted them. They are visited in the order in which the set keeps
them:
◦ Seemingly random order for a HashSet
◦ Sorted order for a TreeSet
1 I t e r a t o r <S t r i n g > i t e r = names . i t e r a t o r ( ) ;
1 I t e r a t o r <S t r i n g > i t e r = names . i t e r a t o r ( ) ;
2 w h i l e ( i t e r . hasNext ( ) )
2 f o r ( S t r i n g name : names )
3 {
3 {
4 String x = i t e r . next () ;
4 // Some c o d e
5 // Some c o d e
5 }
6 }
Listing 1: While loop Listing 2: For-each loop
Lecture 8 19 / 24
Sets Iterators and Sets
Sets
Important methods (1)
Table 4 lists some of the important methods in HashSet and TreeSet
classes.
Lecture 8 20 / 24
Sets Iterators and Sets
Sets
Important methods (2)
Lecture 8 21 / 24
Maps
Maps
A map allows you to associate elements from a key set with elements from
a value collection.
The HashMap and TreeMap classes both implement the Map interface.
Use a map to look up objects by using a key.
The key “unlocks” the “data” (value). A map is like a mathematical
function mapping between two sets.
Lecture 8 22 / 24
Maps
Maps
Basic methods
A map has the form Map<K, V> where:
K: specifies the type of keys maintained in this map.
V: defines the type of mapped values.
The following are the most common used methods provided by Map
interface:
clear: Removes all the elements from the map.
containsKey: Returns true if the map contains the requested key.
containsValue: Returns true if the map contains the requested value.
equals: Compares an Object with the map for equality.
get: Retrieve the value of the requested key.
entrySet: Returns a Set view of the mappings contained in this map.
keySet: Returns a Set that contains all keys of the map.
put: Adds the requested key-value pair in the map.
remove: Removes requested key and its value from map, if the key exists.
size: Returns the number of key-value pairs currently in the map.
Lecture 8 23 / 24
Additional Info
Additional Info
Some may find these articles useful –
◦ Java List Collection Tutorial and Examples
◦ Java Map
Lecture 8 24 / 24
