Collections CS3250

Sources  Slides by Professor Chuck Allison  Core Java, by Cay S. Horstmann and Gary Cornell  The Java Tutorial 

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

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

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"

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)

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);

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);

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);

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 }

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 }

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

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

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);

Interface Hierarchy Collection ListSet SortedSet Queue Map SortedMap

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); }

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); }

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 extra/generics/subtype.html

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); }

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?

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

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

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)

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.

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

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

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

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(); }

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()

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

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

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

Word Frequency From the Java Tutorial: 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); }

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 _______ ();

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