Core Java
Collections
CONFIDENTIAL: For limited circulation only Slide 1
Lesson Objective
● The Collection API
● Collection Interface
● Generics
● Enhanced For loop
● Auto-boxing with Collections
● Implementing classes
● The Legacy Classes and Interfaces
● Arrays and Collections
CONFIDENTIAL: For limited circulation only Slide 2
Collections Framework
● A Collection is a group of objects.
● Collections framework provides a a set of standard utility classes
to manage collections.
● Collection is used to store, retrieve objects, and to transmit them
from one method to another.
● Collections Framework consists of three parts:
● Core Interfaces
● Concrete Implementation
● Algorithms such as searching and sorting
CONFIDENTIAL: For limited circulation only Slide 3
Advantages of Collections
• Reduces programming effort by providing useful data structures and
algorithms so you do not have to write them yourself.
• Increases performance by providing high-performance implementations
of useful data structures and algorithms.
• Provides interoperability between unrelated APIs by establishing a
common language to pass collections back and forth.
• Reduces the effort required to learn APIs by eliminating the need to
learn multiple ad hoc collection APIs.
• Reduces the effort required to design and implement APIs by
eliminating the need to produce ad hoc collections APIs.
• Fosters software reuse by providing a standard interface for collections
and algorithms to manipulate them.
CONFIDENTIAL: For limited circulation only Slide 4
Interfaces and Implementations
Fig:1
Fig:3
Fig:2
CONFIDENTIAL: For limited circulation only Slide 5
Collection Interfaces
● Let us discuss some of the collection interfaces:
CONFIDENTIAL: For limited circulation only Slide 6
Illustration of List, Set, and Map
CONFIDENTIAL: For limited circulation only Slide 7
Collection Implementations
CONFIDENTIAL: For limited circulation only Slide 8
Collection Implementations
● HashSet: A HashSet is an unsorted, unordered Set.
It uses the hashcode of the object being inserted, so the more efficient
your hashCode() implementation is, the better access performance you
will get.
Use this class when you want a collection with no duplicates and you do
not care about order when you iterate through it.
● LinkedHashSet: A LinkedHashSet is an ordered version of HashSet that
maintains a doubly-linked List across all elements.
Use this class instead of HashSet when you care about the iteration order.
When you iterate through a HashSet the order is unpredictable, while a
LinkedHashSet lets you iterate through the elements in the order in which
they were inserted.
CONFIDENTIAL: For limited circulation only Slide 9
Collection Implementations
● TreeSet: A TreeSet stores objects in a sorted sequence. It stores its
elements in a tree and they are automatically arranged in a sorted order.
● ArrayList: Think of this as a growable array. It gives you fast iteration and
fast random access. It is an ordered collection (by index).
However, it is not sorted. ArrayList now implements the new
RandomAccess interface — a marker interface (meaning it has no
methods) that says, “this list supports fast (generally constant time)
random access.”
Choose this over a LinkedList when you need fast iteration but are not as
likely to be doing a lot of insertion and deletion.
● LinkedList: A LinkedList is ordered by index position, like ArrayList,
except that the elements are doubly-linked to one another.
CONFIDENTIAL: For limited circulation only Slide 10
Collection Implementations
● HashMap: The HashMap gives you an unsorted, unordered Map. When you
need a Map and you do not care about the order (when you iterate
through it), then HashMap is the way to go.
The other maps add a little more overhead. Where the keys land in the
Map is based on the key’s hashcode. So, like HashSet, the more efficient
your hashCode() implementation, the better access performance you will
get. HashMap allows one null key and multiple null values in a collection.
● TreeMap: TreeMap is a sorted Map.
● LinkedHashMap: Like its Set counterpart, LinkedHashSet, the LinkedHash-
Map collection maintains insertion order (or, optionally, access order).
Although it will be somewhat slower than HashMap for adding and
removing elements, you can expect faster iteration with a
LinkedHashMap.
CONFIDENTIAL: For limited circulation only Slide 11
Collection Interface methods
CONFIDENTIAL: For limited circulation only Slide 12
Demo :ArrayListDemo
Demo:
ArrayListSemo.java
ArrayListDemo.java
CONFIDENTIAL: For limited circulation only Slide 13
Iterators
● Iterator is an object that enables you to traverse through a
collection.
● It can be used to remove elements from the collection selectively,
if desired.
public interface Iterator<E>
{
boolean hasNext(); //returns true if there are more elements
E next(); // returns next element
void remove(); // remove element from collection
}
CONFIDENTIAL: For limited circulation only Slide 14
Demo :Iterators
Demo:
ItTest.java
ItTest.java
CONFIDENTIAL: For limited circulation only Slide 15
Comparator Interface
● The java.util.Comparator interface can be used to sort the
elements of an Array or a list in the required way.
● It gives you the capability to sort a given collection in any number
of different ways.
● Methods defined in Comparator Interface are as follows:
● int compare(Object o1, Object o2)
obj1 and obj2 are the objects to be compared. This method returns zero if
the objects are equal. It returns a positive value if obj1 is greater than
obj2. Otherwise, a negative value is returned.
● boolean equals(Object obj)
obj is the object to be tested for equality. The method returns true if obj
and the invoking object are both Comparator objects and use the same
ordering. Otherwise, it returns false.
CONFIDENTIAL: For limited circulation only Slide 16
Demo :Comparator
Demo:
ComparatorExample.java
ComparatorExample.java
CONFIDENTIAL: For limited circulation only Slide 17
Generics
● Generics is a mechanism by which a single piece of code can
manipulate many different data types without explicitly having a
separate entity for each data type.
● Before Generics:
List myIntegerList = new LinkedList(); // 1
myIntegerList.add(new Integer(0)); // 2
Integer x = (Integer) myIntegerList.iterator().next(); // 3
Note: Line no 3 if not properly typecasted will throw runtime exception
● After Generics:
List<Integer> myIntegerList = new LinkedList<Integer>(); // 1
myIntegerList.add(new Integer(0)); //2
Integer x = myIntegerList.iterator().next(); // 3
CONFIDENTIAL: For limited circulation only Slide 18
Why Generics?
● Problem: Collection element types:
● Compiler is unable to verify types.
● Assignment must have type casting.
● ClassCastException can occur during runtime.
● Solution: Generics
● Tell the compiler type of the collection.
● Let the compiler fill in the cast.
Example: Compiler will check if you are adding Integer type entry to a
String type collection (compile time detection of type mismatch).
CONFIDENTIAL: For limited circulation only Slide 19
Using Generics
● You can instantiate a generic class to create type specific object.
● In J2SE 5.0, all collection classes are rewritten to be generic classes.
● Example:
Vector<String> vs = new Vector<String>();
vs.add(new Integer(5)); // Compile error!
vs.add(new String(“hello”));
String s = vs.get(0); // No casting needed
CONFIDENTIAL: For limited circulation only Slide 20
Using Generics
● Generic class can have multiple type parameters.
● Type argument can be a custom type.
● Example:
HashMap<String, Mammal> map =
new HashMap<String, Mammal>();
map.put(“wombat”, new Mammal("wombat"));
Mammal w = map.get(“wombat”);
CONFIDENTIAL: For limited circulation only Slide 21
Enhanced for loop
● Iterating over collections looks cluttered:
void printAll(Collection<emp> e) {
for (Iterator<emp> i = e.iterator(); i.hasNext(); )
System.out.println(i.next()); } }
● Using enhanced for loop, we can do the same thing as:
void printAll(Collection<emp> e) {
for (emp t : e) )
System.out.println(t); }}
● When you see the colon (:) read it as “in.”
● The loop above reads as “for each emp t in e.”
● The enhanced for loop can be used for both Arrays and Collections
CONFIDENTIAL: For limited circulation only Slide 22
Implementing Classes
● ArryaList
● HashSet
● TreeSet
● HashMap
CONFIDENTIAL: For limited circulation only Slide 23
ArrayList Class
● An ArrayList Class can grow dynamically.
● It provides more powerful insertion and search mechanisms than
arrays.
● It gives faster Iteration and fast random access.
● It uses Ordered Collection (by index), but not Sorted.
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(0, new Integer(42));
int total = list.get(0).intValue();
CONFIDENTIAL: For limited circulation only Slide 24
Demo : ArrayList Class
Demo:
ArrayListTest.java
ArrayListDemo.java
CONFIDENTIAL: For limited circulation only Slide 25
HashSet Class
● HashSet Class does not allow duplicates.
● A HashSet is an unsorted, unordered Set.
● It can be used when you want a collection with no duplicates and
you do not care about the order when you iterate through it.
CONFIDENTIAL: For limited circulation only Slide 26
Demo : HashSet Class
Demo:
SetTest.java
SetTest.java
CONFIDENTIAL: For limited circulation only Slide 27
TreeSet Class
● TreeSet does not allow duplicates.
● It iterates in sorted order.
● Sorted Collection:
● By default elements will be in ascending order.
● Not synchronized:
● If more than one thread wants to access it at the same time, then it
must be synchronized externally.
CONFIDENTIAL: For limited circulation only Slide 28
Demo : TreeSet Class
Demo:
TreesetDemo.java
TreesetDemo.java
CONFIDENTIAL: For limited circulation only Slide 29
HashMap Class
● Map is an object that stores key/value pairs.
● Given a key, you can find its value. Keys must be unique, however
values may be duplicated
● HashMap uses the hashcode value of an object to determine how
the object should be stored in the collection.
● Hashcode is used again to help locate the object in the collection.
● HashMap gives you an unsorted and unordered Map.
● It allows one null key and multiple null values in a collection.
CONFIDENTIAL: For limited circulation only Slide 30
Demo : HashMap Class
Demo:
HashMapDemo.java
HashMapDemo.java
CONFIDENTIAL: For limited circulation only Slide 31
Vector Class
● The java.util.Vector class implements a growable array of
Objects.
● It is same as ArrayList. However, Vector methods are synchronized
for thread safety.
● New java.util.Vector is implemented from List Interface.
● Creation of a Vector:
● Vector v1 = new Vector(); // allows old or new methods
● List v2 = new Vector(); // allows only the new (List) methods.
CONFIDENTIAL: For limited circulation only Slide 32
Demo : Vector Class
Demo:
VectorDemo.java
VectorDemo.java
CONFIDENTIAL: For limited circulation only Slide 33
Hashtable Class
● It is a part of java.util package.
● It implements a hashtable, which maps keys to values.
● Any non-null object can be used as a key or as a value.
● The Objects used as keys must implement the hashcode and the
equals method.
● Synchronized class
● The Hashtable class only stores objects that override the
hashCode() and equals() methods that are defined by Object.
CONFIDENTIAL: For limited circulation only Slide 34
Demo : HashTable Class
Demo:
HashTableDemo.java
HashTableDemo.java
CONFIDENTIAL: For limited circulation only Slide 35
Arrays Class
● The java.util.Arrays class is basically a set of static methods that
are all useful for working with arrays.
● The Arrays class contains various methods for manipulating arrays
such as sorting and searching
● In addition to that, it has got many utility methods for using with
arrays such as a method for viewing arrays as lists and methods for
printing the contents of an array, whatever be the dimension of
the array.
CONFIDENTIAL: For limited circulation only Slide 36
Demo : Arrays Class
Demo:
ArraysMethodTester.java
ArraysMethodTester.java
CONFIDENTIAL: For limited circulation only Slide 37
Collections Class
● The java.util.Collections class is basically a set of static methods
which operates on Collection.
● The Collections class contains various methods for manipulating
collections such as reverse, sort, max, min, binarySearch etc.
CONFIDENTIAL: For limited circulation only Slide 38
Demo : Collections Class
Demo:
CollectionsDemo.java
CollectionsDemo.java
CONFIDENTIAL: For limited circulation only Slide 39
Common Best Practices on Collections
● Let us discuss some of the best practices on Collections:
● Use for-each liberally.
● Presize collection objects.
● Note that Vector and HashTable is costly. Collection Best Practices.txt
● Note that LinkedList is the worst performer.
● Choose the right Collection.
● Note that adding objects at the beginning of the collections is
considerably slower than adding at the end.
● Encapsulate collections.
● Use thread safe collections when needed.
CONFIDENTIAL: For limited circulation only Slide 40
