1. Collections CS3250

2. Sources  Slides by Professor Chuck Allison  Core Java, by Cay S. Horstmann and Gary Cornell  The Java Tutorial  http://java.sun.com/docs/books/tutorial/index.html

3. Outline  java.util.Arrays  Comparing objects  Generics  Collections  java.util.Collections  Maps

4. java.util.Arrays  Binary search  equals  fill  sort  asList  toString

5. Comparing objects  Comparable – implemented in class of objects being compared  Comparator – implemented in class that is separate from the class of the objects being compared public interface Comparable { public int compareTo(T o); } public interface Comparator { public int compare(T o1, T o2); } "natural ordering"

6. Generics  New in Java 1.5  Generic programming: write code that can be reused for objects of many different types -- Core Java (7 th ed., p. 707)

7. Example  The old way:  With generics: List inventory = new LinkedList(); inventory.add("Brass Lantern");... String item = (String) inventory.get(0); List inventory = new LinkedList (); inventory.add("Brass Lantern");... String item = inventory.get(0);

8. Advantages?  The old way:  With generics: List inventory = new LinkedList(); inventory.add("Brass Lantern");... String item = (String) inventory.get(0); List inventory = new LinkedList (); inventory.add("Brass Lantern");... String item = inventory.get(0);

9. Advantages  No casts needed  Compiler can check types List inventory = new LinkedList(); inventory.add("Brass Lantern");... String item = (String) inventory.get(0); List inventory = new LinkedList (); inventory.add("Brass Lantern");... String item = inventory.get(0);

