Transcript Lecture 5. Java Collection : Built

Java Programming
Lecture 5.
Java Collection :
Built-in Data Structures for Java
Cheng-Chia Chen
Transparency No. 1
Java Collection
The Java Collection API
Interfaces:
 Collection 
 Set  SortedSet,
 List
 Map  SortedMap
 Iterator  ListIterator
 Comparator
Transparency No. 2
Java Collection
Summary of all interfaces in the java Collection API
Collection Interfaces : The primary means by which collections are
manipulated.
 Collection  Set, List
 A group of objects.
 May or may not be ordered; May or may not contain duplicates.
 Set  SortedSet
 The familiar set abstraction.
 No duplicates; May or may not be ordered.
 SortedSet
 elements automatically sorted, either in their natural ordering (see the
Comparable interface), or by a Comparator object provided when a
SortedSet instance is created.
 List
 Ordered collection, also known as a sequence.
 Duplicates permitted; Allows positional access.
Transparency No. 3
Java Collection
 Map SortedMap
 A mapping from keys to values.
 Each key can map to at most one value (function).
 SortedMap
 A map whose mappings are automatically sorted by key, either in the
keys' natural ordering or by a comparator provided when a SortedMap
instance is created.
Transparency No. 4
Java Collection
Infrastructure
Iterators : Similar to the Enumeration interface, but more powerful, and with
improved method names.
 Iterator  ListIterator
 functionality of the Enumeration interface,
 supports elements removement from the backing collection.
 ListIterator
 Iterator for use with lists.
 supports bi-directional iteration, element replacement, element insertion and index
retrieval.
Ordering
 Comparable ( compareTo(object) )
 Imparts a natural ordering to classes that implement it.
 The natural ordering may be used to sort a list or maintain order in a sorted set or
map. Many classes have been retrofitted to implement this interface.
 Comparator ( compare(Object, Object) )
 Represents an order relation, which may be used to sort a list or maintain order
in a sorted set or map. Can override a type's natural ordering, or order objects of a
type that does not implement the Comparable interface.
Transparency No. 5
Java Collection
Infrastructure
Runtime Exceptions
 UnsupportedOperationException
 Thrown by collections if an unsupported optional operation is called.
 ConcurrentModificationException
 Thrown by Iterator and listIterator if the backing collection is modified
unexpectedly while the iteration is in progress.
 Also thrown by sublist views of lists if the backing list is modified
unexpectedly.
Transparency No. 6
Java Collection
classes of the java collection API
1. AbstractCollection (Collection) 



AbstractMap (Map) 





AbstractSet (Set)  HashSet, TreeSet(SortedSet)
AbstractList (List) ArrayList, AbstractSequentialList  LinkedList
HashMap
TreeMap (SortedMap)
WeakHashMap
Arrays
Collections
Transparency No. 7
Java Collection
General-Purpose Implementation classes
The primary implementations of the collection interfaces.
 HashSet : Hash table implementation of the Set interface.
 TreeSet : Red-black tree implementation of the SortedSet interface.
 ArrayList : Resizable-array implementation of the List interface.
 (Essentially an unsynchronized Vector.) The best all-around implementation of the
List interface.
 LinkedList : Doubly-linked list implementation of the List interface.
 May provide better performance than the ArrayList implementation if elements are
frequently inserted or deleted within the list.
 Useful for queues and double-ended queues (deques).
 HashMap : Hash table implementation of the Map interface.
 (Essentially an unsynchronized Hashtable that supports null keys and values.) The
best all-around implementation of the Map interface.
 TreeMap : Red-black tree implementation of the SortedMap interface.
Transparency No. 8
Java Collection
The java.util.Collection interface
 represents a group of objects, known as its elements.
 no direct implementation
 The primary use : pass around collections of objects where
