1. 1 Java's Collection Framework By Rick Mercer with help from The Java Tutorial, The Collections Trail, by Joshua BlockThe Collections Trail

2. 2 Overview Framework (in software): a general system of components and architectural solutions that provides development tools to programmers for use with a relatively wide range of applications. Collection: (hmm...) any collection of elements

3. 3 Collection Framework  A collections framework is a unified architecture for representing and manipulating collections. It has: –Interfaces: abstract data types representing collections –Implementations: concrete implementations of the collection interfaces –Algorithms: methods that perform useful computations, such as searching and sorting These algorithms are said to be polymorphic: the same method can be used on different implementations

4. 4 Interfaces  An interface describes a set of methods: –no constructors or instance variables  Interfaces must be implemented by classes –646 java classes implement >= 1 interfaces (‘02)  2 or more classes implement an interface –Classes guaranteed to have the same methods –Objects can be treated as the same type –Can use different algorithms / instance variables

5. 5 Collection interfaces Queue since Java 5 Click here for a Annotated Outline of Collections FrameworkAnnotated Outline of Collections Framework

6. 6 Implementations  A collection class –implements an ADT as a Java class –implements all methods of the interface –selects appropriate instance variables –can be instantiated  Java implements interfaces with – List: ArrayList, LinkedList, Vector – Map: HashMap, TreeMap – Set: TreeSet, HashSet

7. 7 Algorithms  Java has polymorphic algorithms to provide functionality for different types of collections –Sorting (e.g. sort)Sorting –Shuffling (e.g. shuffle)Shuffling –Routine Data Manipulation (e.g. reverse, addAll)Routine Data Manipulation –Searching (e.g. binarySearch)Searching –Composition (e.g. frequency)Composition –Finding Extreme Values (e.g. max)Finding Extreme Values

8. 8 Two Useful ADTs  List: a collection with a first element, a last element, distinct predecessors and successors –duplicates that "equals" each other are allowed  Map: maps keys to values Map –Maps cannot contain duplicate keys –Each key maps at most one value

9. 9 List  A list is –a collection of elements (numbers, strings, accounts, pictures,…) –ordered (a sequence): there is a first, and a last element lists can be empty – no elements –elements with a unique predecessor and successor –also known as a sequence  Peruse the Java 5 List InterfaceList Interface

10. 10 ArrayList A Java Collection Class that Implements List  ArrayList –stores a collection of any type of object –can be all the same type, or different types –similar functionality to an array, but does not use subscripts –is an indexed collection  The next slide is part of Sun's documentation

11. 11 ArrayList Java  Resizable-array implementation of the List interface. Implements all optional list operations, and permits all elements, including null. In addition to implementing the List interface, this class provides methods to manipulate the size of the array that is used internally to store the list. The size, isEmpty, get, set, iterator, and listIterator operations run in constant time. The add operation runs in amortized constant time, that is, adding n elements requires O(n) time. All of the other operations run in linear time (roughly speaking). The constant factor is low compared to that for the LinkedList implementation.

12. 12 List implemented by 3 classes // Interface name: List // Three classes that implement the List interface: List bigList = new ArrayList (); List littleList = new LinkedList (); List sharedList = new Vector (); // All three have an add method bigList.add("in array list"); littleList.add("in linked list"); sharedList.add("in vector"); // All three have a get method assertEquals("in array list", bigList.get(0)); assertEquals("in linked list", littleList.get(0)); assertEquals("in vector", sharedList.get(0));

13. 13 Java 5 Generics  A List can be made to store only one type List accountList = new ArrayList (); accountList.add(new BankAccount("One", 111.11)); accountList.add(new BankAccount("Two", 222.22)); accountList.add(new BankAccount("Three", 333.33)); accountList.add(new BankAccount("Four", 444.44)); System.out.println(accountList.toString()); Output [One $111.11, Two $222.22, Three $333.33, Four $444.44]

14. 14 Iterators  Iterators provide a general way to traverse all elements in a collection ArrayList list = new ArrayList (); list.add("1-FiRsT"); list.add("2-SeCoND"); list.add("3-ThIrD"); Iterator itr = list.iterator(); while (itr.hasNext()) { System.out.println(itr.next().toLowerCase()); } Output 1-first 2-second 3-third

15. 15 Map and SortedMap  The Map interface defines methodsMap interface – get, put, contains, keySet, values, entrySet  TreeMap implements Map –put, get, remove: O(log n)  HashMap implements Map –put, get, remove: O(1)

16. 16 Set and SortedSet  Some Map methods return Set  The Set interface – add, addAll, remove, size, but no get !  Some implementations – TreeSet : values stored in order, O(log n) – HashSet : values in a hash table, no order, O(1)

17. 17 Let's play  Set up a small collection of mappings Map tm = new TreeMap (); tm.put("M", new BankAccount("Michel", 111.11)); tm.put("G", new BankAccount("Georgie", 222.22)); tm.put("S", new BankAccount("Sam", 333.33)); tm.put("P", new BankAccount("Pei", 444.44)); tm.put("Z", new BankAccount("Zac", 555.55)); // Coming up: Some Map methods

18. 18 keySet() // Get the set of keys in the Map. // With TreeMap, the keys are ordered. Set keys = tm.keySet(); assertEquals("[G, M, P, S, Z]", keys.toString());

19. 19 values() // The values Collection accountCollection = tm.values(); Iterator itr = accountCollection.iterator(); double allTheMoney = 0.0; while (itr.hasNext()) { allTheMoney += itr.next().getBalance(); } assertEquals(1666.65, allTheMoney, 0.01);

20. 20 entrySet() // The mappings Collection > mapping = tm.entrySet(); Iterator > itr2 = mapping.iterator(); while (itr2.hasNext()) { System.out.print("<" +itr2.next().toString() + "> "); }

21. 21 Enhanced for Loop  for can iterate over collections for (Type element : collection) { element is the next thing visited for each iteration } ArrayList names = new ArrayList (); names.add("Aaron"); names.add("Moksha"); names.add("Drew"); names.add("Qiyam"); for (String name : names) System.out.print(name + " "); Output Aaron Moksha Drew Qiyam

22. 22 Use for over iterator Collection accountCollection = tm.values(); double allTheMoney = 0.0; for (BankAccount nextAccount : accountCollection) allTheMoney += nextAccount.getBalance(); assertEquals(1666.65, allTheMoney, 0.01);

23. 23 Algorithms  See the Java API for the Collections classCollections –play with sort, binarySearch, reverse, shuffle your choice