UNIT IV

Java Collections

Collections Overview
The Java Collections Framework standardizes the way in which groups of objects are handled
by your programs.
The Collections Framework was designed to meet several goals.
First, the framework had to be high-performance. The implementations for the fundamental
collections (dynamic arrays, linked lists, trees, and hash tables) are highly efficient.
Second, the framework had to allow different types of collections to work in a similar manner
and with a high degree of interoperability.
Third, extending and/or adapting a collection had to be easy. Toward this end, the entire
Collections Framework is built upon a set of standard interfaces.

Algorithms are another important part of the collection mechanism. Algorithms operate on
collections and are defined as static methods within the Collections class. Thus, they are
available for all collections. Each collection class need not implement its own versions. The
algorithms provide a standard means of manipulating collections.

Another item closely associated with the Collections Framework is the Iterator interface. An
iterator offers a general-purpose, standardized way of accessing the elements within a
collection, one at a time. Thus, an iterator provides a means of enumerating the contents of a
collection. Because each collection implements Iterator, the elements of any collection class
can be accessed through the methods defined by Iterator. Thus, with only small changes, the
code that cycles through a set can also be used to cycle through a list, for example. Iterator
interface provides the facility of iterating the elements in forward direction only. There are only Collection Interfaces:
three methods in the Iterator interface. They are:
1. public boolean hasNext() it returns true if iterator has more elements. The Collection interface:
2. public object next() it returns the element and moves the cursor pointer to the next The Collection interface is the foundation upon which the collections framework is built. It
element. declares the core methods that all collections will have. These methods are summarized in the
3. public void remove() it removes the last elements returned by the iterator. It is rarely following.
used.
Hierarchy of Collection Framework boolean add(Object obj)
Let us see the hierarchy of collection framework. The java.util package contains all the classes Adds obj to the invoking collection. Returns true if obj was added to the collection. Returns
and interfaces for Collection framework. false if obj is already a member of the collection, or if the collection does not allow duplicates.

boolean addAll(Collection c)
Adds all the elements of c to the invoking collection. Returns true if the operation succeeded
(i.e., the elements were added). Otherwise, returns false.