maximum generality is desired.
Ex: List l = new ArrayList( c ) ; // c is a Collection object
Transparency No. 9
Java Collection
The definition
public interface Collection {
// Basic properties
int size();
boolean isEmpty();
boolean contains(Object element); // use equals() for comparison
boolean equal(Object);
int hashCode(); // new equals() requires new hashCode()
// basic operations
boolean add(Object);
// Optional; return true if this changed
boolean remove(Object); // Optional; use equals() (not ==)
Transparency No. 10
Java Collection
The Collection interface definition
// Bulk Operations
boolean containsAll(Collection c); // true if c  this
// the following 4 methods are optional, returns true if contents changed
boolean addAll(Collection c); // Optional; this = this U c
boolean removeAll(Collection c); // Optional; this = this - c
boolean retainAll(Collection c); // Optional; this = this c
void clear();
// Optional; this = {};
// transformations
Iterator iterator(); // collection  iterator
Object[] toArray(); // collection  array
Object[] toArray(Object[] a );
// if |this| \le |a| => copy this to a and return a ; else => create a new array b
// whose component type is that of a and copy this to b and return b; .
}
Transparency No. 11
Java Collection
Why using Iterators instead of Enumerations
 Iterator allows the caller to remove elements from the underlying
collection during the iteration with well-defined semantics.
 Method names have been improved.
public interface Iterator {
boolean hasNext(); // cf: hasMoreElements()
Object next();
// cf: nextElement()
void remove();
// Optional
}
// a simple Collection filter using iterator that Enumeration could not help
static void filter(Collection c) {
for (Iterator i = c.iterator(); i.hasNext(); ) {
if ( no-good( i.next() ) ) i.remove(); // i.next() is removed from c
i.remove(); // exception raised, cannot removed more than once !
}}
Transparency No. 12
Java Collection
Examples of Bulk and array operations for Collection
 Remove all instances of an element e from a collection c:
c.removeAll(Collections.singleton(e)); // remove all e’s in c
c.removeAll(Collections.singleton(null)); // remove all nulls in c
 collections to arrays :
Collection c = new LinkedList(); // LinkedList is an imp. of Col.
c .add(“a”); c.add(“b”); // c == [“a”, “b”]; component type = Object
Object[] ar1 = c.toArray(); // ok, ar1.length == 2
String[] ar2 = (String[]) c.toArray(); // runtime exception, cannot
// cast an array of Object component type to String[];
// note: can pass compilation.
String[] ar3 = (String[]) c.toArray(new String[0]); // ok! since
c.toArray(String[]) has String component type.
Transparency No. 13
Java Collection
The Set Interface
 is a Collection that cannot contain duplicate elements.
 models the mathematical set abstraction.
 contains no methods other than those inherited from Collection.





same signatures but different semantics ( meaning )
Collection c = new LinkedList(); Set s = new HashSet();
String o = “a”;
c.add(o); c.add(o) ; // both return true; c.size() == 2
s.add(o); s.add(o) ; // 2nd add() returns false; s.size() == 1
 It adds the restriction that duplicate elements are prohibited.
 Collection noDups = new HashSet(c); // a simple way to eliminate
duplicate from c
 Two Set objects are equal if they contain the same elements.
 Two direct implementations:
 HashSet
TreeSet
Transparency No. 14
Java Collection
Basic Operations
 A simple program to detect duplicates using set:
import java.util.*;
public class FindDups {
public static void main(String args[]) {
Set s = new HashSet(); // or new TreeSet(), another implementation of Set
// following code uses Set methods only
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);
}}
% java FindDups i came i saw i left
Duplicate detected: i
Duplicate detected: i
4 distinct words detected: [came, left, saw, i]
Transparency No. 15
Java Collection
Bulk Operations for Set objects
1. s1.containsAll(s2) returns true if s2 is a subset of s1.
2. s1.addAll(s2), s1.retainAll(s2), s1.removeAll(s2):
 s1 = s1 U s2, s1 = s1  s2, s1 = s1 – s2, respectively
 return true iff s1 is modified.
 For nondestructive operations:
Set union = new HashSet(s1); // make a copy of s1
union.addAll(s2);
Set intersection = new HashSet(s1); // may also use TreeSet(s1)
intersection.retainAll(s2);
Set difference = new HashSet(s1);
difference.removeAll(s2);
Transparency No. 16
Java Collection
Example
 Show all arguments that occur exactly once and those that
occur more than once.
import java.util.*;
public class FindDups2 {
public static void main(String args[]) {
Set uniques = new HashSet(), 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);
} }
Transparency No. 17
Java Collection
The List Interface
 A List is an ordered Collection(sometimes called a sequence).
 may contain duplicate elements.
 The List interface includes operations for:
 Positional Access: set/get elements based on their numerical position
in the list.
 Search: search for a specified object in the list and return its numerical
position.
 List Iteration: extend Iterator semantics to take advantage of the list's
