Set Uses

I don't use this one much

Handy for when you want to remove duplicates:

  // c is some Collection<Type> (List, Queue, or whatever)
  Collection<Type> noDups = new HashSet<Type>(c);

Set-like operations:

  Set<Integer> s = ...
  Collection<Integer> c = ... 
  if (s.containsAll(c)) {  ...  //c is a subset of s?
  s.addAll(c);     //s is now union of s and c
  s.retainAll(c);  //s is now intersection of s and c
  s.removeAll(c);  //s is now difference of s and c

Set Implementations

HashSet - best all-round implementation
- (How would this be implemented?)
LinkedHashSet - as HashSet, but iterator order == order of insertions
TreeSet - uses a red-black tree (kind of balanced BST), so items need to be Comparable or have Comparator

Set Variations

SortedSet
- Lets you grab subset (from/to)
NavigableSet (extends SortedSet)
- Lets you access higher, lower, floor, ceiling, or reverse order
TreeSet is only java.util implementation of both of these

Map

java.util.Map
Also called dictionary, associative array, or hash in other languages
maps keys to values, so need to specify <Type> for both
Stores them together as a pair in an Entry object
Key must be unique (or will overwrite old value for that key)
Does not extend Collection

Map Methods

put(key, value)
size(), isEmpty()
get(key) - returns value
remove(key) - removes Entry
containsKey(key), containsValue(value)
keySet() - returns a Set view of all keys
entrySet() - returns as Set view of all Entries
values() - a Collection of all values (may have duplicates)
(not Iterable, but Set is, so can iterator over returned set)

Map Implementations

HashMap - usually best choice
- (How would this be implemented?)
LinkedHashMap - as HashMap, but iterator order (of returned sets) == order of key insertions
TreeSet - uses a red-black tree (kind of balanced BST), so items need to be Comparable or have Comparator

There is also a SortedMap and NavigableMap, which work like SortedSet and NavigableMap for keys and entries.

Map Uses: Counting instances

  /** Counts the frequency of every token in the a given file. */
  Scanner filein = new Scanner(new java.io.File(filename));
  Map<String, Integer> wordCounts = new HashMap<String, Integer>();
  while (filein.hasNext()) {
    String word = filein.next().toLowerCase();
    if (wordCounts.containsKey(word)) {
      wordCounts.put(word, wordCounts.get(word) + 1);
    }else {
      wordCounts.put(word, 1);
    }
  }

A sample input file

How much wood would a woodchuck chuck
  if a woodchuck could chuck wood ?
A woodchuck would chuck all the wood he could chuck
  if a woodchuck could chuck wood .

Map Uses: Printing with toString()

  System.out.println(wordCounts);

Prints:

{wood=4, how=1, chuck=5, a=4, woodchuck=4, he=1, the=1, .=1, much=1, 
 would=2, could=3, if=2, ?=1, all=1}

Change HashMap to LinkedHashMap:

{how=1, much=1, wood=4, would=2, a=4, woodchuck=4, chuck=5, if=2, could=3, ?=1, 
  all=1, the=1, he=1, .=1}

Map Uses: Querying

  System.out.println("wood: " + wordCounts.get("wood"));
  System.out.println("chuck: " + wordCounts.get("chuck"));
  System.out.println("woodchuck: " + wordCounts.get("woodchuck"));

Prints:

wood: 4
chuck: 5
woodchuck: 4

Map Uses: Iterating over contents

  for (String word : wordCounts.keySet()) {
    System.out.println(word + " " + wordCounts.get(word));
  }

Prints:

wood 4
how 1
chuck 5
a 4
woodchuck 4
he 1
the 1
. 1
much 1
would 2
could 3
if 2
? 1
all 1

Map Uses: Iterating over contents with Entry set

  for (Map.Entry<String, Integer> wordCount : wordCounts.entrySet()) {
    System.out.println(wordCount.getKey() + " " + wordCount.getValue());
  }

Prints same as previous slide.

Map Uses: Views

keySet() and entrySet() and values() return views: objects that reflect the original and pass on any changes

  //removes all entries (keys and count values) for punctuation
  Set<String> punctuation = new HashSet<String>(Arrays.asList(".", "?", "!"));
  wordCounts.keySet().removeAll(punctuation);
  System.out.println(wordCounts);

  //removes all entries with a count value of 1, 2, or 3
  Set<Integer> counts = new HashSet<Integer>(Arrays.asList(1, 2, 3));
  wordCounts.values().removeAll(counts);
  System.out.println(wordCounts);  //Prints: {wood=4, chuck=5, a=4, woodchuck=4}

Another view example

  String[] nums = {"one", "two", "three", "four"};
  System.out.println(java.util.Arrays.toString(nums));  //[one, two, three, four]

  List<String> numbers = java.util.Arrays.asList(nums);
  numbers.set(1, "2");

  System.out.println(java.util.Arrays.toString(nums));  //[one, 2, three, four]

Can't add or remove from List returned by asList, but can change it.
- Point: So you can use all Collections methods on arrays now too: like shuffle, etc.
Be careful not to affect original map if you don't mean to!
- Particularly hard to debug is List view is passed to another method and changed there

Comparator

Both SortedSet and SortedMap mention a Comparator... also used by java.util sort methods.
Mentioned this briefly before

java.util.Comparator

public interface Comparable<T> {

  public int compare(T o1, T o2);
  
}

Basically compareTo for type T object, but as a separate object

PlayingCard

public class PlayingCard {

  private int value;
  private Suit suit;

  public PlayingCard(int value, Suit suit) {
    if (value < 1 || value > 13) {
      throw new IllegalArgumentException("Value " + value +
          " out of valid 1 - 13 range.");
    }
    this.value = value;
    this.suit = suit;
  }

  public int getValue() {
    return this.value;
  }
  public Suit getSuit()  {
    return this.suit;
  }
  
  @Override
  public String toString() {
    String v = "" + this.value;
    switch (this.value) {
      case 1:  v = "A"; break;
      case 11: v = "J"; break;
      case 12: v = "Q"; break;
      case 13: v = "K"; break;
    }
    return v + this.suit;
  }

  // nested class for Suit
  public static enum Suit {
    C, D, H, S;
  }
}

PlayingCard Comparator

PlayingCard is not Comparable
- Even if it was, we might want to sort it in a different order

Can use a Comparator in this case

public class BySuitThenValue implements Comparator<PlayingCard> {

  public int compare(PlayingCard left, PlayingCard right) {
    int suitDiff = left.getSuit().ordinal() - right.getSuit().ordinal();
    if (suitDiff == 0) {
      //same suit, so sort on value
      return left.getValue() - right.getValue();
    }else {
      return suitDiff;
    }
  }
}

PlayingCard could even offer a number of different Comparator implementations as nested classes

PlayingCard Comparator Use

  List<PlayingCard> deck = new ArrayList<PlayingCard>(52);
  for (int v = 1; v <= 13; v++) {
    for (PlayingCard.Suit s : PlayingCard.Suit.values()) {
      deck.add(new PlayingCard(v, s));
    }
  }
  System.out.println(deck);
  Collections.shuffle(deck);
  System.out.println(deck);
  Collections.sort(deck, new BySuitThenValue());  //Comparator use
  System.out.println(deck);

Prints:

[AC, AD, AH, AS, 2C, 2D, 2H, 2S, 3C, 3D, 3H, 3S, 4C, 4D, 4H, 4S, ...
[AS, 9H, 8D, 6S, QH, AC, 4C, 9C, QD, KD, 6H, 3D, 3C, 5H, 2C, 6C, ...
[AC, 2C, 3C, 4C, 5C, 6C, 7C, 8C, 9C, 10C, JC, QC, KC, AD, 2D, 3D, ...

Anonymous Classes

The point of Comparator is provide a single method
You can actually do this on the fly, rather than write a separate class

In main, could have done this:

  Comparator<PlayingCard> byValue = new Comparator<PlayingCard>() {
    public int compare(PlayingCard left, PlayingCard right) {
      return left.getValue() - right.getValue();
    }
  };
  Collections.sort(deck, byValue);
  System.out.println(deck);

Here, byValue contains an instance of an anonymous class

Bringing it together: Sort a map by value

Suppose we have our woodchuck wordCounts map. How to print sorted by decreasing value?
Might consider TreeMap with Comparator... but that Comparator has to sort based on keys.

So, given a normal Map...

  Comparator<Map.Entry<String, Integer>> byDecrCount =
      new Comparator<Map.Entry<String, Integer>>() {
          public int compare(Map.Entry<String, Integer> left,
                             Map.Entry<String, Integer> right) {
              return right.getValue() - left.getValue();
          }
      };

  List<Map.Entry<String, Integer>> entries =
      new ArrayList<Map.Entry<String, Integer>>(wordCounts.entrySet());

  Collections.sort(entries, byDecrCount);

  System.out.println(entries);  //could use a for loop for better formatting...

[chuck=5, wood=4, a=4, woodchuck=4, could=3, would=2, if=2, 
 how=1, he=1, the=1, .=1, much=1, ?=1, all=1]

Could expand compare method to sort alphabetically within same count
All the generics can be tedious to write

Summary

Sets - maybe not used much on their own, but still handy to know
Maps - quite useful, especially if you start nesting
- For example, each value could be an entire List...
Comparator - Valuable if you ever want to write a quick custom sort-order for some list
Anonymous classes - common shortcut for short implementations of single-method interfaces.

15a: Sets, Maps, and Comparable

ICS211, Fall 2012
Dr. Zach

Status check

Set

Set Uses

Set Implementations

Set Variations

Map

Map Methods

Map Implementations

Map Uses: Counting instances

A sample input file

Map Uses: Printing with toString()

Map Uses: Querying

Map Uses: Iterating over contents

Map Uses: Iterating over contents with Entry set

Map Uses: Views

Another view example

Comparator

PlayingCard

PlayingCard Comparator

PlayingCard Comparator Use

Anonymous Classes

Bringing it together: Sort a map by value

Summary

For next time...

15a: Sets, Maps, and Comparable

ICS211, Fall 2012Dr. Zach

Status check

Set

Set Uses

Set Implementations

Set Variations

Map

Map Methods

Map Implementations

Map Uses: Counting instances

A sample input file

Map Uses: Printing with toString()

Map Uses: Querying

Map Uses: Iterating over contents

Map Uses: Iterating over contents with Entry set

Map Uses: Views

Another view example

Comparator

PlayingCard

PlayingCard Comparator

PlayingCard Comparator Use

Anonymous Classes

Bringing it together: Sort a map by value

Summary

For next time...

ICS211, Fall 2012
Dr. Zach