73

UNIT-III
The Collection Framework

In order to handle group of objects we can use array of objects If we have a class called
Employ with members name and id, if we want to store details of 10 Employees, create an
array of object to hold 10 Employ details
Employ ob [] = new Employ [10];
We cannot store different class objects into same array
Inserting element at the end of array is easy but at the middle is difficult
After retriving the elements from the array, in order to process the elements we dont have
any methods

Collection Object:
A collection object is an object which can store group of other objects
A collection object has a class called Collection class or Container class
All the collection classes are available in the package called 'javautil‟ (util stands for utility)
Group of collection classes is called a Collection Framework
A collection object does not store the physical copies of other objects; it stores references of
other objects
All the collection classes in javautil package are the implementation classes of different
interfaces

Interface Type Implementation Classes

Set <T> HashSet<T>
LinkedHashSet<T>
List <T> Stack<T>
LinkedList<T>
ArrayList<T>
Vector<T>
Queue <T> LinkedList<T>
Map<T> HashMap<K,V>
Hashtable<K,V>

Set: A Set represents a group of elements (objects) arranged just like an array The set will
grow dynamically when the elements are stored into it A set will not allow duplicate
elements

List: Lists are like sets but allow duplicate values to be stored
Queue: A Queue represents arrangement of elements in FIFO (First In First Out) order This
means that an element that is stored as a first element into the queue will be removed first
from the queue
Map: Maps store elements in the form of key value pairs If the key is provided its
corresponding value can be obtained

Retrieving Elements from Collections: Following are the ways to retrieve any element from
a collection object:
 74

Using Iterator interface

Using ListIterator interface
Using Enumeration interface

Iterator Interface: Iterator is an interface that contains methods to retrieve the elements one
by one from a collection object It retrieves elementsonly in forward direction It has 3
methods:
Method Description
boolean hasNext() This method returns true if the iterator has more elements
element next() This method returns the next element in the iterator
void remove() This method removes the last element from the collection
returned by the iterator

ListIterator Interface: ListIterator is an interface that contains methods to retrieve the

elements from a collection object, both in forward and reverse directions It can retrieve the
elements in forward and backward direction It has the following important methods:
Method Description
boolean hasNext() This method returns true if the ListIterator has more elements
when traversing the list in forward direction
element next() This method returns the next element
This method removes the list last element that was returned by
void remove() the
next () or previous () methods
boolean hasPrevious() This method returns true if the ListIterator has more elements
when traversing the list in reverse direction
element previous() This method returns the previous element in the list

Enumeration Interface: This interface is useful to retrieve elements one by one like Iterator
It has 2 methods
Method Description
boolean hasMoreElements() This method tests Enumeration has any more elements
element nextElement() This returns the next element that is available in Enumeration

HashSet Class: HashSet represents a set of elements (objects) It does not guarantee the order
of elements Also it does not allow the duplicate elements to be stored
· We can write the HashSet class as: class HashSet<T>
· We can create the object as: HashSet<String> hs = new HashSet<String> ();

HashSet();
HashSet (int capacity); Here capacity represents how many elements can be stored into th
HashSet initially This capacity may
: increase automatically when more
number of elements is being stored

Description
boolean add(obj) This method adds an element obj to the HashSet It returns true if the
element is added to the HashSet, else it returns false If the same
 75

element is already available in the HashSet, then the present element

is
not added
This method removes the element obj from the HashSet, if it is
boolean remove(obj) present It returns true if the element is removed successfully
otherwise false
void clear() This removes all the elements from the HashSet
boolean contains(obj) This returns true if the HashSet contains the specified element obj
boolean isEmpty() This returns true if the HashSet contains no elements
int size() This returns the number of elements present in the HashSet

Program 1: Write a program which shows the use of HashSet and Iterator
//HashSet Demo
import javautil*;
class HS
{public static void main(String args[])
{//create a HashSet to store Strings
HashSet <String> hs = new HashSet<String> ();
//Store some String elements
hsadd ("India");
hsadd ("America");
hsadd ("Japan");
hsadd ("China");
hsadd ("America");
//view the HashSet
Systemoutprintln ("HashSet = " + hs);
//add an Iterator to hs
Iterator it = hsiterator ();
//display element by element using Iterator
Systemoutprintln ("Elements Using Iterator: ");
while (ithasNext() )
{String s = (String) itnext ();
Systemoutprintln(s);
}
}
}
Output:
 76

LinkedHashSet Class: This is a subclass of HashSet class and does not contain any additional
members on its own LinkedHashSet internally uses a linked list to store the elements It is a
generic class that has the declaration:
class LinkedHashSet<T>

