The Java Collections Framework Based on .
-
Upload
aubrie-evans -
Category
Documents
-
view
224 -
download
3
Transcript of The Java Collections Framework Based on .
The Java Collections Framework
Based onhttp://java.sun.com/docs/books/tutorial/collections/intro/index.html
Collections• A collection: An object that groups multiple elements into a
single unit • Collection implementations in earlier versions of Java
– Vector , Hashtable , and array.
Interfaces
• Core collection interfaces are the interfaces used to manipulate collections, and to pass them from one method to another
The Collection Interfacepublic interface Collection { // Basic Operations int size(); boolean isEmpty(); boolean contains(Object element); boolean add(Object 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(); Object[] toArray(Object a[]);}
The Collection Interface• Also, classes implementing some Collection interface have
constructors that take a Collection argument.
Iteratorspublic interface Iterator {
boolean hasNext(); Object next(); void remove(); // Optional
}
Compare this with the older “Enumeration” interface
public interface Enumeration {boolean hasMoreElements();Object nextElement();
}
Using Iteratorsstatic void filter(Collection c) {
for (Iterator i = c.iterator(); i.hasNext(); ) if (!myCondition(i.next())) i.remove();
}
• The code is polymorphic: it works for any Collection that supports element removal, regardless of implementation.
• It would have been impossible to write this using Enumeration instead of Iterator. – Because there's no safe way to remove an element from
a collection while traversing it with an Enumeration.
The Set Interface• The Set interface extends Collection and contains no methods
other than those inherited from Collection. • It adds the restriction that duplicate elements are prohibited.• Set also adds a stronger contract on the behavior of the
equals and hashCode operations (methods inherited from Object)
• Two Set objects are equal if they contain the same elements.
• The JDK contains two general-purpose Set implementations.– HashSet , which stores its elements in a hash
table, is the best-performing implementation. – TreeSet , which stores its elements in a red-black
tree, guarantees the order of iteration.
Example• Removes duplicates from the collection c
Collection c; // … Some code that fills in new elements into cCollection noDups = new HashSet(c);
Example– Takes the words in its argument list – Prints out
• any duplicate words,• the number of distinct words, and • a list of the words with duplicates eliminated:
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); }
}
The Set Interfaceimport 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); }
}
• Note that the example code always refers to the collection by its interface type (Set), rather than by its implementation type (HashSet).
• This is a strongly recommended programming practice, as it gives you the flexibility to change implementations merely by changing the constructor.
Exampleimport java.util.*;
public class FindDups2 { public static void main(String args[]) { Set uniques = new HashSet(); Set dups = new HashSet();
for (int i=0; i<args.length; i++) if (!uniques.add(args[i])) dups.add(args[i]);
uniques.removeAll(dups); // Destructive set-difference
System.out.println("Unique words: " + uniques); System.out.println("Duplicate words: " + dups); }}
The List Interfacepublic interface List extends Collection { // Positional Access Object get(int index); Object set(int index, Object element); // Optional void add(int index, Object element); // Optional Object remove(int index); // Optional boolean addAll(int index, Collection c); // Optional
// Search int indexOf(Object o); int lastIndexOf(Object o);
// Iteration ListIterator listIterator(); ListIterator listIterator(int index);
// Range-view List subList(int from, int to);}
List Implementations• The JDK contains two general-purpose List implementations.
– ArrayList , which is generally the best-performing implementation, and
– LinkedList which offers better performance under certain circumstances.
• Also, Vector has been retrofitted to implement List.
List Examplespublic class Shuffle { public static void main(String args[]) { List l = new ArrayList(); for (int i=0; i<args.length; i++) l.add(args[i]); Collections.shuffle(l); System.out.println(l); }}• or, equivalently
public class Shuffle { public static void main(String args[]) { List l = Arrays.asList(args); Collections.shuffle(l); System.out.println(l); }}
The ListIterator Interfacepublic interface ListIterator extends Iterator { boolean hasNext(); Object next();
boolean hasPrevious(); Object previous();
int nextIndex(); int previousIndex();
void remove(); // Optional void set(Object o); // Optional void add(Object o); // Optional}
Iterators Element(0) Element(1) Element(2) Element(3)
^ ^ ^ ^ ^
Index: 0 1 2 3 4
ListIterator example:
for (ListIterator i=l.listIterator(l.size()); i.hasPrevious(); ) {
Foo f = (Foo) i.previous();
... // Do stuff
}
Iterator example• The set method "overwrites" the last element returned by
next() or previous() with the specified element. • The following polymorphic algorithm replaces all
occurrences of one specified value with another:
public static void replace(List l, Object val, Object newVal) { for (ListIterator i = l.listIterator(); i.hasNext(); ) if (val.equals(i.next()) i.set(newVal);}
Iterator example• The add method inserts a new element into the list,
immediately before the current cursor position. • The following polymorphic algorithm replaces all occurrences
of a specified value with the sequence of values contained in the specified list:
public static void replace(List l, Object val, List newVals) { for (ListIterator i = l.listIterator(); i.hasNext(); ) { if (val.equals(i.next()) { i.remove(); for (ListIterator j = newVals.listIterator(); j.hasNext(); )
i.add(j.next()); }
}}
Algorithms (the Collections class)Most of the polymorphic algorithms in the Collections class
apply specifically to List. • sort(List): Sorts a List using a merge sort algorithm, which
provides a fast, stable sort. (A stable sort is one that does not reorder equal elements.)
• shuffle(List): Randomly permutes the elements in a List. (Shown above.)
• reverse(List): Reverses the order of the elements in a List. • fill(List, Object): Overwrites every element in a List with the
specified value. • copy(List dest, List src): Copies the source List into the
destination List. • binarySearch(List, Object): Searches for an element in an
ordered List using the binary search algorithm.
The Arrays class• Static methods for manipulating arrays
– asList– binarySearch– equals– fill– sort
Maps• A Map is an object that maps keys to values. • A map cannot contain duplicate keys.• Each key can map to at most one value.
public interface Map { // Basic Operations Object put(Object key, Object value); Object get(Object key); Object remove(Object key); boolean containsKey(Object key); boolean containsValue(Object value); int size(); boolean isEmpty();
// Bulk Operations void putAll(Map t); void clear();
// Collection Views public Set keySet(); public Collection values(); public Set entrySet();
// Interface for entrySet elements public interface Entry { Object getKey(); Object getValue(); Object setValue(Object value); }}
Map Implementations• The JDK contains two new general-purpose Map
implementations. – HashMap , which stores its entries in a hash table, is the
best-performing implementation. – TreeMap , which stores its entries in a red-black tree,
guarantees the order of iteration. • Also, Hashtable has been retrofitted to implement Map.
• Two Map objects are equal if they represent the same key-value mappings.
Comparison to Hashtable• Map provides Collection-views in lieu of direct support for
iteration via Enumeration objects. • Map allows you to iterate over keys, values, or key-value
pairs;– Hashtable did not provide the third option.
• Map provides a safe way to remove entries in the midst of iteration; – Hashtable did not.
HashMap Exampleimport java.util.*;
public class Freq { private static final Integer ONE = new Integer(1);
public static void main(String args[]) { Map m = new HashMap();
// Initialize frequency table from command line 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); }}