sequential nature.
 Range-view: perform arbitrary range operations on the list.
 Three direct implementations:
 ArrayList : resizable array
 LinkedList : doubly linked-list
 Vector : synchronized ArrayList.
Transparency No. 18
Java Collection
The List interface definition
public interface List extends Collection {
// Positional Access
Object get(int index);
// 0-based
Object set(int index, Object element);
// Optional; return old value
void add(int index, Object element);
// Optional
Object remove(int index);
// Optional
abstract boolean addAll(int index, Collection c); // Optional
// Search
int indexOf(Object o);
int lastIndexOf(Object o);
// Range-view
List subList(int from, int to);
// Iteration
ListIterator listIterator([int f] ); // default f = 0; return a listIterator with cursor
set to position f}
Transparency No. 19
Java Collection
List in comparison with Vector (1.1)
 shorter getter/setter names





get(int)
// elementAt(int) /
add(int,Object)
// insertElemetnAt(O,i)
Object set(int, Object) // void setElementAt(Object,int)
Object remove(int)
// void removeElementAt(int)
Note: From java1.2 Vector also implements the List interface.
 List concatenation:
 list1 = list1.addAll(list2); // destructive
 List list3 = new arrayList( list1); // or LinkedList(list1)
 list3.addAll(list2); // list3 equals to list1 . list2
 Two List objects are equal if they contain the same elements in
the same order.
 List l1 = new LilnkedList(l2); // l2 is an ArrayList
 l1.equals(l2) ? true: false // returns true, but l1==l2 returns false.
Transparency No. 20
Java Collection
ListIterator
public interface ListIterator extends Iterator {
// from Iterator
boolean hasNext();
E(0)
E(1)
E(2)
E(3)
^
^
^
^
^
Object next();
Index: 0
1
2
3
4
// backward iteration:
(cursor)
boolean hasPrevious();
previous()
next()
Object previous();
int nextIndex(); // == cursor position == pos of next() object
int previousIndex(); // == nextIndex() – 1 = pos of previous() object
// ; == -1 if cursor = 0;
void remove();
// Optional
void set(Object o); // Optional
void add(Object o); // Optional
}
Transparency No. 21
Java Collection
Set and Add operations in ListIterator
 set(Object), remove() : Replaces/remove the last element
returned by next or previous with the specified element.
Ex: => either E(1) (if next() is called more recently than
previous())
E(0)
E(1)
E(2)
E(3)
or E(2) (otherwise)
^
^
^
^
^
1
2
3
4
would be replaced Index: 0
(cursor)
 add(Object): Inserts the specified element into the list,
immediately before the current cursor position.
 Ex: add(o) => E(0) E(1) o (cursor) E(2) E(3)
 Backward Iteration:
for(ListIterator i = list.listIterator(list.size()); i.hasPrevious(); )
{ processing( i.previous()) ; }
Transparency No. 22
Java Collection
Some Examples
 possible implementation of List.indexOf(Object):
public int indexOf(Object o) {
for (ListIterator i = listIterator(); i.hasNext(); )
if (o==null ? i.next()==null : o.equals(i.next()))
return i.previousIndex(); // or i.nextIndex() -1
return -1; // Object not found
}
 replace 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==null ? i.next()==null : val.equals(i.next()))
i.set(newVal);
}
Transparency No. 23
Java Collection
Range-view Operation
 subList(int f, int t), returns a List view of a portion of this list
whose indices range from f, inclusive, to t, exclusive, [f,t).
 Ex:
E(0)
E(1)
E(2)
E(3)
^
^
^
^
^
sublist(1,3) = E(1),E(2)
Index: 0
1
2
(cursor)
3
4
 This half-open range mirrors the typical for-loop:
for (int i=f; i<t; i++) {
...
} // iterate over the sublist
 Change on sublist is reflected on the backing list
Ex: the following idiom removes a range of elements from a list:
list . subList(from, to) . clear();
Transparency No. 24
Java Collection
The Map Interface




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.
Three implementations:
 HashMap, which stores its entries in a hash table, is the bestperforming implementation.
 TreeMap, which stores its entries in a red-black tree, guarantees the
order of iteration.
 Hashtable has also been retrofitted to implement Map.
 All implementation must provide two constructors: (like
Collections) Assume M is your implementation
 M()
// empty map
 M(Map m) // a copy of map from m