Iterator iterator( )
Returns an iterator for the invoking collection.
boolean remove(Object obj)
Removes one instance of obj from the invoking collection. Returns true if the element was List subList(int start, int end)
removed. Otherwise, returns false. Returns a list that includes elements from start to end.1 in the invoking list. Elements in the
returned list are also referenced by the invoking object.
boolean removeAll(Collection c)
Removes all elements of c from the invoking collection. Returns true if the collection changed Set Interface:
(i.e., elements were removed). Otherwise, returns false. A Set is a Collection that cannot contain duplicate elements. It models the mathematical set
abstraction.
int size( ) The Set interface contains only methods inherited from Collection and adds the restriction
Returns the number of elements held in the invoking collection. that duplicate elements are prohibited.
add( )
Object[ ] toArray( ) Adds an object to the collection
Returns an array that contains all the elements stored in the invoking collection. The array
elements are copies of the collection elements. clear( )
The List interface: Removes all objects from the collection
The List interface extends Collection and declares the behavior of a collection that stores a
sequence of elements. contains( )
Elements can be inserted or accessed by their position in the list, using a zero-based Returns true if a specified object is an element within the collection
index.
A list may contain duplicate elements. remove( )
In addition to the methods defined by Collection, List defines some of its own, which Removes a specified object from the collection
are summarized in the following below Table. Example:
Several of the list methods will throw an UnsupportedOperationException if the Set have its implementation in various classes like HashSet, TreeSet, LinkedHashSet.
collection cannot be modified, and a ClassCastException is generated when one Following is the example to explain Set functionality:
object is incompatible with another.
Object get(int index) import java.util.*;
public class SetDemo {
Returns the object stored at the specified index within the invoking collection. public static void main(String args[]) {
int count[] = {34, 22,10,60,30,22};
int indexOf(Object obj) Set<Integer> set = new HashSet<Integer>();
Returns the index of the first instance of obj in the invoking list. If obj is not an element of the try{
for(int i = 0; i<5; i++){
list, .1 is returned.
set.add(count[i]);
}
int lastIndexOf(Object obj) System.out.println(set);
Returns the index of the last instance of obj in the invoking list. If obj is not an element of the TreeSet sortedSet = new TreeSet<Integer>(set);
list, .1 is returned. System.out.println("The sorted list is:");
System.out.println(sortedSet);
System.out.println("The First element of the set is: "+
ListIterator listIterator( ) (Integer)sortedSet.first());
Returns an iterator to the start of the invoking list. System.out.println("The last element of the set is: "+
(Integer)sortedSet.last());
}
ListIterator listIterator(int index)
catch(Exception e){}
Returns an iterator to the invoking list that begins at the specified index. }
}
Object set(int index, Object obj)
Assigns obj to the location specified by index within the invoking list. The Map interface:
The Map interface maps unique keys to values. A key is an object that you use to retrieve a Returns a collection containing the values in the map. This method provides a collection-view
value at a later date. of the values in the map.
Given a key and a value, you can store the value in a Map object. After the value is Example:
stored, you can retrieve it by using its key.
Several methods throw a NoSuchElementException when no items exist in the import java.util.*;
invoking map. public class CollectionsDemo {
A ClassCastException is thrown when an object is incompatible with the elements in a public static void main(String[] args) {
map. Map m1 = new HashMap();
A NullPointerException is thrown if an attempt is made to use a null object and null is m1.put("Zara", "8");
not allowed in the map. m1.put("Mahnaz", "31");
void clear( ) m1.put("Ayan", "12");
Removes all key/value pairs from the invoking map. m1.put("Daisy", "14");
System.out.println();
boolean containsKey(Object k) System.out.println(" Map Elements");
Returns true if the invoking map contains k as a key. Otherwise, returns false. System.out.print("\t" + m1);
}
boolean containsValue(Object v) }
Returns true if the map contains v as a value. Otherwise, returns false

Object get(Object k) R The Queue Interface

eturns the value associated with the key k. The Queue interface extends Collection and declares the behavior of a queue, which is often
a first-in, first-out list. However, there are types of queues in which the ordering is based upon
int hashCode( ) other criteria. Queue is a generic interface that has this declaration:
Returns the hash code for the invoking map. interface Queue<E>

Set keySet( )
Returns a Set that contains the keys in the invoking map. This method provides a set-view of
the keys in the invoking map.

Object put(Object k, Object v)

