Programming & Data Structures GRIFFITH COLLEGE DUBLIN Programming & Data Structures Java Collections Framework Lecture 21

What is a Collection A Collection (sometimes called a container) is simply an object that groups multiple elements into a single unit. Collections are used to store, retrieve and manipulate data, and to transmit data from one method to another. While earlier versions of Java contained collection implementations, they did not contain a collections framework. A collections framework is a unified architecture for representing and manipulating collections. All collections frameworks contain three things: Lecture 21

Three Elements of Framework Interfaces: abstract data types representing collections. Interfaces allow collections to be manipulated independently of the details of their representation. In object-oriented languages like Java, these interfaces generally form a hierarchy. Implementations: concrete implementations of the collection interfaces. In essence, these are reusable data structures. Algorithms: methods that perform useful computations, like searching and sorting, on objects that implement collection interfaces. Lecture 21

Benefits of Collections Framework It reduces programming effort: By providing useful data structures and algorithms, frees you to concentrate on the important parts of your program, rather than implemenation It increases program speed and quality: The collections framework does this primarily by providing high-performance, high-quality implementations. It fosters software reuse: New data structures that conform to the standard collection interfaces are by nature reusable. The same goes for new algorithms. It allows interoperability among unrelated APIs: The collections interfaces will become the "lingua franca" by which APIs pass collections back and forth. Lecture 21

Interfaces The core collection interfaces are the interfaces used to manipulate collections, and to pass them from one method to another. The basic purpose of these interfaces is to allow collections to be manipulated independently of the details of their representation. When you understand how to use these interfaces, you know most of what there is to know about the framework. The core collections interfaces are shown below: Lecture 21

Collections Framework The core collection interfaces form a hierarchy: Collection Set List HashSet Map SortedMap TreeMap HashMap ArrayList TreeSet LinkedList Stack Lecture 21

Collection The Collection interface is the root of the collection hierarchy. A Collection represents a group of objects Some Collection implementations allow duplicate elements and others do not. Some are ordered and others unordered. The JDK doesn't provide any direct implementations of this interface: It provides implementations of more specific subinterfaces like Set and List. This interface is the least common denominator that all collections implement. Collection is used to pass collections around and manipulate them when maximum generality is desired. Lecture 21

Set and List Containers A Set is a collection that cannot contain duplicate elements. It is used to represent sets like the cards comprising a poker hand, the courses making up a student's schedule, or the processes running on a machine. A List is an ordered collection (sometimes called a sequence). Lists can contain duplicate elements. The user of a List generally has precise control over where in the List each element is inserted. The user can access elements by their integer index (position). If you've used Vector, you're already familiar with the general flavour of List. Lecture 21

Map Container Map is an object that maps keys to values. Maps cannot contain duplicate keys: Each key can map to at most one value. The last two core collection interfaces (SortedSet (not shown) and SortedMap) are merely sorted versions of Set and Map. A SortedSet is a Set that maintains its elements in ascending order. Several additional operations are provided to take advantage of the ordering. A SortedMap is a Map that maintains its mappings in ascending key order. Lecture 21