Transparency No. 25
Java Collection
The Map interface
public interface Map { // Map does not extend Collection
// Basic Operations
// put or replace, return replace object
Object put(Object key, Object value); // optional
Object get(Object key);
Object remove(Object key);
boolean containsKey(Object key);
boolean containsValue(Object value);
int size();
boolean isEmpty();
Transparency No. 26
Java Collection
The Map interface
// Bulk Operations
void putAll(Map t); //optional
void clear(); // optional
// Collection Views;
// backed by the Map, change on either will be reflected on the other.
public Set keySet(); // cannot duplicate by definition!!
public Collection values(); // can duplicate
public Set entrySet(); // no equivalent in Dictionary
// nested Interface for entrySet elements
public interface Entry {
Object getKey();
Object getValue();
Object setValue(Object value);
}}
Transparency No. 27
Java Collection
Possible Exceptions thrown by Map methods
 UnsupportedOperationException
 if the method is not supported by this map.
 ClassCastException
 if the class of a key or value in the specified map prevents it from being
stored in this map.
 ex: m.put(“Name”, new Interger(2)) // m actually put (String) value
 IllegalArgumentException
 some aspect of a key or value in the specified map prevents it from
being stored in this map.
 ex: put(“Two”, 2) // put expect an Object value
 NullPointerException
 this map does not permit null keys or values, and the specified key or
value is null.
Transparency No. 28
Java Collection
Basic Operations
 a simple program to generate a frequency table
import 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]); // key is a string
m.put(args[i], (freq==null ? ONE : new Integer( freq.intValue() + 1)));
} // value is Integer
System.out.println( m.size()+" distinct words detected:");
System.out.println(m);
} }
 > java Freq if it is to be it is up to me to delegate
8 distinct words detected:
{to=3, me=1, delegate=1, it=2, is=2, if=1, be=1, up=1}
Transparency No. 29
Java Collection
Bulk Operations
 clear() : removes all of the mappings from the Map.
 putAll(Map) operation is the Map analogue of the
Collection interface's addAll(…) operation.
 can be used to create attribute map creation with default
values. Here's a static factory method demonstrating this
technique:
 static Map newAttributeMap(Map defaults, Map overrides) {
Map result = new HashMap(defaults);
result.putAll(overrides);
return result;
}
Transparency No. 30
Java Collection
Collection Views methods
 allow a Map to be viewed as a Collection in three ways:
 keySet: the Set of keys contained in the Map.
 values: The Collection of values contained in the Map. This Collection is not a Set, as
multiple keys can map to the same value.
 entrySet: The Set of key-value pairs contained in the Map.
 The Map interface provides a small nested interface called Map.Entry that is the type
of the elements in this Set.
 the standard idiom for iterating over the keys in a Map:
for (Iterator i = m.keySet().iterator(); i.hasNext(); ) {
System.out.println(i.next());
if(no-good(…)) i.remove() ; } // support removal from the back Map
 Iterating over key-value pairs
for (Iterator i=m.entrySet().iterator(); i.hasNext(); ) {
Map.Entry e = (Map.Entry) i.next();
System.out.println(e.getKey() + ": " + e.getValue());
}
Transparency No. 31
Java Collection
Permutation groups of words
import java.util.*;
import java.io.*;
public class Perm {
public static void main(String[] args) {
int minGroupSize = Integer.parseInt(args[1]);
// Read words from file and put into simulated multimap
Map m = new HashMap();
try { BufferedReader in = new BufferedReader(new FileReader(args[0]));
String word;
while((word = in.readLine()) != null) {
String alpha = alphabetize(word);
// normalize word : success ccesssu
List l = (List) m.get(alpha);
if (l==null) m.put(alpha, l=new ArrayList());
l.add(word);
} } catch(IOException e) { System.err.println(e); System.exit(1); }
Transparency No. 32
Java Collection
// Print all permutation groups above size threshold
for (Iterator i = m.values().iterator(); i.hasNext(); ) {
List l = (List) i.next();
if (l.size() >= minGroupSize)
System.out.println(l.size() + ": " + l);
} }
Transparency No. 33
Java Collection
// buketsort implementation
private static String alphabetize(String s) {
int count[] = new int[256];
int len = s.length();
for (int i=0; i<len; i++)
count[s.charAt(i)]++;
StringBuffer result = new StringBuffer(len);
for (char c='a'; c<='z'; c++)
for (int i=0; i<count[c]; i++)
result.append(c);
return result.toString();
}}
Transparency No. 34
Java Collection
Some results
% java Perm dictionary.txt 8
9: [estrin, inerts, insert, inters, niters, nitres, sinter, triens, trines]
8: [carets, cartes, caster, caters, crates, reacts, recast, traces]
9: [capers, crapes, escarp, pacers, parsec, recaps, scrape, secpar, spacer]
8: [ates, east, eats, etas, sate, seat, seta, teas]
12: [apers, apres, asper, pares, parse, pears, prase, presa, rapes, reaps, spare,
spear]
9: [anestri, antsier, nastier, ratines, retains, retinas, retsina, stainer, stearin]
10: [least, setal, slate, stale, steal, stela, taels, tales, teals, tesla]
8: [arles, earls, lares, laser, lears, rales, reals, seral]
8: [lapse, leaps, pales, peals, pleas, salep, sepal, spale]
8: [aspers, parses, passer, prases, repass, spares, sparse, spears]
8: [earings, erasing, gainers, reagins, regains, reginas, searing, seringa]
11: [alerts, alters, artels, estral, laster, ratels, salter, slater, staler, stelar, talers]
9: [palest, palets, pastel, petals, plates, pleats, septal, staple, tepals] …
Transparency No. 35
Java Collection
The SortedSet Interface
 A SortedSet is a Set that maintains its elements in ascending
