Upload
tehya
View
44
Download
0
Embed Size (px)
DESCRIPTION
Collections. CS3250. 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. - PowerPoint PPT Presentation
Citation preview
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