By Rick Mercer with help from

1
Java's Collection Framework

• By Rick Mercer with help from
• The Java Tutorial, The Collections Trail, by
  Joshua Block

2
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

3
Interfaces

• An interface describes a set of methods
• no constructors or instance variables
• Interfaces must be implemented by classes
• 646 java classes implement gt 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

4
Collection interfaces
Queuesince Java 5
5
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

6
Algorithms

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

7
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
• Maps cannot contain duplicate keys
• Each key maps at most one value

8
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 Interface

9
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

10
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.

11
List implemented by 3 classes

• // Interface name List
• // Three classes that implement the List
  interface
• ListltStringgt bigList new ArrayListltStringgt()
• ListltStringgt littleList new LinkedListltStringgt()
  
• ListltStringgt sharedList new VectorltStringgt()
• // 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))

12
Generics

• A List can be made to store only one type
• ListltBankAccountgt accountList
• new ArrayListltBankAccountgt()
• 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

13
Algorithms

• See the Java API for the Collections class
• play with max, min, sort, binarySearch, shuffle
  reverse

14
Iterators

• Iterators provide a general way to traverse all
  elements in a collection
• ArrayListltStringgt list new
  ArrayListltStringgt()
• list.add("1-FiRsT")
• list.add("2-SeCoND")
• list.add("3-ThIrD")
• IteratorltStringgt itr list.iterator()
• while (itr.hasNext())
• System.out.println(itr.next().toLowerCase())
  

Output 1-first 2-second 3-third
15
Enhanced for loop

• If a class extends IterableltEgt (like you did with
  your SetltEgt class), you can use Java's enhanced
  for loop of this general form
• for (E refVar collectionltEgt )
• refVar refers to each element in
  collectionltEgt
• example
• ArrayListltStringgt list new
  ArrayListltStringgt()
• list.add("first")
• for (String s list)
• System.out.println(s.toLowerCase())

16
Map and SortedMap

• The Map interface defines methods
• get, put, contains, keySet, values, entrySet
• TreeMap implements Map
• put, get, remove O(log n)
• HashMap implements Map
• put, get, remove O(1)

17
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)

18
Let's play

• Set up a small collection of mappings
• MapltString, BankAccountgt tm
• new TreeMapltString,
  BankAccountgt()
• 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

19
keySet()

• // Get the set of keys in the Map.
• // With TreeMap, the keys are ordered.
• SetltStringgt keys tm.keySet()
• assertEquals("G, M, P, S, Z", keys.toString())

20
values()

• // The values
• CollectionltBankAccountgt accountCollection
• tm.values()
• IteratorltBankAccountgt itr
• accountCollection.iterator()
• double allTheMoney 0.0
• while (itr.hasNext())
• allTheMoney itr.next().getBalance()
• assertEquals(1666.65, allTheMoney, 0.01)

21
entrySet()

• // The mappings
• CollectionltEntryltString, BankAccountgtgt mapping
• tm.entrySet()
• IteratorltEntryltString, BankAccountgtgt itr2
• mapping.iterator()
• while (itr2.hasNext())
• System.out.print("lt" itr2.next().toString()
• "gt ")
• ltGGeorgie 222.22gt ltMMichel 111.11gt
• ltPPei 444.44gt ltSSam 333.33gt ltZZac 555.55gt

22
Maps do not have an iterator

• Code Demo Sum up all balances in tm
• There is no iterator method in TreeMap