order, sorted according to the elements' natural order(via
comparable interface), or according to a Comparator provided
at SortedSet creation time.
 In addition to the normal Set operations, the Set interface
provides operations for:
 Range-view: Performs arbitrary range operations on the sorted set.
 Endpoints: Returns the first or last element in the sorted set.
 Comparator access: Returns the Comparator used to sort the set (if
any).
 Standard constructors: Let S be the implementation
 S( [ Comparator ] ) // empty set
 S(SortedSet) // copy set
 Implementation: TreeSet
Transparency No. 36
Java Collection
The SortedSet
public interface SortedSet extends Set {
// Range-view
SortedSet subSet(Object f, Object t); // return [ f, t ), f.eq(t) ->null
SortedSet headSet(Object t);
// [first(), t )
SortedSet tailSet(Object fromElement);// [f, last() ]
// Endpoints
Object first();
Object last();
// Comparator access
Comparator comparator(); // if any
}
Transparency No. 37
Java Collection
The SortedMap Interface
 A SortedMap is a Map that maintains its entries in ascending
order, sorted according to the keys‘ natural order, or according
to a Comparator provided at SortedMap creation time.
 In addition to the normal Map operations, the Map interface
provides operations for:
 Range-view: Performs arbitrary range operations on the sorted map.
 Endpoints: Returns the first or last key in the sorted map.
 Comparator access: Returns the Comparator used to sort the map (if
any).
 Constructors provided by implementations:
 M([Comparator])
 M(SortedMap)
// empty SortedMap
// copy Map
 Implementation: TreeMap
Transparency No. 38
Java Collection
The SortedMap interface
// analogous to SortedSet
public interface SortedMap extends Map {
Comparator comparator();
// range-view operations
SortedMap subMap(Object fromKey, Object toKey);
SortedMap headMap(Object toKey);
SortedMap tailMap(Object fromKey);
// member access;
// Don’t forget bulk of other Map operations available
Object first();
Object last();
}
Transparency No. 39
Java Collection
Map Operations
 Operations inheriting from Map behave identically to normal
maps with two exceptions:
 Iterator() traverse the collections in key-order.
 toArray(…) contains the keys, values, or entries in key-order.
 Although not guaranteed by the interface,
 the toString() method of SortedMap in all the JDK's SortedMap returns
a string containing all the elements in key-order.
Transparency No. 40
Java Collection
Example
SortedMap m = new TreeMap();
m.put("Sneezy", "common cold");
m.put("Sleepy", "narcolepsy");
m.put("Grumpy", "seasonal affective disorder");
System.out.println( m.keySet() );
System.out.println( m.values() );
System.out.println( m.entrySet() );
 Running this snippet produces this output:
[ Grumpy, Sleepy, Sneezy]
[ seasonal affective disorder, narcolepsy, common cold]
[ Grumpy=seasonal affective disorder, Sleepy=narcolepsy,
Sneezy=common cold]
Transparency No. 41
Java Collection
Actual Collection and Map Implementations
 Implementations are the actual data objects used to store