Collection Interface public interface Collection { // Basic Operations int size(); boolean isEmpty(); boolean contains(Object element); boolean add(Object element); boolean remove(Object element); Iterator iterator(); // Bulk Operations boolean containsAll(Collection c); boolean addAll(Collection c); boolean removeAll(Collection c); boolean retainAll(Collection c); void clear(); // Array Operations Object[] toArray(); Object[] toArray(Object a[]); } Lecture 21

Discussion The interface has methods to tell you how many elements are in the collection (size, isEmpty), to check if a given object is in the collection (contains), to add and remove an element from the collection (add, remove), and to provide an iterator over the collection (iterator). The add method is defined generally enough so that it makes sense for collections that allow duplicates as well as those that don't. Similarly, the remove method is defined to remove a single instance of the specified element from the Collection, assuming the Collection contains the element. Lecture 21

Iterators The object returned by the iterator method deserves special mention. It is an Iterator. Iterators allow the caller to remove elements from the underlying collection during the iteration with well-defined semantics. public interface Iterator { boolean hasNext(); Object next(); void remove(); } The remove method removes from the underlying Collection the last element that was returned by next. The remove method may be called only once per call to next, and throws an exception if this condition is violated. Lecture 21

Iterators The following snippet shows you how to use an Iterator to filter a Collection, that is, to traverse the collection, removing every element that does not satisfy some condition: static void filter(Collection c) { for (Iterator i = c.iterator(); i.hasNext(); ) if (!cond(i.next())) i.remove(); } Note : The code is polymorphic: it works for any Collection that supports element removal, regardless of implementation. Lecture 21

Bulk Operations The bulk operations perform some operation on an entire Collection in a single shot. containsAll: Returns true if the target Collection contains all of the elements in the specified Collection (c). 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. retainAll: Removes from the target Collection all of its elements that are not also contained in the specified Collection. clear: Removes all elements from the Collection. Lecture 21

Array Methods The toArray allow the contents of a Collection to be translated into an array. The simple form with no arguments creates a new array of Object. The more complex form allows the caller to provide an array or to choose the runtime type of the output array. For example, suppose c is a Collection. The following snippet dumps the contents of c into a newly allocated array of Object whose length is identical to the number of elements in c: Object[] a = c.toArray(); Suppose c is known to contain only strings. The following snippet dumps the contents of c into a newly allocated array of String whose length is identical to the number of elements in c: String[] a = (String[]) c.toArray(new String[0]); Lecture 21

Set Interface A Set is a Collection that cannot contain duplicate elements. Set models the mathematical set abstraction. The Set interface extends Collection and contains no methods other than those inherited from Collection. It adds the restriction that duplicate elements are prohibited. Two Set objects are equal if they contain the same elements. Lecture 21

List Interface A List is an ordered Collection (sometimes called a sequence). Lists may contain duplicate elements. In addition to the operations inherited from Collection, the List interface includes operations for: Positional Access: manipulate 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. Lecture 21

List Interface public interface List extends Collection { // Positional Access Object get(int index); Object set(int index, Object element); void add(int index, Object element); Object remove(int index); abstract boolean addAll(int index, Collection c); // Search int indexOf(Object o); int lastIndexOf(Object o); // Iteration ListIterator listIterator(); ListIterator listIterator(int index); // Range-view List subList(int from, int to); } Lecture 21

Implementations The JDK contains two general-purpose List implementations. ArrayList which is generally the best-performing implementation LinkedList which offers better performance under certain circumstances. Also, Vector has been retrofitted to implement List. Lecture 21

Discussion hasNext() and hasPrevious() next() and previous() The remove operation always removes the first occurrence of the specified element from the list. The add and addAll operations always append the new element(s) to the end of the list. The set and remove operations return the old value that is being overwritten or removed The ListIterator allows us to move backwards as well as forwards through the List hasNext() and hasPrevious() next() and previous() The subList method allows us to manipulate subLists using the same methods we use on Lists Lecture 21

Algorithms 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. shuffle(List): Randomly permutes the elements in a List. 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. Collections.min(List) and Collections.max(List) return the extreme values in the List Lecture 21

Map Interface 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); } } Lecture 21

Map Interface The Basic and Bulk Operations perform as you would expect. The Collection-view 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 Collection-views provide the only means to iterate over a Map Lecture 21

Example Code : HashSet import java.util.*; public class CollTest { public static void main(String [] args) { // HashSet example HashSet hs = new HashSet(); String st; hs.add(" Beta "); hs.add(" Alpha "); hs.add(" Gamma "); System.out.println(hs); for(Iterator i = hs.iterator(); i.hasNext();) { st = (String)i.next(); System.out.println(st); } Lecture 21

Example Code : LinkedList import java.util.*; public class CollTest { public static void main(String [] args) { // LinkedList example LinkedList ll = new LinkedList(); String st; ll.add(" Beta "); ll.add(" Alpha "); ll.add(" Gamma "); System.out.println(ll); for(Iterator i = ll.iterator(); i.hasNext();) { st = (String)i.next(); System.out.println(st); } Collections.sort(ll); Lecture 21

Example Code : TreeMap import java.util.*; public class CollTest { public static void main(String [] args) { // TreeMap example TreeMap tm = new TreeMap(); String st; tm.put(“A”, " Beta "); tm.put(“B”, " Alpha "); tm.put(“B”, " Gamma "); System.out.println(tm); Set ks = tm.keySet(); for(Iterator i = ks.iterator(); i.hasNext();) { st = (String)i.next(); System.out.println(st); } Lecture 21

Summary The Java Collection Framework supplies us with reusable data structures and algorithms to manipulate data in many ways The main elements are Containers, Interfaces and Algorithms The main Interfaces are Map, List and Set The main concrete implementations are HashMap, TreeMap, HashSet, TreeSet, ArrayList, LinkedList, Stack and Vector The Java Tutorial Collections Trail is very informative Lecture 21