1. Introduction to Java Collections
Written by
Adam Carmi

2. Agenda About Collections Core Collection Interfaces Object Ordering
Collection, Set, List, Map
Object Ordering
Comparable, Comparator
More Core Collection interfaces
SortedSet, SortedMap
Implementations
Algorithms

3. What is a Collection Framework?
A collection (sometimes called a container) is an object that groups multiple elements into a single unit.
A collection framework is a unified architecture for representing and manipulating collections.
Java’s collection framework consists of
Collection interfaces
Concrete collection implementations (reusable data structures)
Algorithms (reusable functionality)
C++’s Standard Template Library is also a collection framework

4. Benefits of a Collection Framework
Reduces programming effort
Powerful data structures and algorithms
Increases program speed and quality
High quality implementations
Fine tuning by switching implementations
Reduces the effort of learning new APIs
Uniformity of the framework
APIs of applications
Encourages software reuse
New data structures and algorithms

5. Core Collection Interfaces
Collection interfaces allow collections to be manipulated independently of the details of their representation

6. The Collection Interface
Represents a group of objects, known as its elements.
The JDK does not provide any direct implementations of this interface.
Collection is used to pass collections around and manipulate them when maximum generality is desired.
java.util.Collection

7. Iterator A mechanism for iterating over a collection’s elements.
Represented by the Iterator interface.
Iterator allows the caller to remove elements from the underlying collection during the iteration with well-defined semantics
The only safe way to modify a collection during iteration
java.util.Iterator

8. Example: Iterator static void filter(Collection c) {
for (Iterator it = c.iterator() ; it.hasNext(); )
if (!cond(it.next()))
it.remove(); }
Iterator it = c.iterator();
while (it.hasNext())

9. The Set Interface A collection that can not contain duplicate keys.
Contains no methods other than those declared in the Collection interface.
Two set objects are equal if they contain the same elements, regardless of their implementations.
java.util.Set