collections (and Maps).
Three kinds of implementations:
 General-purpose Implementations
 the public classes that provide the primary implementations of the
core interfaces.
 Wrapper Implementations
 used in combination with other implementations (often the generalpurpose implementations) to provide added functionality.
 Convenience Implementations
 Convenience implementations are mini-implementations, typically
made available via static factory methods that provide convenient,
efficient alternatives to the general-purpose implementations for
special collections (like singleton sets).
Transparency No. 42
Java Collection
General Purpose Implementations
Hash Table
Set
balanced
tree
ArrayList
Vector
HashMap
Hashtable
linked list
TreeSet
(sortedSet)
HashSet
List
Map
Resizable
array
LinkedList
TreeMap
(sortedMap)
Transparency No. 43
Java Collection
Properties of the implementations




consistent names as well as consistent behavior.
fully implementations [of all the optional operations].
All permit null elements, keys and values.
unsynchronized.
 remedy the deficiency of Hashtable and Vector
 can become synchronized through the synchronization wrappers
 All have fail-fast iterators, which detect illegal concurrent
modification during iteration and fail quickly and cleanly.
 All are Serializable,
 all support a public clone() method.
 should be thinking about the interfaces rather than the
implementations. The choice of implementation affects only
performance.
Transparency No. 44
Java Collection
HashSet vs treeSet (and HashMap vs TreeMap)
 HashSet/ HashMap is much faster (constant time vs. log time
for most operations), but offers no ordering guarantees.
 always use HashSet/HashMap unless you need to use the
operations in the SortedSet, or in-order iteration.
 choose an appropriate initial capacity of your HashSet if
iteration performance is important.
 The default initial capacity is 101, and that's often more than you need.
 can be specified using the int constructor.
 Set s= new HashSet(17); // set bucket size to 17
Transparency No. 45
Java Collection
ArrayList vs LinkedList
 Most of the time, you'll probably use ArrayList.
 offers constant time positional access
 Think of ArrayList as Vector without the synchronization overhead.
 Use LikedList If you frequently add elements to the beginning of
the List, or iterate over the List deleting elements from its
interior.
 These operations are constant time in a LinkedList but linear time in
an ArrayList.
Transparency No. 46
Java Collection
Wrapper Implementations
 are implementations that delegate all of their real work to a
specified collection, but add some extra functionality on top of
what this collection offers.
 These implementations are anonymous:
 the JDK provides a static factory method.
 All are found in the Collections class which consists solely of static
methods.
 Synchronization Wrappers






public static Collection synchronizedCollection(Collection c);
public static Set synchronizedSet(Set s);
public static List synchronizedList(List list);
public static Map synchronizedMap(Map m);
public static SortedSet synchronizedSortedSet(SortedSet s);
public static SortedMap synchronizedSortedMap(SortedMap m);
Transparency No. 47
Java Collection
read-only access to Collection/Maps
 Unmodifiable Wrappers






public static Collection unmodifiableCollection(Collection c);
public static Set unmodifiableSet(Set s);
public static List unmodifiableList(List list);
public static Map unmodifiableMap(Map m);
public static SortedSet unmodifiableSortedSet(SortedSet s);
public static SortedMap unmodifiableSortedMap(SortedMap m);
Transparency No. 48
Java Collection
Convenience Implementations
 mini-implementations that can be more convenient and more
efficient then the general purpose implementations
 available via static factory methods or exported constants in
class Arrays or Collections.
 List-view of an Array
 List l = Arrays.asList(new Object[100]); // list of 100 null’s.
 Immutable Multiple-Copy List

List l = new ArrayList(Collections.nCopies(1000, new Integer(1)));
 Immutable Singleton Set
 c.removeAll(Collections.singleton(e));
 profession.values().removeAll(Collections.singleton(LAWYER));
 (Immutable) Empty Set and Empty List Constants
 Collections.EMPTY_SET
Collections.EMPTY_LIST
 Collections.EMPTY_MAP // add(“1”)  UnsupportedOp… Exception
Transparency No. 49
Java Collection
The Arrays class
 static List asList(Object[] a) // a could not be of the type int[],…
 Returns a fixed-size list backed by the specified array. cannot add/remove();
 static int binarySearch(Type[] a, Type key)
 Searches the specified array of bytes for the specified value using the binary search
