Collections

CollectionsCS3250

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

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<T> {public int compareTo(T o);

}

public interface Comparator<T> {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 (7th ed., p. 707)

Example

The old way:

With generics:

List inventory = new LinkedList();inventory.add("Brass Lantern");. . .String item = (String) inventory.get(0);

List<String> inventory= new

LinkedList<String>();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<String> inventory= new

LinkedList<String>();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<String> inventory= new

LinkedList<String>();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<E> { 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. JavaC++: 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<int>::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<String> inventory = new LinkedList<String>();inventory.add("Brass Lantern);

Interface Hierarchy

Collection

List Set

SortedSet

Queue

Map

SortedMap

public interface Collection<E> extends Iterable<E> { // Basic operations int size(); boolean isEmpty(); boolean contains(Object element); boolean add(E element); //optional boolean remove(Object element); //optional Iterator<E> iterator();

// Bulk operations boolean containsAll(Collection<?> c); boolean addAll(Collection<? extends E> c); //optional boolean removeAll(Collection<?> c); //optional boolean retainAll(Collection<?> c); //optional void clear(); //optional

// Array operations Object[] toArray(); <T> T[] toArray(T[] a);}

public interface Collection<E> extends Iterable<E> { // Basic operations int size(); boolean isEmpty(); boolean contains(Object element); boolean add(E element); //optional boolean remove(Object element); //optional Iterator<E> iterator();

// Bulk operations boolean containsAll(Collection<?> c); boolean addAll(Collection<? extends E> c); //optional boolean removeAll(Collection<?> c); //optional boolean retainAll(Collection<?> c); //optional void clear(); //optional

// Array operations Object[] toArray(); <T> T[] toArray(T[] a);}

public interface Collection<E> extends Iterable<E> { // Basic operations int size(); boolean isEmpty(); boolean contains(Object element); boolean add(E element); //optional boolean remove(Object element); //optional Iterator<E> iterator();

// Bulk operations boolean containsAll(Collection<?> c); boolean addAll(Collection<? extends E> c); //optional boolean removeAll(Collection<?> c); //optional boolean retainAll(Collection<?> c); //optional void clear(); //optional

// Array operations Object[] toArray(); <T> T[] toArray(T[] a);}

For more information about generic wildcards (? and ? extends

E) see http://docs.oracle.com/javase/tutorial/extra/generics/subtype.html

public interface Collection<E> extends Iterable<E> { // Basic operations int size(); boolean isEmpty(); boolean contains(Object element); boolean add(E element); //optional boolean remove(Object element); //optional Iterator<E> iterator();

// Bulk operations boolean containsAll(Collection<?> c); boolean addAll(Collection<? extends E> c); //optional boolean removeAll(Collection<?> c); //optional boolean retainAll(Collection<?> c); //optional void clear(); //optional

// Array operations Object[] toArray(); <T> T[] toArray(T[] a);}

public interface Collection<E> extends Iterable<E> { // Basic operations int size(); boolean isEmpty(); boolean contains(Object element); boolean add(E element); //optional boolean remove(Object element); //optional Iterator<E> iterator();

// Bulk operations boolean containsAll(Collection<?> c); boolean addAll(Collection<? extends E> c); //optional boolean removeAll(Collection<?> c); //optional boolean retainAll(Collection<?> c); //optional void clear(); //optional

// Array operations Object[] toArray(); <T> T[] toArray(T[] a);}

What do these optional methods have in common?

Implementations

Interface

Implementations

Hash table

Resizable array

Tree Linked list Hash table + linked list

Set HashSet TreeSet LinkedHashSet

List ArrayList LinkedList

Queue LinkedList

Map HashMap TreeMap LinkedHashMap

List

Ordered Collection

Allows duplicate elements

Provides positional access

Permits arbitray range operations (sublists)

pie ice cream

cake

0 1 2 3

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 iteratorspublic interface ListIterator<E> extends Iterator<E> { 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.

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<E> extends Collection<E> { 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 exception Returns 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<K,V> { 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<? extends K, ? extends V> m); void clear(); public Set<K> keySet(); public Collection<V> values(); public Set<Map.Entry<K,V>> 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: http://java.sun.com/docs/books/tutorial/collections/interfaces/map.html

java Freq if it is to be it is up to me to delegate8 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<String, Integer> m = new HashMap<String, Integer>(); // 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 delegate8 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 delegate8 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 delegate8 distinct words:{if=1, it=2, is=2, to=3, be=1, up=1, me=1, delegate=1}

HashMap

TreeMap

LinkedMap

Map<String, Integer> m = new _______<String, Integer>();

Summary of implementations

The Java Tutorial gives this list of "most commonly used" implementations:

Set HashSetList ArrayListMap HashMapQueue LinkedList