Java Collections

and
Generics
java.util package
By Waqas

Java Collection Framework

A Collection (sometimes called a Container) is
simply an object that groups multiple objects into a
single group.

The java collection framework standardizes the way

in which groups of objects are handled by your
programs by providing a unified architecture called
Collection Framework
By Waqas

The Collection Framework is designed to meet

several goals.

First, the framework provides high performance, fast

and highly efficient way to work with groups of
objects.

Second, the framework allows different types of

collections to work in a similar manner with high
3
degree of compatibility. By Waqas

Collection Framework Elements

The Collection Framework consists of three
elements: Interfaces, Implementation and Algorithms.

Interfaces
Abstract data types to manipulate collections
independent of implementation
Collection, Set, List, Map etc.
By Waqas

details.

e.g.

Implementations
Concrete

classes

which

are

implementing

Collection interfaces, used as reusable data

structures. e.g. HashMap, ArrayList, TreeSet,
HashSet etc.

Algorithms
Methods to perform operations on collections
By Waqas
such as sorting, searching,
iterations.

Collection Framework
Interfaces

By Waqas

Collection

Set

SortedSet

Map

List

SortedMap

Collection Framework

Interfaces
By Waqas

Collection Interface
A Collection interface is the super interface in the
collection interfaces hierarchy. A collection
represents a group of objects, known as its elements.
Java does not provide any direct implementation of
this interface.
It provides implementations of more specific
subinterfaces like Set and List.
By Waqas

Set Interface
A Set is a Collection that does not contain duplicate
elements, so its a collection of unique elements. If
you add duplicate element in Set then add( ) method
simply ignore the element and return false.
The elements in Set are not in order.
The set interface does not define any additional
methods, it inherits all the methods of Collection
interface.
By Waqas

List Interface
The List interface also extends Collection interface
and declares the behavior of a collection that stores a
sequence of objects in order.
Elements can be inserted or retrieved by their
position in the list, using a zero based index.
List can accept duplicate values.

By Waqas

10

SortedSet Interface
The SortedSet interface extends Set and declares the
behavior of a set in which objects are sorted in either
their natural order or the order you specified in your
custom object.
SortedSet does not accept duplicate elements.

By Waqas

11

Map Interface
A Map is an object that maps keys to values.
A map cannot contain duplicate keys but can contain
duplicate values.
Each key can map to at most one value.
We can retrieve value by using its key.
Elements are not orderedBy Waqas

12

SortedMap Interface
The SortedMap interface extends Map and declares
the behavior of a map in which objects are sorted by
their keys in their natural order or custom order.

SortedMap elements can not contain duplicate keys.

By Waqas

13

Difference between Interfaces

Interface

Duplicates

Order

Sorting

Set

Not Allowed

No Order

No Sorting

List

Allowed

Order by Index

No Sorting

Map

Not Allowed for Keys

No Order

No Sorting

Sorted Set

Not Allowed

By Natural Order

By Natural Order

Sorted Map

Not Allowed

By Natural Order

By Natural Order

By Waqas

14

Collection Framework
Implementations

By Waqas

15

Set

SortedSet

HashSet

TreeSet

List

ArrayList

LinkedList
Vector

Map

HashMap

SortedMap

Collection Framework
Implementations

TreeMap
By Waqas

16

ArrayList Class
ArrayList class implements the List interface.
ArrayList is a dynamic array that can grow and shrink
automatically as needed.
Insertions and deletions are linear thats why these
operations are slow in ArrayList
Searching is fast in ArrayList because Java performs
search randomly.
By Waqas

17

LinkedList Class
LinkedList class implements the List interface.
Every element in LinkedList contains the data item
and the pointer to the next node.
Insertions and deletions are fast because they are
linear in time.
Searching is slow as java search LinkedList
sequentially not randomly.
By Waqas

18

HashSet Class
HastSet provides an implementation of Set

interface.
Objects are not stored in order thats why
searching objects is very fast.

HashSet does not support duplicate elements.

By Waqas

19

TreeSet Class
TreeSet provides an implementation of SortedSet
interface.
Objects are stored in sorted, ascending order.
Access and retrieval times is not as fast as HashSet.
TreeSet is an excellent choice when you want to
store large amounts of sorted data items.
By Waqas

20

HashMap Class
HashMap provides an implementation of Map
interface.
Objects are stored as key-value pairs.
null objects are supported by the HashMap.
Objects are not stored in order.