Stack Class: A stack represents a group of elements stored in LIFO (Last In First Out) order
This means that the element which is stored as a last element into the stack will be the first
element to be removed from the stack Inserting the elements (Objects) into the stack is called
push operation and removing the elements from stack is called pop operation Searching for an
element in stack is called peep operation Insertion and deletion of elements take place only
from one side of the stack, called top of the stack We can write a Stack class as:
class Stack<E>
eg: Stack<Integer> obj = new Stack<Integer> ();
Stack Class Methods:
Method Description
boolean empty() this method tests whether the stack is empty or not If the stack is
empty then true is returned otherwise false
element peek() this method returns the top most object from the stack without
removing it
this method pops the top-most element from the stack and returns
element pop() it
element push(element obj) this method pushes an element obj onto the top of the stack and
returns that element
int search(Object obj) This method returns the position of an element obj from the top of
the stack If the element (object) is not found in the stack then it
returns -1

Program 2: Write a program to perform different operations on a stack

//pushing, popping, searching elements in a stack
import javautil*;
class StackDemo
{
public static void main(String args[])
{//create an empty stack to contain Integer objects
Stack<Integer> st = new Stack<Integer>();
stpush (new Integer(10) );
stpush (new Integer(20)
); stpush (new
Integer(30) ); stpush
(new Integer(40) );
stpush (new Integer(50) );
Systemoutprintln (st);
Systemoutprintln ("Element at top of the stack is : " + stpeek() );
Systemoutprintln ("Removing element at the TOP of the stack : " + stpop());
Systemoutprintln ("The new stack is : " + st);
}
}
 77

Output:

LinkedList Class: A linked list contains a group of elements in the form of nodes Each node
will have three fields- the data field contatins data and the link fields contain references to
previous and next nodesA linked list is written in the form of:
class LinkedList<E>
we can create an empty linked list for storing String type elements (objects) as:
LinkedList <String> ll = new LinkedList<String> ();
LinkedList Class methods:
Method Description
boolean add (element obj) This method adds an element to the linked list It returns true if the
element is added successfully
This method inserts an element obj into the linked list at a
void add(int position, specified
element obj) position
void addFirst(element obj) This method adds the element obj at the first position of the linked
list
void addLast(element obj) This method adds the element obj at the last position of the linked
list
element removeFirst () This method removes the first element from the linked list and
returns it
element removeLast () This method removes the last element from the linked list and
returns it
element remove (int This method removes an element at the specified position in the
position) linked list
void clear () This method removes all the elements from the linked list
element get (int position) This method returns the element at the specified position in the
linked list
element getFirst () This method returns the first element from the list
element getLast () This method returns the last element from the list
This method replaces the element at the specified position in the
element set(int position, list
element obj) with the specified element obj
int size () Returns number of elements in the linked list
int indexOf (Object obj) This method returns the index of the first occurrence of the
specified element in the list, or -1 if the list does not contain the
element
This method returns the index of the last occurrence of the
int lastIndexOf (Object specified
obj) element in the list, or -1 if the list does not contain the element

.
 78

Object[] toArray() This method converts the linked list into an array of Object class
type All the elements of the linked list will be stored into the array
in the same sequence
Note: In case of LinkedList counting starts from 0 and we start counting from 1

Program 3: Write a program that shows the use of LinkedList class

import javautil*;
//Linked List
class LinkedDemo
{public static void main(String args[])
{LinkedList <String> ll = new LinkedList<String>();
lladd ("Asia");
lladd ("North America");
lladd ("South America");
lladd ("Africa");
lladdFirst ("Europe");
lladd (1,"Australia");
lladd (2,"Antarctica");
Systemoutprintln ("Elements in Linked List is : " + ll);
Systemoutprintln ("Size of the Linked List is : " + llsize() );
}
}
Output:

ArrayList Class: An ArrayList is like an array, which can grow in memory dynamically
ArrayList is not synchronized This means that when more than one thread acts simultaneously
on the ArrayList object, the results may be incorrect in some cases
ArrayList class can be written as: class ArrayList <E>
We can create an object to ArrayList as: ArrayList <String> arl = new ArrayList<String> ();
ArrayList Class
Methods:
Method Description
boolean add (element obj) This method appends the specified element to the end of the
ArrayList If the element is added successfully then the method
returns true
void add(int position, This method inserts the specified element at the specified positioin

element obj) in the ArrayList

element remove(int This method removes the element at the specified position in the
position) ArrayList and returns it
boolean remove (Object This method removes the first occurrence of the specified element
80
 79

. .

obj) obj from the ArrayList, if it is present

