Java's Collections Framework

• As we've seen, the Java standard library provides class definitions and Java interfaces for many data structures ('collections') (mostly in java.util)
• Here are some of the Java interfaces:
• Note that there can be inheritance between Java interfaces as well as classes (even multiple inheritance)

Java's Collection interface

The Java interface java.util.Collection includes the following:

Java's Set interface

• A set is a collection of objects in which there are no duplicates and order is not significant
• Java's Set interface inherits from Collection but changes the semantics of certain methods, e.g.

  add(o)

  Add object o to the set if it is not already present

Java's List interface

• A list is a collection in which duplicates are allowed and order is significant. Elements are indexed starting from 0
• Java's List interface inherits from Collection but changes the semantics of certain methods and declares additional methods, e.g.:

  add(i, o)	Inserts object o at position i
  add(o)	Appends object o to end of list
  get(i)	Returns element at position i
  indexOf(o)	Returns the index of the first occurrence of o
  remove(i)	Removes & returns the element at the ith position
  remove(o)	Removes the first occurrence of object o
  set(i, o)	Replaces the element at the ith position by o and returns the replaced element

Java's Map interface

• A map (or dictionary or associative array) is a collection of key-value pairs. Duplicate keys are not allowed & order is not significant
• Java's Map interface includes the following (plus isEmpty() and size()):

  containsKey(k)	Returns true if this map contains a mapping for key k
  containsValue(v)	Returns true if there is a mapping to value v
  get(k)	Returns the value to which key k is mapped
  keySet()	Returns a Set containing all the keys in this map
  put(k, v)	Adds a mapping from k to v
  remove(k)	Removes the mapping for key k from this map
  values()	Returns a Collection of all the values in this map

Implementations

Once you've decided which Java interface to use, you choose an implementation (or implement a new one of your own)

(Where Java needs to test for equalkity of objects in these data structures, it wil use your equals method. For the hash tables, it will use your hashCode method)

Traversing collections

• You'll often want to write code that vists each item in a data structure
  • e.g. computing the total number of library boooks on loan
  • e.g. finding the card with highest value in a hand
• Obviously this needs some sort of loop but the code will differ depending on how the data structure is implemented
  • e.g. incrementing an index to access each element in an array
  • e.g. following pointers sequentially through a linked list
  • e.g. following pointers recursively to walk a tree

Iterators

• An iterator is an object that 'knows' how to traverse a collection
  • You obtain an iterator object using the iterator() method (see the Collection interface)
  • Then the iterator offers you at least two methods: hasNext and next
• Example:
  • Suppose we have a collection, e.g.

    List<LibraryBook> library = new LinkedList<LibraryBook>();

  • Then we can traverse it, as follows:

    Iterator<LibraryBook> iter = library.iterator();
    while (iter.hasNext()) {
        LibraryBook b = iter.next();
        // Do something with b
    }

  • If you change to an ArrayList, the rest of the code remains unchanged because it too has an iterator

A new for-loop

• Much simpler than iterators is the new for-loop
• Example:

  for (LibraryBook b : library) {
      // Do something with b
  }

• Should remind you of this in Python:

  for b in library:
      # Do something with b

• These new for-loops even work with Java arrays, e.g.

  int[] numbers = {1, 3, 5, 7};
  int total = 0;
  for (int n : numbers) {
      total = total + n;
  }