algorithm. Type can be any primitive type or Object.
 static boolean equals(Type[] a1, Type[] a2)
 static void fill(Type[] a [,int f, int t], Type val)
 Assigns the specified val to each element of the specified array of Type.
 static void sort(Type[] a [, int f, int t])
 Sorts the specified range of the specified array of ints into ascending numerical order.
 static sort(Object[] a, Comparator c [,int f, int t ])
 Sorts the specified array of objects according to the order induced by the specified
comparator.
Transparency No. 50
Java Collection
The Collections class
static int binarySearch(List list, Object key [, Comparator c])
static void copy(List dest, List src) // foreach i d.set(i, s.get(i));
static Enumeration enumeration(Collection c)
 Returns an enumeration over the specified collection.
static void
fill(List list, Object o)
static Object max(Collection coll [, Comparator comp] )
static Object min(Collection coll [, Comparator comp] )
static List
nCopies(int n, Object o)
static void
reverse(List l)
static Set
singleton(Object o)
static Comparator reverseOrder() // assume a is of type String[]
// usage: Arrays.sort(a, Collections.reverseOrder());
static void shuffle(List list [, Random rnd])
static void swap(List, int, int)
static void rotate(List, int d) ;// obj at i moved to ( i - d mod size())
Transparency No. 51
Java Collection
The implementation of reverseOrder()
public static Comparator reverseOrder() {
return REVERSE_ORDER;
}
private static final Comparator REVERSE_ORDER = new
ReverseComparator();
private static class ReverseComparator implements
Comparator,Serializable {
public int compare(Object o1, Object o2) {
Comparable c1 = (Comparable)o1;
Comparable c2 = (Comparable)o2;
return -c1.compareTo(c2);
}
}
Transparency No. 52
Java Collection
The Collections class
static List
singletonList(Object o)
static Map
singletonMap(Object key, Object value)
static void
sort(List list, Comparator c)
static Collection synchronizedCollection(Collection c) …
static Collection unmodifiableCollection(Collection c) …
static List EMPTY_LIST //The empty list (immutable).
static Map
EMPTY_MAP //The empty map (immutable).
static Set
EMPTY_SET //The empty set (immutable).
Transparency No. 53
Java Collection
problem 2: The definition of Multiset class
public interface Multiset extends Collection {
// Basic properties
int size(); boolean isEmpty(); boolean contains(Object e);
boolean contains(Object e, int t) // return multiplicity(e) >= t.
int multiplicity(Object e); // return the multiplicity of e in this
boolean equals(Object); // see AbstractMap for detail
int hashCode(); // e1.equals(e2) => e1.hashCode() == e2.hashCode()
// basic operations
boolean add(Object [,int times]); // return true if this changed
boolean remove(Object ); // use equals() (not ==)
int remove(Object, int times) // return the number of occurrences removed
Transparency No. 54
Java Collection
The Multiset interface definition
// Bulk Operations
boolean containsAll(Collection c); // true if c  this
boolean addAll(Collection c); // add all elements of c to this
boolean union(Collection c); // this = this U c.
boolean removeAll(Collection c); // remove all elements of c
boolean remove (Collection c) ; // this = this – c;
boolean retainAll(Collection c); // retains all elements of C
boolean retain(Collection c); // this = this  c
void clear();
// this = {};
Collection get(Object e) // get all e elements
Transparency No. 55
Java Collection
// transformations
Iterator iterator(); // Multiset  iterator
Object[] toArray(); // Multiset  Object[]
Object[] toArray(Object[] a ); // MultiSet  Type[]
Set toSet();
// remove multiplicity from the Multiset
}
Transparency No. 56
Java Collection
Problem 2 : Implementation of the Multiset class


Define a class called jpCourse2001.problem2.MultisetImpl,
which implement the .jpCourse2001.problem2.Multiset
interface.
Your class should have at least the constructors:
public MultisetImpl(); // create a new empty Multiset
public MultisetImpl(Colelction c) // a new Multiset with elements from c.

A proposed approach is to use a hash table to implement your
class:
1. You can consult the source programs of HashSet and HashMap to
learn how the hash table technique is used to implement both classes,
2. and then adapt them to suit your requirement in the new Multiset
class.
3. Implement the Map.Entry so that :

getValue = ( multiplicity , list of elements )

getKey() contains head of the list (used for comparison).
Transparency No. 57