Java Collections
and
Generics
java.util package
By Waqas 1
Java Collection Framework
Comparable Interface
Collection Framework Elements
Arrays Class
Collection Framework Interfaces
Comparator Interface
Collection Interface
Collections Class
Set Interface
Generics in Java
List Interface
Examples of Generic Errors
SortedSet Interface
Generic ArrayList
Map Interface
Generic TreeSet
SortedMap Interface
Generic TreeMap
Collection Framework Implementations
Generic Iterator
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
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 it’s 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 that’s 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 that’s 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
By Waqas 39
By Waqas 40