void clear () This method removes all the elements from the ArrayList
element set(int position, This method replaces an element at the specified position in the
element obj) ArrayList with the specified element obj
boolean contains (Object This method returns true if the ArrayList contains the specified
obj) element obj
element get (int position) This method returns the element available at the specified position
in the ArrayList
int size () Returns number of elements in the ArrayList
int indexOf (Object obj) This method returns the index of the first occurrence of the
specified element in the list, or -1 if the list does not contain the
element
This method returns the index of the last occurrence of the
int lastIndexOf (Object specified
obj) element in the list, or -1 if the list does not contain the element
Object[] toArray () This method converts the ArrayLlist into an array of Object class
type All the elements of the ArrayList will be stored into the array
in the same sequence

Program 4: Write a program that shows the use of ArrayList class

import javautil*;
//ArrayList Demo
class ArrayListDemo
{public static void main(String args[])
{ArrayList <String> al = new ArrayList<String>();
aladd ("Asia");
aladd ("North
America"); aladd
("South America");
aladd ("Africa"); aladd
("Europe"); aladd
(1,"Australia"); aladd
(2,"Antarctica");
Systemoutprint ("Size of the Array List is: " + alsize ());
Systemoutprint ("\nRetrieving elements in ArrayList using Iterator
:"); Iterator it = aliterator ();
while (ithasNext () )
Systemoutprint (itnext () + "\t");
}
}
Output:
 80

Vector Class: Similar to ArrayList, but Vector is synchronized It means even if several
threads act on Vector object simultaneously, the results will be reliable
Vector class can be written as: class Vector <E>
We can create an object to Vector
as: Vector <String> v = new Vector<String> ();
Vector Class Methods:
Method Description
This method appends the specified element to the end of the
boolean add(element obj) Vector
If the element is added successfully then the method returns true
void add (int position, This method inserts the specified element at the specified positioin
element obj) in the Vector
element remove (int This method removes the element at the specified position in the
position) Vector and returns it
boolean remove (Object This method removes the first occurrence of the specified element
obj) obj from the Vector, if it is present
void clear () This method removes all the elements from the Vector
element set (int position, This method replaces an element at the specified position in the
element obj) Vector with the specified element obj
boolean contains (Object This method returns true if the Vector contains the specified
obj) element obj
element get (int position) This method returns the element available at the specified position
in the Vector
int size () Returns number of elements in the Vector
int indexOf (Object obj) This method returns the index of the first occurrence of the
specified element in the Vector, or -1 if the Vector does not
contain
the element
This method returns the index of the last occurrence of the
int lastIndexOf (Object specified
obj) element in the Vector, or -1 if the Vector does not contain the
element
Object[] toArray ( ) This method converts the Vector into an array of Object class type
All the elements of the Vector will be stored into the array in the
same sequence
int capacity () This method returns the current capacity of the Vector

Program 5: Write a program that shows the use of Vector class

import javautil*;
//Vector Demo
class VectorDemo
{public static void main(String args[])
{Vector <Integer> v = new Vector<Integer> ();
int x[] = {10,20,30,40,50};
//When x[i] is stored into v below, x[i] values are converted into Integer Objects
//and stored into v This is auto boxing
for (int i = 0; i<xlength; i++)
vadd(x[i]);
Systemoutprintln ("Getting Vector elements using get () method: ");
 81

for (int i = 0; i<vsize(); i++)

Systemoutprint (vget (i) + "\t");
Systemoutprintln ("\nRetrieving elements in Vector using ListIterator :");
ListIterator lit = vlistIterator ();
while (lithasNext () )
Systemoutprint (litnext () + "\t");
Systemoutprintln ("\nRetrieving elements in reverse order using ListIterator
:"); while (lithasPrevious () )
Systemoutprint (litprevious () + "\t");
}
}
Output:

HashMap Class: HashMap is a collection that stores elements in the form of key-value pairs
If key is provided later its corresponding value can be easily retrieved from the HAshMap
Keys should be unique HashMap is not synchronized and hence while using multiple threads
on HashMap object, we get unreliable results
We can write HashMap class as: class HashMap<K, V>
For example to store a String as key and an integer object as its value, we can create the
HashMap as: HashMap<String, Integer> hm = new HashMap<String, Integer> ();
The default initial capacity of this HashMap will be taken as 16 and the load factor as 075
Load factor represents at what level the HashMap capacity should be doubled For example,
the product of capacity and load factor = 16 * 075 = 12 This represents that after storing 12th
key-value pair into the HashMap, its capacity will become 32
HashMap Class Methods:
Method Description
value put (key, value) This method stores key-value pair into the HashMap
value get (Object key) This method returns the corresponding value when key is given If
the key does not have a value associated with it, then it returns null
Set<K> keyset() This method, when applied on a HashMap converts it into a set
where only keys will be stored
Collection <V> values() This method, when applied on a HashMap object returns all the
values of the HashMap into a Collection object
value remove (Object key) This method removes the key and corresponding value from the
HashMap
void clear () This method removes all the key-value pairs from the map
boolean isEmpty () This method returns true if there are no key-value pairs in the
HashMap
int size () This method returns number of key-value pairs in the HashMap
83
 82

. .

Program 6: Write a program that shows the use of HashMap class

//HashMap Demo
import javautil*;
class HashMapDemo
{public static void main(String args[])
{HashMap<Integer, String> hm = new HashMap<Integer, String> ();
hmput (new Integer (101),"Naresh");
hmput (new Integer (102),"Rajesh");
hmput (new Integer (103),"Suresh");
hmput (new Integer (104),"Mahesh");
hmput (new Integer (105),"Ramesh");
Set<Integer> set = new
HashSet<Integer>(); set = hmkeySet();

Systemoutprintln (set);
}
}
Output:

Hashtable Class: Hashtable is a collection that stores elements in the form of key-value
pairs If key is provided later its corresponding value can be easily retrieved from the
HAshtable Keys should be unique Hashtable is synchronized and hence while using
multiple threads on Hashtable object, we get reliable results
We can write Hashtable class as: class Hashtable<K,V>
For example to store a String as key and an integer object as its value, we can create the
Hashtable as: Hashtable<String, Integer> ht = new Hashtable<String, Integer> ();
The default initial capacity of this Hashtable will be taken as 11 and the load factor as 075
Load factor represents at what level the Hashtable capacity should be doubled For example,
the product of capacity and load factor = 11 * 075 = 825 This represents that after storing
8th key-value pair into the Hashtable, its capacity will become 22
Hashtable Class Methods:
Method Description
value put(key, value) This method stores key-value pair into the Hashtable
value get(Object key) This method returns the corresponding value when key is given If
the key does not have a value associated with it, then it returns null
Set<K> keyset() This method, when applied on a Hashtable converts it into a set
where only keys will be stored
Collection <V> values() This method, when applied on a Hashtable object returns all the
values of the Hashtable into a Collection object
value remove(Object key) This method removes the key and corresponding value from the
Hashtable

.
 83

void clear() This method removes all the key-value pairs from the Hashtable
boolean isEmpty() This method returns true if there are no key-value pairs in the
Hashtable
int size() This method returns number of key-value pairs in the Hashtable

Program 7: Write a program that shows the use of Hashtable class

//Hashtable Demo
import javautil*;
class HashtableDemo
{public static void main(String args[])
{
Hashtable<Integer, String> ht = new Hashtable<Integer,
String> (); htput (new Integer (101),"Naresh");
htput (new Integer
(102),"Rajesh"); htput (new
Integer (103),"Suresh"); htput
(new Integer (104),"Mahesh");
htput (new Integer
(105),"Ramesh");
Enumeration e = htkeys ();
while ( ehasMoreElements () )
{
Integer i1 = (Integer) enextElement ();
Systemoutprintln (i1 + "\t" + htget (i1));
}
}
}
Output:

Arrays Class: Arrays class provides methods to perform certain operations on any single
dimensional array All the methods of the Arrays class are static, so they can be called in the
form of Arraysmethodname ()
Arrays Class Methods:
Method Description
static void sort (array) This method sorts all the elements of an array into ascending
order This method internally uses QuickSort algorithm
static void sort (array, int This method sorts the elements in the range from start to end
start, int end) within an array into ascending order

.
 84

static int binarySearch This method searches for an element in the array and returns its
(array, element) position number If the element is not found in the array, it returns
a negative value Note that this method acts only on an array
which is sorted in ascending order This method internally uses
BinarySearch algorithm
static boolean equals This method returns true if two arrays, that is array1 and array2
(array1, array2) are equal, otherwise false
static array copyOf (source- This method copies n elements from the source-array into another
array, int n) array and returns the array
static void fill (array, value) This method fills the array with the specified value It means that
all the elements in the array will receive that value

Program 8: Write a program to sort given numbers using sort () method of Arrays Class
import javautil*;
//Arrays Demo
class ArraysDemo
{public static void main(String args[])
{
int x[] =
{40,50,10,30,20};
Arrayssort( x );
for (int i=0;i<xlength;i++)
Systemoutprint(x[i] +
"\t");
}
}
Output:

StringTokenizer: The StringTokenizer class is useful to break a String into small pieces
called tokens We can create an object to StringTokenizer as:
StringTokenizer st = new StringTokenizer (str, "delimeter");
StringTokenizer Class Methods:
Method Description
String nextToken() Returns the next token from the StringTokenizer
boolean hasMoreTokens() Returns true if token is available and returns false if not available
int countTokens() Returns the number of tokens available

Program 9: Write a program that shows the use of StringTokenizer object

//cutting the String into tokens
import javautil*;
class STDemo
{
 85

public static void main(String args[])

{//take a String
String str = "Java is an OOP Language";
//brake wherever a space is found
StringTokenizer st = new StringTokenizer
(str," "); //retrieve tokens and display
Systemoutprintln ("The tokens are: ");

while ( sthasMoreTokens () )
{
String s = stnextToken
(); Systemoutprintln (s
);
}
}
}
Output:

Calendar: This class is useful to handle date and time We can create an object to Calendar
class
as: Calendar cl = CalendargetInstance ();
Calendar Class Methods:
Method Description
int get(Constant) This method returns the value of the given Calendar constant
Examples of Constants are CalendarDATE, CalendarMONTH,
CalendarYEAR, CalendarMINUTE, CalendarSECOND,
CalendarHour
void set(int field, int value) This method sets the given field in Calendar Object to the given
value For example, clset(CalendarDATE,15);
String toString() This method returns the String representation of the Calendar
object
This method compares the Calendar object with another object
boolean equals(Object obj) obj
and returns true if they are same, otherwise false

Program 10: Write a program to display System time and date

//To display system time and date
import javautil*;
class Cal
{public static void main(String args[])
{Calendar cl = CalendargetInstance ();

//Retrieve Date
 86

int dd = clget (CalendarDATE);

int mm = clget (CalendarMONTH);
++mm;
int yy = clget (CalendarYEAR);
Systemoutprintln ("Current Date is : " + dd + "-" + mm + "-" +
yy ); //Retrieve Time
int hh = clget (CalendarHOUR);
int mi = clget (CalendarMINUTE);
int ss = clget (CalendarSECOND);
Systemoutprintln ("Current Time is : " + hh + ":" + mi + ":" +ss);
}
}
Output:

Date Class: Date Class is also useful to handle date and time Once Date class object is
created, it should be formatted using the following methods of DateFormat class of javatext
packageWe
can create an object to Date class as: Date dd = new Date ();
Once Date class object is created, it should be formatted using the methods of DateFormat
class of javatext package
DateFormat class Methods:
DateFormat fmt = DateFormatgetDateInstance(formatconst, region);
This method is useful to store format information for date value into DateFormat object
fmt
DateFormat fmt = DateFormatgetTimeInstance(formatconst, region);
This method is useful to store format information for time value into DateFormat object
fmt
DateFormat fmt = DateFormatgetDateTimeInstance(formatconst, formatconst, region);
This method is useful to store format information for date value into DateFormat
object fmt
Formatconst Example (region=LocaleUK)
03 september
DateFormatFULL 2007 19:43:14 O'Clock GMT + 05:30
03 september
DateFormatLONG 2007 19:43:14 GMT + 05:30
03-sep-07
DateFormatMEDIUM 19:43:14
DateFormatSHORT 03/09/07 19:43

Program 11: Write a program that shows the use of Date class
//Display System date and time using Date class
import javautil*;
import javatext*;
class MyDate
{
public static void main(String args[])
 87

{Date d = new Date ();

DateFormat fmt = DateFormatgetDateTimeInstance (DateFormatMEDIUM,
DateFormatSHORT, LocaleUK);
String str = fmtformat (d);
Systemoutprintln (str);
}
}
Output:

Streams and Files

A Stream represents flow of data from one place to another place Input Streams reads or
accepts data Output Streams sends or writes data to some other place All streams are
represented as classes in javaio package The main advantage of using stream concept is to
achieve hardware independence This is because we need not change the stream in our
program even though we change the hardware Streams are of two types in Java:
Byte Streams: Handle data in the form of bits and bytes Byte streams are used to
handle any characters (text), images, audio and video files For example, to store an
image file (gif or
jpg), we should go for a byte stream To handle data in the form of 'bytes' the abstract
classes: InputStream and OutputStream are used The important classes of byte streams
are:
InputStream

FileInputStream FilterInputStream ObjectInputStream

BufferedInputStream DataInputStream

Byte Stream Classes for Reading Data

OutputStream

FileOutputStream FilterOutputStream ObjectOutputStream

|

BufferedOutputStream DataOutputStream