Java Collections

and
Generics
java.util package
By Waqas 1
 Java Collection Framework

Collection Framework Interfaces

Collection Interface
Set Interface
List Interface
SortedSet Interface
Map Interface
SortedMap Interface
Collection Framework Implementations
ArrayList Class
LinkedList Class
HastSet Class
TreeSet Class
HashMap Class
TreeMap Class

By Waqas 2
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 3
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
degree of compatibility. By Waqas 4
Collection Framework Elements
The Collection Framework consists of three
elements: Interfaces, Implementation and Algorithms.

Interfaces

Abstract data types to manipulate collections

independent of implementation details. e.g.
Collection, Set, List, Map etc.

By Waqas 5
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

such as sorting, searching, iterations.
By Waqas 6
Collection Framework
Interfaces

By Waqas 7
 Collection Map

Set List SortedMap

SortedSet
Collection Framework
Interfaces

By Waqas 8
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 9
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 10
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 11
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 12
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 13

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 14
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 15
Collection Framework
Implementations

By Waqas 16
 Set SortedSet List

HashSet TreeSet ArrayList LinkedList

Vector
Map SortedMap

Collection Framework
HashMap TreeMap
Implementations
By Waqas 17
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 18
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 19
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 20
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 21
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 22
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 23
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 24
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 25
Arrays Class
Arrays class contains various methods for
manipulating arrays.

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. By Waqas 26
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 27
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 28
Comparator Interface

Student students[] = new Student[5];

students[0] = new Student(5, "Simon");

students[1] = new Student(2, "James");
students[2] = new Student(1, "Peter");
students[3] = new Student(4, "David");
students[4] = new Student(3, "John");

Arrays.sort(students,
By Waqasnew 29
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 30
Java Generics

By Waqas 31
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 32
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 33
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 34
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); // Compiler Error

By Waqas 35
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 36
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 37
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 38