CS 46B - Lecture 14

Cover page image

Pre-class reading

Sections 15.3-15.4
That's in the PDF of the content area, not the printed book

Sets

Unordered collection
Optimized for fast access
Two implementations: hash set and tree set
Hash set: Groups elements with same characteristic
Tree set: Arranges elements by sort order

Constructing Sets

Choose between hash set and tree set
Use tree set if you want to visit in sorted order
Elements need to be comparable, or supply comparator
Otherwise use hash set

Store reference in variable of type Set

Set<String> names = new HashSet<>();
Set<String> names = new TreeSet<>();
Set<String> names = new TreeSet<>(myComparator);

Working with Sets

`Set<String> names;`	Use the interface type for variable declarations
`names = new HashSet<>();`	Use a `TreeSet` if you need to visit the elements in sorted order.
`names.add("Romeo");`	Now `names.size()` is 1
`names.add("Fred");`	Now `names.size()` is 2
`names.add("Romeo");`	`names.size()` is still 2. You can’t add duplicates.
`if (names.contains("Fred"))`	The `contains` method checks whether a value is contained in the set. In this case, the method returns `true`.
`System.out.println(names);`	Prints the set in the format `[Fred, Romeo]`. The elements need not be shown in the order in which they were inserted.
`for (String name : names) {...}`	Use this loop to visit all elements of a set. (You can also use an iterator.)
`names.remove("Romeo");`	Now `names.size()` is 1
`names.remove("Juliet");`	It is not an error to remove an element that is not present. The method call has no effect.

Maps

Associates keys and values
Example: Name -> Color object is a Map<String, Color>
HashMap and TreeMap implementations
TreeMap visits the keys in sorted order

Working with maps

`Map<String, Integer> scores;`	Keys are strings, values are Integer wrappers. Use the interface type for variable declarations.
`scores = new TreeMap<>();`	Use a `HashMap` if you don’t need to visit the keys in sorted order.
`scores.put("Harry", 90); scores.put("Sally", 95);`	Adds keys and values to the map.
`scores.put("Sally", 100);`	Modifies the value of an existing key.
`int n = scores.get("Sally"); Integer n2 = scores.get("Diana");`	Gets the value associated with a key, or null if the key is not present. `n` is 100, `n2` is null.
`System.out.println(scores);`	Prints scores.toString(), a string of the form `{Harry=90, Sally=100}`
`for (String key : scores.keySet()) { Integer value = scores.get(key); . . . }`	Iterates through all map keys and values.
`scores.remove("Sally");`	Removes the key and value.

Lecture 14 Clicker Question 1

The keys of a map form what kind of collection?

A set
A stack
A list
None of the above

Lecture 14 Clicker Question 2

The values of a map form what kind of collection?

A set
A stack
A list
None of the above

Lecture 14 Clicker Question 3

Suppose you want to implement a table of contents that shows the pages on which each particular word occurs. What is a good data structure for this purpose?

TreeMap<Integer, TreeSet<String>>
TreeMap<String, TreeSet<Integer>>
TreeSet<TreeMap<String, Integer>>
TreeSet<TreeMap<Integer, String>>

Hash Functions

Object class has a hashCode method
Computes an integer for each object
Override in your own class to be compatible with equals
Hash code should depend on object contents
Hash code should “spread around” objects into different numbers
It's ok to have a few “collisions”—objects with the same hash code

Example: Hash code for String

final int HASH_MULTIPLIER = 31;
int h = 0;
for (int i = 0; i < s.length(); i++)
   h = HASH_MULTIPLIER * h + s.charAt(i);

eat	100184 = 31 * (31 * 'e' + 'a') + 't'
tea	114704
Juliet	–2065036585
Ugh	84982
VII	84982

Implementing Hash Functions

Form hash code of each instance variable that is compared in equals
Combine these hash codes

public class Country
{
   public int hashCode()
   {
      int h1 = name.hashCode();
      int h2 = new Double(area).hashCode();
      final int HASH_MULTIPLIER = 31;
      int h = HASH_MULTIPLIER * h1 + h2;
      return h;
   }
}