Puts an entry in the invoking map, overwriting any previous value associated with the key. The
key and value are k and v, respectively. Returns null if the key did not already exist. Otherwise,
the previous value linked to the key is returned.
Since Queue is an interface you need to instantiate a concrete implementation of the interface
void putAll(Map m) in order to use it. You can choose between the following Queue implementations in the Java
Puts all the entries from m into this map. Collections API:
java.util.LinkedList
Object remove(Object k) java.util.PriorityQueue
Removes the entry whose key equals k.
import java.util.*;
int size( ) public class QueueDemo {
Returns the number of key/value pairs in the map. static String newLine = System.getProperty("line.separator");
public static void main(String[] args) {
Collection values( ) System.out.println(newLine + "Queue in Java" + newLine);
 System.out.println("-----------------------" + newLine); created with an initial size. When this size is exceeded, the collection is automatically enlarged.
System.out.println("Adding items to the Queue" + newLine); When objects are removed, the array can be shrunk.
//Creating queue would require you to create instannce of LinkedList and assign ArrayList has the constructors shown here:
//it to Queue ArrayList( )
//Object. You cannot create an instance of Queue as it is abstract ArrayList(Collection<? extends E> c)
Queue queue = new LinkedList(); ArrayList(int capacity)
//you add elements to queue using add method import java.util.*;
queue.add("Java"); class ArrayListDemo {
queue.add(".NET"); public static void main(String args[]) {
queue.add("Javascript"); // Create an array list.
queue.add("HTML5"); ArrayList<String> al = new ArrayList<String>();
queue.add("Hadoop"); System.out.println("Initial size of al: " +
System.out.println(newLine + "Items in the queue..." + queue + newLine); al.size());
//You remove element from the queue using .remove method // Add elements to the array list.
//This would remove the first element added to the queue, here Java al.add("C");
System.out.println("remove element: " + queue.remove() + newLine); al.add("A");
//.element() returns the current element in the queue, here when "java" is removed al.add("E");
//the next most top element is .NET, so .NET would be printed. al.add("B");
System.out.println("retrieve element: " + queue.element() + newLine); al.add("D");
//.poll() method retrieves and removes the head of this queue al.add("F");
//or return null if this queue is empty. Here .NET would be printed and then would al.add(1, "A2");
//be removed System.out.println("Size of al after additions: " +
//from the queue al.size());
System.out.println("remove and retrieve element, null if empty: " + queue.poll() + // Display the array list.
newLine); System.out.println("Contents of al: " + al);
//.peek() just returns the current element in the queue, null if empty // Remove elements from the array list.
//Here it will print Javascript as .NET is removed above al.remove("F");
System.out.println("retrieve element, null is empty " + queue.peek() + newLine); al.remove(2);
} System.out.println("Size of al after deletions: " +
} al.size());
System.out.println("Contents of al: " + al);
Collection Classes: }
}
The ArrayList Class: Convert an ArrayList into an array.
The ArrayList class extends AbstractList and implements the List interface. ArrayList is a import java.util.*;
generic class that has this declaration: class ArrayListToArray {
class ArrayList<E> public static void main(String args[]) {
Here, E specifies the type of objects that the list will hold. // Create an array list.
ArrayList supports dynamic arrays that can grow as needed. In Java, standard arrays are of a ArrayList<Integer> al = new ArrayList<Integer>();
fixed length. After arrays are created, they cannot grow or shrink, which means that you must // Add elements to the array list.
know in advance how many elements an array will hold. But, sometimes, you may not know al.add(1);
until run time precisely how large an array you need. To handle this situation, then Collections al.add(2);
Framework defines ArrayList. In essence, an ArrayList is a variable-length array of object al.add(3);
references. That is, an ArrayList can dynamically increase or decrease in size. Array lists are al.add(4);
System.out.println("Contents of al: " + al); System.out.print("pop -> ");
// Get the array. Integer a = st.pop();
Integer ia[] = new Integer[al.size()]; System.out.println(a);
ia = al.toArray(ia); System.out.println("stack: " + st);
int sum = 0; }
// Sum the array. public static void main(String args[]) {
for(int i : ia) sum += i; Stack<Integer> st = new Stack<Integer>();
System.out.println("Sum is: " + sum); System.out.println("stack: " + st);
} showpush(st, 42);
} showpush(st, 66);
Linked list: showpush(st, 99);
A linked list is a data structure used for collecting a sequence of objects that allows efficient showpop(st);
addition and removal of elements in the middle of the sequence. showpop(st);
Rather than storing the values in an array, a linked list uses a sequence of nodes. Each node showpop(st);
stores a value and a reference to the next node in the sequence . When you insert a new node try {
into a linked list, only the neighbouring node references need to be updated. The same is true showpop(st);
} catch (EmptyStackException e) {
but element access can be slow. System.out.println("empty stack");
}
}
}

Stack:
Stack is a subclass of Vector that implements a standard last-in, first-out stack. Stack only
defines the default constructor, which creates an empty stack.
class Stack<E>
Here, E specifies the type of element stored in the stack.

import java.util.*;
class StackDemo {
static void showpush(Stack<Integer> st, int a) {
st.push(a);
System.out.println("push(" + a + ")");
System.out.println("stack: " + st);
}
static void showpop(Stack<Integer> st) {