10. Iterators  Used to traverse collections  How can a method be optional when implementations are required for every method in the interface? public interface Iterator { boolean hasNext(); E next(); void remove(); //optional }

11. Using iterators  Should always call hasNext before calling next  Otherwise could get NoSuchElement exception  Can use "for each" loop with any object that implements Iterable interface Iterator iter = c.iterator(); while (iter.hasNext()) { String element = (String) iter.next(); // Do something with element } for (String element: c) { // Do something with element }

12. Iterators: C++ vs. Java C++: iterators are modeled after array indexes (pointers)  Can advance position independently of accessing element Java: like reading from a file  Accessing elements and advancing position are inseparable  Iterator is always "between" elements Iterator iter = c.iterator(); while (iter.hasNext()) { String element = iter.next(); // Do something with element } vector ::iterator iter; for (iter = v.begin(); iter != v.end(); iter++) { cout << *iter; // Do more stuff with *iter } Groucho Harpo Chico Groucho Harpo Chico

13. Collections  Interfaces  Implementations  List  Set  Queue  Map

14. Separating interfaces and implementations  Specify implementation only when you construct the collection object:  Why is this a good approach? List inventory = new LinkedList (); inventory.add("Brass Lantern);

15. Interface Hierarchy Collection ListSet SortedSet Queue Map SortedMap

16. public interface Collection extends Iterable { // Basic operations int size(); boolean isEmpty(); boolean contains(Object element); boolean add(E element); //optional boolean remove(Object element); //optional Iterator iterator(); // Bulk operations boolean containsAll(Collection c); boolean addAll(Collection c); //optional boolean removeAll(Collection c); //optional boolean retainAll(Collection c); //optional void clear(); //optional // Array operations Object[] toArray(); T[] toArray(T[] a); }

17. public interface Collection extends Iterable { // Basic operations int size(); boolean isEmpty(); boolean contains(Object element); boolean add(E element); //optional boolean remove(Object element); //optional Iterator iterator(); // Bulk operations boolean containsAll(Collection c); boolean addAll(Collection c); //optional boolean removeAll(Collection c); //optional boolean retainAll(Collection c); //optional void clear(); //optional // Array operations Object[] toArray(); T[] toArray(T[] a); }

18. public interface Collection extends Iterable { // Basic operations int size(); boolean isEmpty(); boolean contains(Object element); boolean add(E element); //optional boolean remove(Object element); //optional Iterator iterator(); // Bulk operations boolean containsAll(Collection c); boolean addAll(Collection c); //optional boolean removeAll(Collection c); //optional boolean retainAll(Collection c); //optional void clear(); //optional // Array operations Object[] toArray(); T[] toArray(T[] a); } For more information about generic wildcards ( ? and ? extends E ) see http://docs.oracle.com/javase/tutorial/ extra/generics/subtype.html

19. public interface Collection extends Iterable { // Basic operations int size(); boolean isEmpty(); boolean contains(Object element); boolean add(E element); //optional boolean remove(Object element); //optional Iterator iterator(); // Bulk operations boolean containsAll(Collection c); boolean addAll(Collection c); //optional boolean removeAll(Collection c); //optional boolean retainAll(Collection c); //optional void clear(); //optional // Array operations Object[] toArray(); T[] toArray(T[] a); }

20. public interface Collection extends Iterable { // Basic operations int size(); boolean isEmpty(); boolean contains(Object element); boolean add(E element); //optional boolean remove(Object element); //optional Iterator iterator(); // Bulk operations boolean containsAll(Collection c); boolean addAll(Collection c); //optional boolean removeAll(Collection c); //optional boolean retainAll(Collection c); //optional void clear(); //optional // Array operations Object[] toArray(); T[] toArray(T[] a); } What do these optional methods have in common?

21. Implementations InterfaceImplementations Hash tableResizable array TreeLinked listHash table + linked list SetHashSetTreeSetLinkedHashSet ListArrayListLinkedList QueueLinkedList MapHashMapTreeMapLinkedHashMap

22. List  Ordered Collection  Allows duplicate elements  Provides positional access  Permits arbitray range operations (sublists) pie ice cream cake 0123 System.out.println(list.get(2)); pie

23. List implementations  LinkedList  Quickly add and remove elements anywhere in the list  Not well-suited for random access ("staggeringly inefficient")  ArrayList  Works well for random access  Takes more time to add and remove elements (except at the end)

24. List iterators public interface ListIterator extends Iterator { boolean hasNext(); E next(); boolean hasPrevious(); E previous(); int nextIndex(); int previousIndex(); void remove(); //optional void set(E e); //optional void add(E e); //optional } element = iter.next() System.out.println(element); iter.remove(); Groucho Harpo Chico Can move forward or backward Must call next (or previous ) before calling remove. remove deletes the element just accessed. Must call next (or previous ) before calling remove. remove deletes the element just accessed.

25. Set  Set interface contains only methods from Collection.  Cannot contain duplicate elements.  Two sets are equal if they contain the same elements. (Order is not important.) pie ice cream cake

26. Set implementations  HashSet – best performance, "chaotic ordering"  LinkedList – substantially slower, orders elements based on values  LinkedHashSet – orders elements based on order of insertion into the set, performance almost as good as HashSet

27. Set operations  s1.containsAll(s2) – Returns true if s2 is subset of s1  s1.addAll(s2) – Transforms s1 into union of s1 and s2  s1.retainAll(s2) – Transforms s1 into intersection of s1 and s2  s1.removeAll(s2) – Transforms s1 into the set difference of s1 and s2

28. Queue  "A collection for holding elements prior to processing" (Java Tutorial)  Typically use FIFO ordering, but there are other orderings (e.g., priority queue)  Ordering determines where an element will be added and which element will be deleted. public interface Queue extends Collection { E element(); boolean offer(E e); E peek(); E poll(); E remove(); }

29. Two forms of queue methods  offer is intended only for use on bounded (fixed size) queues. Returns false if element cannot be added.  remove and poll remove and return the head of the queue, which is determined by the queue's ordering.  poll and peek return null if the queue is empty Throws exceptionReturns special value Insert add(e)offer(e) Remove remove()poll() Examine element()peek()

30. java.util.Collections  Sorting  merge sort: fast (n log(n)) and stable  Shuffling  "Routine data manipulations"  reverse, fill, copy, swap, addAll  Searching – binarySearch  Composition  frequency, disjoint

31. Maps  Stores key/value pairs of objects  Duplicate keys are not allowed  Not part of the Collection hierarchy  Returns keys as a Set view  Returns values as a Collection

32. public interface Map { V put(K key, V value); V get(Object key); V remove(Object key); boolean containsKey(Object key); boolean containsValue(Object value); int size(); boolean isEmpty(); void putAll(Map m); void clear(); public Set keySet(); public Collection values(); public Set > entrySet(); public interface Entry { K getKey(); V getValue(); V setValue(V value); } Basic Operations Bulk Operations Collection Views Interface for entrySet elements

33. Word Frequency From the Java Tutorial: http://java.sun.com/docs/books/tutorial/collections/interfaces/map.html java Freq if it is to be it is up to me to delegate 8 distinct words: {to=3, delegate=1, be=1, it=2, up=1, if=1, me=1, is=2} import java.util.*; public class Freq { public static void main(String[] args) { Map m = new HashMap (); // Initialize frequency table from command line for (String a : args) { Integer freq = m.get(a); m.put(a, (freq == null) ? 1 : freq + 1); } System.out.println(m.size() + " distinct words:"); System.out.println(m); }

34. java Freq if it is to be it is up to me to delegate 8 distinct words: {to=3, delegate=1, be=1, it=2, up=1, if=1, me=1, is=2} java Freq if it is to be it is up to me to delegate 8 distinct words: {be=1, delegate=1, if=1, is=2, it=2, me=1, to=3, up=1} java Freq if it is to be it is up to me to delegate 8 distinct words: {if=1, it=2, is=2, to=3, be=1, up=1, me=1, delegate=1} HashMap TreeMap LinkedMap Map m = new _______ ();

35. Summary of implementations  The Java Tutorial gives this list of "most commonly used" implementations: SetHashSet ListArrayList MapHashMap QueueLinkedList