Introduction to Collections

Transcription

1 Module 3 COLLECTIONS Introduction to Collections > A collection sometimes called a container is simply an object that groups multiple elements into a single unit. > Collections are used to store, retrieve, manipulate, and communicate aggregate data

2 What Is a Collections Framework? > A collections framework is a unified architecture for representing and manipulating collections. > All collection frameworks contain the following: Interfaces: Interfaces allow collections to be manipulated independently of the details of their representation Implementations: These are the concrete implementations of the collection interfaces. Algorithms: Methods that perform useful computations on objects that implement collection interfaces. The algorithms are polymorphic: the same method can be used on many different implementations of the appropriate collection interface. Benefits of the Java Collections Framework > The Java Collections Framework provides the following benefits: Reduces programming effort Increases program speed and quality Allows interoperability among unrelated APIs Reduces effort to learn and to use new APIs Reduces effort to design new APIs Fosters software reuse

3 Interfaces > The core collection interfaces encapsulate different types of collections > These interfaces allow collections to be manipulated independently of the details of their representation. > Core collection interfaces are the foundation of the Java Collections Framework. Java Collection Framework

4 Java Collection Framework Interfaces > Note that all the core collection interfaces are generic. public interface Collection<E>... > The <E> syntax tells you that the interface is generic. > When you declare a Collection instance you can and should specify the type of object contained in the collection. > Specifying the type allows the compiler to verify (at compile time) that the type of object you put into the collection is correct, thus reducing errors at runtime.

5 The Collection Interface 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 The Collection Interface // Array operations Object[] toarray(); <T> T[] toarray(t[] a);

6 The Collection Interface Traversing Collections > There are two ways to traverse collections: for each construct Using Iterators

