Status check

• Exam 2; last day to withdraw
• Tamarin grader

xkcd: How to Write Good Code

from xkcd.com

Java Collections

• About 1/2 the classes in java.util
  • not things like Scanner, Calendar, Random, Formatter, etc
• Interfaces (ADTs), implementations, algorithms (static helper methods)
• Major reuse: standard, correct, efficient, maintained

Collection interface (ADT)

• java.util.Collection
• Root/super interface others extend
• Iterable, so can use for-each on any Collection
• Various add, remove, contains operations (no indices though)
• Notice: no get (makes sense: think of stack or queue)
• toArray methods

List interface (ADT)

• Most commonly used ADT
• java.util.List
• extends Collection
• add, get, set, remove: by index
• indexOf, lastIndexOf
• ListIterator (as well as Iterator)
• subList, which gives a view of the list (ie, changes to returned List affect original)
• See Tutorial for more.

subList Examples

From Tutorial:

List<?> list = ...
list.subList(fromIndex, toIndex).clear();

int i = list.subList(fromIndex, toIndex).indexOf(o);
int j = list.subList(fromIndex, toIndex).lastIndexOf(o);

public static <E> List<E> dealHand(List<E> deck, int n) {
    int deckSize = deck.size();
    List<E> handView = deck.subList(deckSize - n, deckSize);
    List<E> hand = new ArrayList<E>(handView);
    handView.clear();
    return hand;
}

Queue interface (ADT)

• java.util.Queue
• extends Collection
• add / remove / element - throws exception
• offer / poll / peek - return null on error

Deque interface (ADT)

• java.util.Deque
• extends Queue, Collection
• Not covered in Tutorial
• now preferred to Java's old Stack class (since no access to center elements)

Other ADTs

Also covered in Tutorial:

• Set: just like Collection, but no duplicates (ignores)
• Map: key-value pairs (like a dictionary); not a Collection subclass; (we'll come back to this)
• SortedSet, SortedMap: elements/keys kept sorted (for iterator or toArray)

More stuff in java.util.concurrent too, but generally not necessary since we're not using threads

Implementations

• As we've seen, different implementations have different performance tradeoffs
  • array: add (with iterator) - O(n), get (with iterator) - O(1), get (without iterator) - O(1)
  • nodes: add (with iterator) - O(1), get (with iterator) - O(1), get (without iterator) - O(n)
• So, interface == ADT: behavior (what you need done)
• Concrete implementations of those ADTs (how you need it done)
• All Collection implementations have a constructor that takes a Collection for easy conversion

Implementations

• ArrayList
• LinkedList
• ArrayDeque

Others:

• Sets: HashSet, TreeSet, LinkedListSet, etc
• Queue: PriorityQueue (we'll revisit this)

Using Implementations

• Always use interfaces for your variable declarations

    List<String> names = new ArrayList<String>();
  

    //btw:
    List<String> names = new ArrayList<>(); //Java 7's diamond <> operator
  

• Can then easily change implementation later in one single place
• Methods should also be declared to take/return List (not an specific implementation)
• Unlike A05:

    public java.util.ArrayList<Direction> getPathToExit()  //bad
  

    public java.util.List<Direction> getPathToExit()  //good
  

Old Implementations

Generally don't use these. synchronized, so slight overhead to them (not as efficient)

• Vector (prefer: ArrayList)
• Stack (prefer: Deque)

Collections class

• java.util.Collections
• All static helper methods ("algorithms")
• Wrappers: checked, synchronized, unmodifiable
• Some very handy tools in here: sort, shuffle, reverse, replaceAll, etc, etc.

java.util.Arrays

• java.util.Arrays
• handy too, though impoverished compared to Collections
• Note: java.util.Arrays.asList method that provides a List view of the array
• (how varargs work)

    String[] cards = {"AS", "2S", "3S", "4S", "5S", ...}
    java.util.List<String> deck = java.util.Arrays.asList(cards);
    java.util.Collections.shuffle(deck);
    System.out.println(deck);                 //last two lines print same thing
    System.out.println(java.util.Arrays.toString(cards));

Implementation Help

• Abstract collections provide most of the methods for you built on some core
• You just need to provide implementations of those core methods
• AbstractCollection, AbstractSet, AbstractList, AbstractSequentialList, etc.
• Some methods optional if your collection meant to be unmodifiable or fixed size

Other useful classes: Comparator

• java.util.Comparator
• like compareTo, but as its own object
• compares two given objects of the same type
• Can be used to provide lots of different sort orders
  • Example: comparator for PlayingCard: AceHigh, AceLow, BySuit, etc.
• Or can be used when you don't have access to a class implementation
  • Example: String's CASE_INSENSITIVE_ORDER; or a comparator that handles prefix numbers "properly"

For next time

• A06b (I need to get the grader up...)
• Quiz 07 (queue) still open
• A07 coming soon
• Exam 2
• Next time: quick recap/review for exam; GUIs.