Day 3
Hashing, Collections,
and Comparators
Wed. January 25th 2006 Scott Ostler
Hashing
Yesterday
we overrode .equals()
Today
we override .hashCode()
Goal:
understand why we need to, and how to do it
What is a Hash?
An
integer that stands in for an object
Quick
way to check for inequality, construct groupings things (should) have equal hashs
Equal
What is .hashCode()
Well
known method name that returns int
Is
defined in java.lang.Object to return a value mostly unique to that instance classes either inherit it, or override it
All
hashCode Object Contract
An
objects hashcode cannot change until it is no longer equal to what it was equal objects must have an equal hashCode is good if two unequal objects have distinct hashes
Two
It
Hashcode Examples
String scott = "Scotty";
String scott2 = Scotty;
String corey = "Corey";
System.out.println(scott.hashCode());
System.out.println(scott2.hashCode());
System.out.println(corey.hashCode());
=> -1823897190, -1823897190, 65295514
Integer int1 = 123456789;
Integer int2 = 123456789;
System.out.println(int1.hashCode());
System.out.println(int2.hashCode());
=> 123456789, 123456789
A Name Class with equals()
public class Name { public String first; public String last; public Name(String first, String last) {
this.first = first;
this.last = last;
} public String toString() {
return first + " " + last;
}
public boolean equals(Object o) {
return (o instanceof Name && ((Name) o).first.equals(this.first) && ((Name) o).last.equals(this.last)); }}
Do our Names work?
Name kyle = new Name(Kyle, MacLaughlin); Name jack = new Name("Jack", "Nance"); Name jack2 = new Name("Jack", "Nance"); System.out.println(kyle.equals(jack)); System.out.println(jack.equals(jack2)); System.out.println(kyle.hashCode()); System.out.println(jack.hashCode()); System.out.println(jack2.hashCode()); false, true, 6718604, 7122755, 14718739
Objects are equal, hashCodes arent
Who cares about hashCode?
Name
code seems to work
Is
this really a problem?
If
we dont use hashCode(), why bother writing it?
ANSWER: JAVA CARES!
We
have violated the Object contract
We
have embarked upon a path filled with Bad, Strange Things
Bad, Strange Thing #1
Set<String> strings = new HashSet<String>();
Set<Name> names = new HashSet<Name>()
strings.add(jack);
names.add(new Name(Jack, Nance));
System.out.println(strings.contains(jack)); System.out.println(names.contains( new Name(Jack, Nance)); => true, false
Solution? make .hashCode()
Remember our requirements:
hashCode() must obey equality hashCode() must be consistent hashCode() must generate int hashCode() should recognize inequality
Possible Implementation
public class Name {
public int hashCode() {
return first.hashCode() + last.hashCode(); } } Does this work?
Good, Normal Thing #1
Set<Name> names = new HashSet<Name>() names.add(jack); System.out.println(names.contains( new Name(Jack, Nance)); true
Could it be better?
A Better Implementation
public class Name {
public int hashCode() { return first.hashCode() * 37 + last.hashCode(); } } Why is it better? (remember contract)
hashCode Object Contract
An
objects hashcode cannot change until it is no longer equal to what it was equal objects must have an equal hashCode is good if two unequal objects have distinct hashes
Two
It
Ex: Jack Nance will be different from Nance Jack
Before We Switch Topics
Any
questions about hashCode, please ask!
It
will be an important point later today
It
will cause bizarre problems if you dont understand it
What Collections Do
Framework
of Interfaces and Classes to
handle:
Collecting objects
Storing objects Sorting objects Retrieving objects
Provides
common syntax across variety of different Collection implementations
How to use Collections
add
file
import java.util.*; to the top of every java
package lab2; import java.util.*; public class CollectionUser {
List<String> list = new ArrayList<String>();
//rest of class
}
Basic Collection<Foo> Syntax
boolean add(Foo o); boolean contains(Object o);
boolean remove(Foo o); int size();
Example Usage
List<Name> iapjava = new ArrayList<Name>(); iapjava.add(new Name(Laura, Dern); iapjava.add(new Name(Toby, Keeler); System.out.println(iapjava.size()); => 2 iapjava.remove(new Name(Toby, Keeler); System.out.println(iapjava.size()); => 1 List<Name> iapruby = new ArrayList<Name>(); Iapruby.add(new Name(Scott, Ostler)); iapjava.addAll(iapruby); System.out.println(iapjava.size()); => 2
Generic Collections
We
can specify the type of object that a collection will hold List<String> strings
Ex: We
are reasonably sure that strings contains only String objects optional, but very useful
Is
Why Use Generics?
List untyped = new ArrayList();
List<String> typed = new ArrayList<String>();
Object obj = untyped.get(0);
String sillyString = (String) obj;
String smartString = typed.get(0);
Retrieving objects
Given Collection<Foo> coll
Iterator:
Iterator<Foo> it = coll.iterator(); while (it.hasNext) { Foo obj = it.next(); // do something with obj }
For each:
for (Foo obj : coll) { // do something with obj }
Object Removing Caveat
Cant remove objects from a Collection while iterating over it
for (Foo obj : coll)
coll.remove(obj) // ConcurrentModificationException
}
Only the Iterator can remove an object its iterating over
Iterator<Foo> it = coll.iterator(); while (it.hasNext) { Foo obj = it.next();
it.remove(Obj); // NOT coll.remove(Obj);
}
Note that iter.remove is optional, and not all Iterator objects will support it
General Collection Types
List
ArrayList HashSet
TreeSet
HashMap
Set
Map
List Overview
Ordered list of objects, similar to Array
Unlike Array, no set size List order generally equals insert order
List<String> strings = new ArrayList<String>();
strings.add(one);
strings.add(two);
strings.add(three);
// strings = [ one, two, three]
Other Ways
Insert at an index
List<String> strings = new ArrayList<String>(); strings.add(one); strings.add(three); strings.add(1, two); // strings = [ one, two, three]
Retrieve objects with an index:
s.o.print(strings.get(0)) s.o.print(strings.indexOf(one)) // => one // => 0
Set Overview
No set size, no set order No duplicate objects allowed!
Set<Name> names = new HashSet<Name>(); names.add(new Name(Jack, Nance)); names.add(new Name(Jack, Nance)); System.out.println(names.size()); => 1
Set Contract
set element cannot be changed in a way that affects its equality is a danger of object mutability
This
If
you dont obey the contract, prepare for Bad, Strange Things
Bad, Strange Thing #2
Set<Name> names = new HashSet<Name>(); Name jack = new Name(Jack, Nance); names.add(jack); System.out.println(names.size()); System.out.println(names.contains(jack)); => true; jack.last = "Vance"; System.out.println(names.contains(jack)); => false System.out.println(names.size()); => 1
Solutions to the Problem?
None. So dont do it. If at all possible, use immutable set elements
Otherwise, be careful
Map Overview
Mapping That
between a set of Key-Value Pairs
is, for every Key object, there is a Value object a lookup service
Essentially Keys
to be
must be unique, but values dont have
Note: Map is not a Collection
Map doesnt support:
boolean add(Foo obj); boolean contains(Object obj);
Rather, it supports:
boolean put(Foo key, Bar value);
boolean containsKey(Foo key);
boolean containsValue(Bar value);
Sample Map Usage
Map<String, String> dns = new HashMap<String, String>(); dns.put(scotty.mit.edu, 18.227.0.87); System.out.println(dns.get(scotty.mit.edu)); System.out.println(dns.containsKey(scotty.mit.edu)); System.out.println(dns.containsValue(18.227.0.87)); dns.remove(scotty.mit.edu); System.out.println(dns.containsValue(18.227.0.87)); // => 18.227.0.87, true, true, false
Other Useful Methods
keySet() - returns a Set of all the keys values() - returns a Collection of all the values
entrySet() - returns a Set of Key,Value Pairs
Each pair is a Map.Entry object Map.Entry supports getKey, getValue, setValue
Dangers of Key Mutability
key must always be equal to what it was
is a restatement of the Set discussion
This
If
a key chanages, it and its value will be lost
Bad, Strange Thing #3
Name isabella = new Name("Isabella", "Rosellini")
Map<Name, String> directory = new HashMap<Name, String>();
directory.put(isabella, "123-456-7890");
System.out.println(directory.get(isabella));
isabella.first = "Dennis";
System.out.println(directory.get(isabella));
directory.put(new Name("Isabella", "Rosellini"), "555-555-1234")
isabella.first = "Isabella";
System.out.println(directory.get(isabella));
What happens?
Two Answers
Right
Answer:
// => 123-456-7890, null, 555-555-1234
Righter Answer:
Doesnt matter because we shouldnt be doing it Unspecified behavior
How to Fix Mutable Keys?
We
want to be able to use any object to stand in for another mutable objects are dangerous
But
Copy the Key
Name dennis = new Name(Dennis, Hopper); Name copy = new Name(dennis.first, dennis.last); map.put(copy, 555-555-1234);
Now changes to dennis dont mess up map
But the keys themselves can still be changed
For (Name name : map.keySet()) { name.first = u r wrecked; // uh oh
}
Make Immutable Keys
public class Name { public final String first; public final String last; public Name(String first, String last) {
this.first = first;
this.last = last;
} public boolean equals(Object o) { return (o instanceof Name && ((Name) o).first.equals(this.first) && ((Name) o).last.equals(this.last)); }}
Immutable Proxy for Keys
Map<String, String> dir = new HashMap<String, String>();
Name naomi = new Name(Naomi, Watts);
String key = naomi.first + , + naomi.last;
dir.put(key, 888-444-1212);
Strings are immutable, so our Maps will be safe
Freeze Keys
public class Name { private String first; private String last; private boolean frozen = false; public void setFirst(String s) { if (!frozen) first = s; } // do same with setLast public void freeze() { frozen = true; } }
Summary: Mutable Keys
Each
approach has tradeoffs
But where appropriate, choose the simplest, strongest solution If a key cannot ever be changed, there will never be problems Put and Pray only as a lost resort
Collection Wrap-up
Common problems
Sharing obects between Collections Trying to remove an Object during iteration Mutable Keys, Sets
Any questions?
Comparing and Sorting
Used
to decide, between two objects, if one is bigger or they are equal should result in:
(a.compareTo(b))
< 0 if a < b = 0 if a = b > 0 if a > b
Comparison Example
Integer one = 1; System.out.println(one.compareTo(3)); System.out.println(one.compareTo(-50)); String frank = Frank; System.out.println(frank.compareTo(Booth)); System.out.println(frank.compareTo(Hopper)); // => -1 , 1, 4, -2
Sorting a List Alphabetically
List<String> names = new ArrayList<String>();
names.add(Sailor);
names.add(Lula);
names.add(Bobby);
names.add(Santos);
names.add(Dell);
Collections.sort(names);
// names => [ Bobby, Dell, Lula, Sailor,
Santos ]
Comparable Interface
We
can sort Strings because they implement Comparable That is, they have a Natural Ordering.
To make Foo class Comparable, we have to implement:
int compareTo(Foo obj);
A Sortable Name
public class Name implements Comparable<Name> {
public int compareTo(Name o) {
int compare = this.last.compareTo(o.last)
if (compare != 0) return compare; else return this.first.compareTo(o.first); } }
Sorting Names in Action
List<Name> names = new ArrayList<Name>(); names.add(new Name("Nicolas", "Cage")); names.add(new Name("Laura", "Dern")); names.add(new Name("Harry", "Stanton")); names.add(new Name("Diane", "Ladd")); names.add(new Name("William", "Morgan")); names.add(new Name(Dirty, "Glover")); names.add(new Name("Johnny", "Cage")); names.add(new Name("Metal", "Cage")); System.out.println(names); Collections.sort(names); System.out.println(names); // => [Johnny Cage, Metal Cage, Nicolas Cage, Laura Dern, Crispin Glover, Diane Ladd, William Morgan, Harry Stanton]
Comparator Objects
To
create multiple sortings for a given Type, we can define Comparator classes A Comparator takes in two objects, and determines which is bigger For type Foo, a Comparator<Foo> has:
int compare(Foo o1, Foo o2);
A First-Name-First Comparator
public class FirstNameFirst implements Comparator<Name> { public int compare(Name n1, Name n2) { int ret = n1.first.compareTo(n2.first); if (ret != 0) return ret; else return n1.last.compareTo(n2.last); } } This goes in a separate file, FirstNameFirst.java
Does it Work?
List<Name> names = new ArrayList<Name>();
..
Comparator<Name> first = new FirstNameFirst();
Collections.sort(names, first);
System.out.println(names);
// => [Crispin Glover, Diane Ladd, Harry Stanton, Johnny Cage, Laura Dern, Metal Cage, Nicolas Cage, William Morgan]
It works!
Comparison Contract
Once
follow
again, there are rules that we must
Specifically,
be careful when
(compare(e1, e2)==0) != e1.equals(e2)
With
such a sorting, using SortedSet or SortedMap will cause Bad, Strange Things
Another Way of Sorting
Use a TreeSet - automatically kept sorted!
Either the Objects in TreeSet must implement Comparable Or give a Comparator Object when making the TreeSet
SortedSet<Name> names = new TreeSet<Name>(new FirstNameFirst()); names.add(new Name("Laura", "Dern")); names.add(new Name("Harry", "Stanton")); names.add(new Name("Diane", "Ladd")); System.out.println(names); // => [Diane Ladd, Harry Stanton, Laura Dern]
Day 3 Wrap-Up
Ask
questions!
There was more here than anyone could get or remember Think of what you want your code to do, and the best way to express that Read Suns Java Documentation:
http://java.sun.com/j2se/1.5.0/docs/api
No one can keep Java in their head Everytime you code, have this page open