By Waqas

21

TreeMap Class
TreeMap class implements SortedMap interface.
It provides an efficient means of storing key-value
pairs in sorted order based on their keys.

As objects are sorted so random access or searching

is little slower then HashMap.
By Waqas

22

Comparable Interface
Many java collection framework classes such as
TreeMap, TreeSet perform automatic sorting of
objects when they added in the collection.
For sorting objects they must be comparable. Java
provides an interface to make two objects
comparable.
Custom classes should implement comparable
interface to provide logic for class specific sorting
By Waqas

23

Comparable Interface
class Student implements Comparable
{
int id;
public int compareTo(Object obj)
{
Student s2 = (Student) obj;
Integer st1 = new Integer(this.id);
Integer st2 = new Integer(s2.id);
return st1.compareTo(st2);
By Waqas

24

Arrays Class
Arrays class contains
manipulating arrays.

various

methods

for

The two most common methods are sorting and

searching.
To sort array pass the array in the sort method. This
method sort all elements in their natural order.
To search elements inside array use binarySearch
method.
25
By Waqas

Comparator Interface
Comparator interface is used to create objects
which can be passed to Arrays.sort or Collection.sort
methods or collections such as TreeMap and
TreeSet.
They are used to sort custom objects in collections.
They are not needed for arrays and collections of
primitive data types and for objects that have a
natural sorting order such as String, Integer.
By Waqas

26

Comparator Interface
class StudentComparator implements
Comparator
{
public int compare(Object obj1, Object
obj2)
{
Student s1 = (Student) obj1;
Student s2 = (Student) obj2;
Integer st1 = new Integer(s1.id);
Integer st2 = new Integer(s2.id);
By Waqas

27

Comparator Interface
Student students[] = new Student[5];
students[0]
students[1]
students[2]
students[3]
students[4]

=
=
=
=
=

new
new
new
new
new

Student(5,
Student(2,
Student(1,
Student(4,
Student(3,

By Waqasnew
Arrays.sort(students,

"Simon");
"James");
"Peter");
"David");
"John");

28

Collections Class
Collections class contains various methods for
manipulating collections.

sort( List );
binarySearch( List, Object );
min(List);
max(List);
replaceAll(List, Object, Object);
reverse(List);
shuffle(List);
swap(List, int, int);
By Waqas

29

Java Generics

By Waqas

30

Example of Generic Errors

When we retrieve an element from a collection, we
need to cast it to the right type otherwise compile
time error occur.
ArrayList list = new ArrayList();
String input = London;
list.add(input);
String output = list.get(0);

// Compiler Error

String output = (String) list.get(0); // Valid

By Waqas

31

Example of Generic Errors

There is no way to ensure that we are casting to a
correct type. Following code will compile but it will
throw exception at runtime.
ArrayList list = new ArrayList();
String input = London;
list.add(input);

Integer output = list.get(0); // Runtime Error

By Waqas

32

Java Generics
Generics in Java allow us to create collections with
a strong type.
This means that if we are creating a collection to
store Strings we will be forced to store and retrieve
only Strings at compile time and runtime.
Overall result of using generics in java collections is
improved reliability, readability and performance.
By Waqas

33

Generic ArrayList
ArrayList<E> list = new ArrayList<E>();
ArrayList<String> list = new ArrayList<String>();
list.add(Simon);
list.add(Peter);
list.add(new Integer(2));

// Compiler Error

String s1 = list.get(0);
String s2 = list.get(1);
Integer I = list.get(0);

By Waqas

// Compiler Error

34

Generic TreeSet
TreeSet<E> set = new TreeSet<E>();

>();TreeSet<Integer> set = new TreeSet<Integer

; set.add(new Integer(2))
set.add(new Integer(3));
set.add(Simon); // Compiler Error

By Waqas

35

Generic TreeMap
TreeMap<K,V> map = new TreeMap<K,V>();

>();TreeMap<Integer, String> map = new TreeMap<Integer, String

; map.put(new Integer(2), Simon)

map.put(new Integer(3), Peter);
map.put(1, Simon);
// Compiler Error
map.put(1, new Integer(3)); // Compiler Error

By Waqas

36

Generic Iterator
Iterator<E> it = set.iterator();
>();TreeSet<String> set = new TreeSet<String
set.add(Simon);
set.add(Peter);
Iterator<String> it = set.iterator();
String s;
while(it.hasNext())
{
s = it.next();
}

By Waqas

37