10. Example: Set import java.util.*; public class FindDups {
public static void main(String args[]) {
Set s = new HashSet();
for (int i=0; i<args.length; i++)
if (!s.add(args[i]))
System.out.println("Duplicate detected: "
+ args[i]);
System.out.println(s.size() + " distinct words"
+ " detected: " + s); }

11. The List Interface An ordered collection (sometimes called a sequence)
Lists may contain duplicate elements
Collection operations
remove operation removes the first occurrence of the specified element
add and addAll operations always appends new elements to the end of the list.
Two List objects are equal if they contain the same elements in the same order.

12. The List Interface (cont)
New List operations
Positional access
Search
Iteration (ordered, backward)
Range-view operations
java.util.List
java.util.ListIterator

13. Calls to next and previous can be intermixed
Example: List
private static void swap(List a, int i, int j) {
Object tmp = a.get(i);
a.set(i, a.get(j));
a.set(j, tmp); }
for (ListIterator i=l.listIterator(l.size()); i.hasPrevious(); ) {
Foo f = (Foo)i.previous();
...
Calls to next and previous can be intermixed

14. Exampe: List (cont)
public static void replace(List l, Object val, List newVals) {
for (ListIterator i = l.listIterator(); i.hasNext() ; ) {
if (val==null ? i.next()==null : val.equals(i.next())) {
i.remove();
for (Iterator j = newVals.iterator(); j.hasNext(); )
i.add(j.next()); }
The add method inserts a new element into the list, immediately before the current cursor position

15. The Map Interface An object that maps keys to values.
A map cannot contain duplicate keys.
Each key cat map to at most one value.
Every object can be used as a hash key
public int Object.hashCode()
Equal objects (according to equals()) must produce the same hash code.
The same hash code must be returned by an object throughout the execution of a Java application.
Two Map objects are equal if they represent the same key-value mappings

16. The Map Interface (cont)
Collection-view methods allow a Map to be viewed as a Collection
keySet – The Set of keys contained in the Map
values – The Collection of values contained in the Map
entrySet – The Set of key-value pairs contained in the Map
With all three Collection-views, calling an Iterator's remove operation removes the associated entry from the backing Map.
This is the only safe way to modify a Map during iteration.
java.util.Map

17. Example: Map import java.util.*; public class Freq {
private static final Integer ONE = new Integer(1);
public static void main(String args[]) {
Map m = new HashMap();
for (int i=0; i<args.length; i++) {
Integer freq = (Integer)m.get(args[i]);
m.put(args[i], (freq==null ?
ONE : new Integer(freq.intValue() + 1))); }
System.out.println(m.size() + " distinct words detected:");
System.out.println(m);

18. Collection-views provide the only means to iterate over a Map.
Example: Map (cont)
for (Iterator i = m.keySet().iterator() ; i.hasNext() ; )
System.out.println(i.next());
for (Iterator i = m.values().iterator(); i.hasNext() ; )
for (Iterator i = m.entrySet().iterator(); i.hasNext() ; ) {
Map.Entry e = (Map.Entry)i.next();
System.out.println(e.getKey() + ": " + e.getValue()); }
Collection-views provide the only means to iterate over a Map.

19. Object Ordering
A natural ordering can be defined for a class by implementing the Comparable interface
Objects of classes that implement the Comparable interface may be sorted automatically
Many JDK1 classes implement the Comparable interface:
Integer
signed numerical
Double
String
lexicographic
Date
chronological
Java Development Kit

20. Object Ordering (cont)
The Comparable interface consists of a single method
public interface Comparable {
public int compareTo(Object o); }
Natural ordering is not always sufficient
Ordering objects in some order other than their natural order
Ordering objects that don't implement the Comparable interface
compareTo returns a negative integer, zero or a positive integer as the receiving object is less than, equal or greater than the input object

21. Object Ordering (cont)
A Comparator may be used to order objects when natural ordering does not suffice
public interface Comparable {
public int compare(Object o1, Object o2); }

22. Example: Comparable public class Name implements Comparable {
private String firstName, lastName;
...
public int compareTo(Object o) {
Name n = (Name)o;
int lastCmp = lastName.compareTo(n.lastName);
return lastCmp != 0 ? lastCmp :
firstName.compareTo(n.firstName); }

23. Example: Comparator
public class NameComparator implements Comparator {
public int compare(Object o1, Object o2) {
Name n1 = (Name)o1;
Name n2 = (Name)o2;
int lastCmp = n1.getLastName().compareTo(n2.getLastName());
return lastCmp != 0 ? lastCmp :
n1.getFirstName().compareTo(n2.getFirstName()); }

24. SortedSet Interface
A Set that maintains its elements in ascending order
according to elements' natural order
according to a Comparator provided at SortedSet creation time
Set operations
Iterator traverses the sorted set in order
Additional operations
Range view – range operations
Endpoints – return the first or last element
Comparator access
java.util.SortedSet

25. SortedMap Interface
A Map that maintains its entries in ascending order
According to keys' natural order
According to a Comparator provided at creation time.
Map operations
Iterator traverses elements in any of the sorted map's collection-views in key-order.
Additional Operations
Range view
End points
Comparator access
java.util.SortedMap

26. Implementations
Implementations are the actual data objects used to store elements
Implement the core collection interfaces
There are three kinds of implementations
General purpose implementations
Wrapper implementations
Convenience implementations
Lesson: Implementations

27. General Purpose Implementations
Hash Table
Resizeable Array
Balanced Tree
Linked List
Interfaces
Set
HashSet
TreeSet
List
ArrayList
LinkedList
Map
HashMap
TreeMap

28. Older Implementations
The collections framework was introduced in JDK1.2.
Earlier JDK versions included collection implementations that were not part of any framework
java.util.Vector
java.util.Hashtable
These implementations were extended to implement the core interfaces but still have all their legacy operations
Be careful to always manipulate them only through the core interfaces.

29. Algorithms
Polymorphic algorithms are pieces of reusable functionality provided by the JDK.
defined as static methods of the Collections class
Provided algorithms
Sorting
Shuffling
Data manipulation
reverse, fill, copy
Searching
Extreme values
Lesson: Algorithms

30. Example: Algorithms
public static void sortNames(Name[] names) {
List l = Arrays.asList(names);
Collections.sort(l); }
Collections.sort(l, new Comparator() {
public int compare(Object o1, Object o2) {
Name n1 = (Name)o1;
Name n2 = (Name)o2;
int lastCmp = n1.getLastName().compareTo(n2.getLastName());
return lastCmp != 0 ? lastCmp :
n1.getFirstName().compareTo(n2.getFirstName());
}});
Arrays.asList is a Convenience implementation of the List interface
API Bridge
Performance