7 for each Construct > The for each construct allows you to concisely traverse a collection or array using a for loop for (Object o : collection) System.out.println(o); Iterators > An Iterator is an object that enables you to traverse through a collection and to remove elements from the collection selectively, if desired. > You get an Iterator for a collection by calling its iterator method. > The following is the Iterator interface. public interface Iterator<E> { boolean hasnext(); E next(); void remove(); //optional

8 Iterator vs for each > Use Iterator instead of the for each construct when you need to: 1. Remove the current element. The for each construct hides the iterator, so you cannot call remove. Therefore, the for each construct is not usable for filtering. 2. Iterate over multiple collections in parallel. Example static void filter(collection<?> c) { for (Iterator<?> it = c.iterator(); it.hasnext(); ) if (!cond(it.next())) it.remove();

9 Removing Elements > The remove method of the Iterator interface removes the element that was returned by the last call to next. > In many situations, that makes sense you need to see the element before you can decide that it is the one that should be removed. > But if you want to remove an element in a particular position, you still need to skip past the element. Iterator<String> it = c.iterator(); it.next(); //skip over the first element it.remove(); // now remove it Removing Elements > If you want to remove two adjacent elements, you cannot simply call it.remove(); it.remove(); // Error! > Instead, you must first call next to jump over the element to be removed. it.remove(); it.next(); it.remove(); // Ok

10 Collection Interface Bulk Operations > Bulk operations perform an operation on an entire Collection. > The following are the bulk operations: containsall returns true if the target Collection contains all of the elements in the specified Collection. addall adds all of the elements in the specified Collection to the target Collection. removeall removes from the target Collection all of its elements that are also contained in the specified Collection Collection Interface Bulk Operations > The following are the bulk operations: retainall removes from the target Collection all its elements that are not also contained in the specified Collection. That is, it retains only those elements in the target Collection that are also contained in the specified Collection. clear removes all elements from the Collection.

11 Collection Interface Bulk Operations > The addall, removeall, and retainall methods all return true if the target Collection was modified in the process of executing the operation. Collection Interface Array Operations > The toarray methods are provided as a bridge between collections and older APIs that expect arrays on input. > The array operations allow the contents of a Collection to be translated into an array. > The simple form with no arguments creates a new array of Object. Object[] a = c.toarray(); > More complex form allows caller to provide an array or to choose the runtime type of the output array. String[] a = c.toarray(new String[0]);

12 Collection Operations > All the interfaces and classes defined in the Java Collections Framework are grouped in the java.util package. > All the concrete classes in the Java Collections Framework implement the Cloneable and Serializable interfaces. > Thus their instances can be cloned and serialized. > Some of the methods in the Collection interface cannot be implemented in the concrete subclass. > In this case, the method would throw java.lang.unsupportedoperationexception. The Set Interface > A Set is a Collection that cannot contain duplicate elements. It models the mathematical set abstraction. > The Set interface contains only methods inherited from Collection and adds the restriction that duplicate elements are prohibited. > Set also adds a stronger contract on the behavior of the equals and hashcode operations, allowing Set instances to be compared meaningfully even if their implementation types differ. > Two Set instances are equal if they contain the same elements.

13 The Set Interface public interface Set<E> extends Collection<E> { // Basic operations int size(); boolean isempty(); boolean contains(object element); boolean add(e element); boolean remove(object element); //optional Iterator<E> iterator(); // Bulk operations boolean containsall(collection<?> c); boolean addall(collection<? extends E> c); boolean removeall(collection<?> c); boolean retainall(collection<?> c); void clear(); // Array Operations Object[] toarray(); <T> T[] toarray(t[] a); The Set Interface

14 The Set Interface > The Java platform contains three general purpose Set implementations: HashSet stores its elements in a hash table, is the best performing implementation; however it makes no guarantees concerning the order of iteration TreeSet stores its elements in a red black tree, orders its elements based on their values; it is substantially slower than HashSet LinkedHashSet spares its clients from the unspecified, generally chaotic ordering provided by HashSet at a cost that is only slightly higher Set Interface Bulk Operations > Bulk operations are particularly well suited to Sets; when applied, they perform standard set algebraic operations. > Suppose s1 and s2 are sets s1.containsall(s2) returns true if s2 is a subset of s1 s1.addall(s2) transforms s1 into the union of s1 and s2. s1.retainall(s2) transforms s1 into the intersection of s1 and s2 s1.removeall(s2) transforms s1 into the (asymmetric) set difference of s1 and s2

15 The List Interface > A List is an ordered Collection. Lists may contain duplicate elements. In addition to the operations inherited from Collection, the List interface includes operations for the following: Positional access manipulates elements based on their numerical position in the list Search searches for a specified object in the list and returns its numerical position Iteration extends Iterator semantics to take advantage of the list's sequential nature Range view performs arbitrary range operations on the list. The List Interface public interface List<E> extends Collection<E> { // Positional access E get(int index); E set(int index, E element); boolean add(e element); void add(int index, E element); E remove(int index); boolean addall(int index, Collection<? extends E> c); // Search int indexof(object o); int lastindexof(object o); // Iteration ListIterator<E> listiterator(); ListIterator<E> listiterator(int index); // Range-view List<E> sublist(int from, int to);

16 The List Interface Comparison to Vector > If you've used Vector, you're already familiar with the general basics of List. > List is an interface, while Vector is a concrete implementation > Consider the following assignment statement. a[i] = a[j].times(a[k]); > The Vector equivalent is: v.setelementat(v.elementat(j).times(v.elementat(k)), i); > The List equivalent is: v.set(i, v.get(j).times(v.get(k)));

17 Comparison to Vector > Consider the following assignment statement. gift[5] = "golden rings"; > The Vector equivalent is: gift.setelementat("golden rings", 5); > The List equivalent is: gift.set(5, "golden rings"); ListIterator<E> public interface ListIterator<E> extends Iterator<E> { boolean hasnext(); E next(); boolean hasprevious(); E previous(); int nextindex(); int previousindex(); void remove(); void set(e e); void add(e e);

18 Iterating backward through a list for (ListIterator<Type> it = list.listiterator(list.size()); it.hasprevious(); ) { Type t = it.previous();... The Cursor > The cursor is always between two elements the one that would be returned by a call to previous and the one that would be returned by a call to next.

19 Queues and Priority Queues > A queue is a first in/first out data structure. > Elements are appended to the end of the queue and are removed from the beginning of the queue. > In a priority queue, elements are assigned priorities. > When accessing elements, the element with the highest priority is removed first. The Queue Interface

20 The PriorityQueue Interface The Map Interface > The Map interface maps keys to the elements. > The keys are like indexes. > In List, the indexes are integer. > In Map, the keys can be any objects.

21 The Map Interface Concrete Map Classes

22 JAVA PUZZLERS ON COLLECTIONS What s in a Name? (Puzzle 57) public class Name { private final String first, last; public Name(String first, String last) { this.first = first; this.last = last; public boolean equals(object o) { if (!(o instanceof Name)) { return false; Name n = (Name) o; return n.first.equals(first) && n.last.equals(last);

23 What s in a Name? public static void main(string[] args) { Set<Name> s = new HashSet<Name>(); s.add(new Name("Mickey", "Mouse")); System.out.println( s.contains(new Name("Mickey", "Mouse")) ); Solution public int hashcode() { return 31 * first.hashcode() + last.hashcode();

24 Making a Hash of It public class Name { private final String first, last; public Name(String first, String last) { this.first = first; this.last = last; public boolean equals(name n) { return n.first.equals(first) && n.last.equals(last); public int hashcode() { return 31 * first.hashcode() + last.hashcode(); Making a Hash of It (Puzzle 58) public static void main(string[] args) { Set<Name> s = new HashSet<Name>(); s.add(new Name("Donald", "Duck")); System.out.println( s.contains(new Name("Donald", "Duck")));

25 What is the Difference? (Puzzle 59) public class Difference { public static void main(string[] args) { int vals[] = { 789, 678, 567, 456, 345, 234, 123, 012 ; Set<Integer> diffs = new HashSet<Integer>(); for (int i = 0; i < vals.length; i++) for (int j = i; j < vals.length; j++) diffs.add(vals[i] - vals[j]); System.out.println(diffs.size()); One Liners (Puzzle 60.A) > Write a method that takes a List of elements and returns a new List containing the same elements in the same order with the second and subsequent occurrences of any duplicate elements removed. > For example, if you pass in a list containing "spam", "sausage", "spam", "spam", "bacon", "spam", "tomato", and "spam", you'll get back a new list containing "spam", "sausage", "bacon", and "tomato".

26 New Game (Puzzle 62) public class NewGame { public static void main(string[] args) { Map<Integer,String> map= new IdentityHashMap<Integer,String>(); map.put(108, "108"); map.put(108, "108"); map.put(549, "549"); map.put(549, "549"); System.err.println(map.size()); More of the Same (Puzzle 63) public class MoreNumbers { private Map<Integer,String> m = new HashMap<Integer,String>(); public void MoreNumbers(){ m.put(108,"108"); m.put(108,"108"); m.put(549,"549"); m.put(549,"549"); public static void main(string[] args) { MoreNumbers morenumbers= new MoreNumbers(); System.err.println(moreNumbers.getSize()); public int getsize(){ return m.size();

27 Concrete Collections ArrayList LinkedList HashSet An indexed sequence that grows and shrinks dynamically An ordered sequence that allows efficient insertions and removal at any location An unordered collection that rejects duplicates TreeSet A sorted set EnumSet A set of enumerated type values LinkedHashSet A set that remembers the order in which elements were inserted PriorityQueue A collection that allows efficient removal of the smallest element Concrete Collections HashMap A data structure that stores key/value associations TreeMap A map in which the keys are sorted EnumMap A map in which the keys belong to an enumerated type LinkedHashMap WeakHashMap IdentityHashMap A map that remembers the order in which entries were added A map with values that can be reclaimed by the garbage collector if they are not used elsewhere A map with keys that are compared by ==, not equals

28 Concrete Collections Concrete Collections

29 Concrete Collections Concrete Collections

30 Concrete Collections

31 Algorithms > The Collections class contains several simple but useful algorithms: static <T extends Comparable<? super T>> T min(collection<t> elements) static <T extends Comparable<? super T>> T max(collection<t> elements) static <T> min(collection<t> elements, Comparator<? super T> c) static <T> max(collection<t> elements, Comparator<? super T> c) Algorithms > static <T> void copy(list<? super T> to, List<T> from) copies all elements from a source list to the same positions in the target list. The target list must be at least as long as the source list. > static <T> void fill(list<? super T> l, T value) sets all positions of a list to the same value. > static <T> boolean addall(collection<? super T> c, T... values) adds all values to the given collection and returns true if the collection changed as a result. > static <T> boolean replaceall(list<t> l, T oldvalue, T newvalue) replaces all elements equal to oldvalue with newvalue.

32 Algorithms > static void swap(list<?> l, int i, int j) swaps the elements at the given offsets. > static void reverse(list<?> l) reverses the order of the elements in a list. For example, reversing the list [t, a, r] yields the list [r, a, t]. This method runs in O(n) time, where n is the length of the list. Algorithms > static int frequency(collection<?> c, Object o) returns the count of elements in c that equal the object o. > boolean disjoint(collection<?> c1, Collection<?> c2) returns true if the collections have no elements in common.

33 COLLECTION BEST PRACTICES Best Practice #1 > Use ArrayLists, HashMap etc as opposed to Vector, Hashtable etc, where possible to avoid any synchronization overhead. > If multiple threads concurrently access a collection and at least one of the threads either adds or deletes an entry into the collection, then the collection must be externally synchronized: Map mymap = Collections.synchronizedMap(myMap); List mylist = Collections.synchronizedList(myList);

34 Best Practice #2 > Set the initial capacity of a collection appropriately (e.g. ArrayList, HashMap etc). > This is because collection classes like ArrayList, HashMap etc. must grow periodically to accommodate new elements. > But if you have a very large array, and you know the size in advance then you can speed things up by setting the initial size appropriately. > HashMaps/Hashtables need to be created with sufficiently large capacity to minimize rehashing (which happens every time the table grows) Best Practice #2 (Con t) > HashMap has two parameters initial capacity load factor > Higher load factor values (default load factor of 0.75 provides a good trade off between performance and space) will reduce the space cost but will increase the lookup cost of mymap.get(&) and mymap.put(&) methods. > When the number of entries in the HashMap exceeds the current capacity loadfactor then the capacity of the HashMap is roughly doubled by calling the rehash function.

35 Best Practice #2 (Con t) > It is also very important not to set the initial capacity too high or load factor too low if iteration performance or reduction in space is important. Best Practice #3 > Program in terms of interface not implementation > For example, you might decide a LinkedList is the best choice for some application, but then later decide ArrayList might be a better choice for performance reason. > Use: List list = new ArrayList(100); > Instead of: ArrayList list = new ArrayList();

36 Best Practice #4 > Return zero length collections or arrays as opposed to returning null > Returning null instead of zero length collection is more error prone, since the programmer writing the calling method might forget to handle a return value of null. Best Practice #5 > Map.containsKey(key) If null keys are allowed in the Map, and null keys are not being used as valid keys in the Map Look for unnecessary call flows that look like: if (map.containskey(key)) value = map.get(key); value will be null if a key is not found via map.get(key) Other use cases using Map methods such as put(key, value) or remove(key) may be eliminated, too.

37 TUNING MEMORY USAGE Java Collections > Each Java Collection has a different level of function, and memory overhead Increasing Functions java.util.hashset java.util.hashmap java.util.hashtable java.util.linkedlist java.util.arraylist Increasing Size > Using the wrong type of collection can incur significant additional memory overhead

38 HashSet public static void main(string[] args){ HashSet<Integer> set= new HashSet<>(); > Implementation of the Set interface > Implementation is a wrapper around a HashMap > Default capacity for HashSet is 16 > Empty size is 144 bytes > Additional 16 bytes overhead for wrapping over HashMap HashMap public static void main(string[] args){ HashMap<Integer> map= new HashMap<>(); > Implementation of the Map interface > Implementation is an array of HashMap$Entry objects > Default capacity is 16 > Empty size is 128 bytes > Overhead is 48 bytes for HashMap Plus (16 + (entries * 4)) byte for array Plus overhead of HashMap$Entry objects

39 LinkedList public static void main(string[] args){ LinkedList list= new LinkedList(); > Implementation of the List interface > Implementation is a linked list of LinkedList$Entry objects > Default capacity is 1 > Empty size is 48 bytes > Overhead is 24 bytes for LinkedList Plus overhead of LinkedList$Entry objects ArrayList public static void main(string[] args){ ArrayList list= new ArrayList(); > Implementation of the List interface > Implementation is a an array of Object > Default capacity is 10 > Empty size is 88 bytes > Overhead is 32 bytes for ArrayList Plus (16 + (entries * 4)) byte for array For a 10,000 entry ArrayList, overhead is ~40K

40 Collections Summary Collection Default Capacity Empty size 10K Overhead HashSet K HashMap K Hashtable K LinkedList K ArrayList K StringBuffer Collections Summary Collection Empty size 10K Overhead Expansion HashSet K x2 HashMap K x2 Hashtable K x2 + 1 LinkedList K + 1 ArrayList 88 40K x1.5 StringBuffer x2