Status

• A10 almost due.
• eCafe course eval link added to course site main page (EC)
• Sorry, no exam 3s yet. :(
  • But I will post the grades in Laulima by the end of today!
• Sound check

Common Methods

• Using objects in Java Collections (and elsewhere) relies on a few common methods
  • toString (Object) - already covered
  • equals (Object)
  • hashCode (Object)
  • compareTo (Comparable)
• Often need to write these, but quite easy to mess them up → subtle bugs
• (Although core, this is a bit advanced... but after a year of Java, so are you.)

PlayingCard (from last time)

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;
  }
}

At this point

  PlayingCard fourC = new PlayingCard(4, PlayingCard.Suit.C);
  PlayingCard fourC2 = new PlayingCard(4, PlayingCard.Suit.C);
  PlayingCard jackH = new PlayingCard(11, PlayingCard.Suit.H);

  // overridden toString() (vs orginal in Object)
  System.out.println(fourC);  // 4C  (was: PlayingCard@4d29dcc0)
  System.out.println(fourC2); // 4C  (was: PlayingCard@4c53ccba)
  System.out.println(jackH);  // JH  (was: PlayingCard@11a5ee7c)

  // equals
  System.out.println(fourC.equals(fourC));  // true
  System.out.println(fourC.equals(jackH));  // false
  System.out.println(fourC.equals(fourC2)); // false
  
  // as Set
  List<PlayingCard> hand = Arrays.asList(fourC, fourC2, jackH);
  Set<PlayingCard> set = new HashSet<PlayingCard>(hand);
  System.out.println(set);  // [4C, JH, 4C]

• Equals method (inherited from Object): by default uses ==
  • == tests object identity (compares memory addresses)

Equals method

• public boolean equals(Object o)
• Implement whenever you want instances with same internal values to be equal
• Note the Object parameter
• 5 rules given in docs:
  • reflexive: x.equals(x) == true
  • symmetric: x.equals(y) == y.equals(x)
  • transitive: if (x.equals(y) && y.equals(z)) x.equals(z)
  • consistent: x.equals(y) == x.equals(y) (if x and y do not change in mean time)
  • never equal to null: x.equals(null) == false
• Artificial implementation examples:
  • return true;
  • return false;
  • return o instanceof ThisClass;
• instanceof reminder

PlayingCard equals

  @Override
  public boolean equals(Object obj) {
    if (obj instanceof PlayingCard) {
      PlayingCard pc = (PlayingCard) obj;
      return this.getValue() == pc.getValue() && this.getSuit() == pc.getSuit();
    }
    return false;
  }

• Optional optimitization for intensive equals checks:
  • First check: if (this == obj) return true;
• May also see: this.getClass() == obj.getClass()
  • instead of obj instanceof PlayingCard
  • This is more restrictive: must be of exactly the same class to be equal

Effect of new equals

  PlayingCard fourC = new PlayingCard(4, PlayingCard.Suit.C);
  PlayingCard fourC2 = new PlayingCard(4, PlayingCard.Suit.C);
  PlayingCard jackH = new PlayingCard(11, PlayingCard.Suit.H);

  // equals
  System.out.println(fourC.equals(fourC));  // true
  System.out.println(fourC.equals(jackH));  // false
  System.out.println(fourC.equals(fourC2)); // true
  
  // as set
  List<PlayingCard> hand = Arrays.asList(fourC, fourC2, jackH);
  Set<PlayingCard> set = new HashSet<PlayingCard>(hand);
  System.out.println(set);  // [4C, JH, 4C]  still the same?
  System.out.println(set.contains(new PlayingCard(4, PlayingCard.Suit.C)); //false !?!

Will return to the Set problem in a minute...

More complex equals example

• (Example from: Joshua Bloch's book, Effective Java)
• class Point (x, y) and subclass Pixel (x, y, color)
• want Point and Pixels to be equal if at the same location

    //In Point...
    @Override
    public boolean equals(Object obj) {
      if (obj instanceof Point) {
        Point p = (Point) obj;
        return this.x == p.x && this.y == p.y;
      }
      return false;
    }
  

    //In Pixel...
    @Override
    public boolean equals(Object obj) {
      if (obj instanceof Pixel) {
        Pixel p = (Pixel) obj;
        return this.x == p.x && this.y == p.y && this.color == p.color;
      }
      return false;
    }
  

• point.equals(point) is fine, and pixel.equals(pixel) is fine
• Consider symmetry: point.equals(pixel) == pixel.equals(point)?

Second attempt

  //In Point...
  @Override
  public boolean equals(Object obj) {
    if (obj instanceof Point) {
      Point p = (Point) obj;
      return this.x == p.x && this.y == p.y;
    }
    return false;
  }

  //In Pixel...
  @Override
  public boolean equals(Object obj) {
    if (obj instanceof Point) {
      if (obj instanceof Pixel) {
        Pixel p = (Pixel) obj;
        return this.x == p.x && this.y == p.y && this.color == p.color;
      }else {
        //just a Point, so ignore color
        return super.equals(obj);
      }
    }
    return false;
  }

• point.equals(point) is fine, and pixel.equals(pixel) is fine
• Consider symmetry: point.equals(pixel) == pixel.equals(point)?
• Consider transitivity: (pixel.equals(point) && point.equals(pixel2)) == pixel.equals(pixel2)?

Point and Pixel Conclusion

• Can't (easily) correctly share equals behavior across levels of class hierarchy
  • EITHER: Pixels and Points must never be equal to each other

        //In Point...
        @Override
        public boolean equals(Object obj) {
          if (this.getClass() == obj.getClass()) {  //and similar in Pixel
            Point p = (Point) obj;
            return this.x == p.x && this.y == p.y;
          }
          return false;
        }
       

  • OR: color (or any other added field) can't be part of Pixel equality.

          //In Point...
          @Override
          public final boolean equals(Object obj) {
            if (obj instanceof Point) {  //and similar in Pixel
              Point p = (Point) obj;
              return this.x == p.x && this.y == p.y;
            }
            return false;
          }
       

• See this article for very good discussion of other approaches that get closer

Returning to PlayingCard

• Both 4Cs are equal... but not when in a Set!
• Why not?
• Related: how does HashSet hash every possible object into an integer?
• Current behavior:

  // hashCode
  System.out.printf("%x\n", fourC.hashCode());  // 4d29dcc0
  System.out.printf("%x\n", fourC2.hashCode()); // 4c53ccba
  System.out.printf("%x\n", jackH.hashCode());  // 11a5ee7c

hashCode

• hashCode method
• Requirements:
  • consistent: same hash value as long as object does not change (in an equals-changing way)
  • equal objects must have same hash value
  • Encouraged: unequal objects have unequal hashCodes (as much as possible)
• When you change equals, you still have the default hashCode(): memory address

Writing hashCode

• Should include every field that contributes to .equals test
• Remember that other objects have .hashCode() methods you can use
  • Also: wrapper classes (tho there are better ways to handle primitives) and Arrays.hashCode(...)
• Handy algorithm (again, thanks to Joshua Block's Effective Java)

    start total with non-zero value (arbitrary--say, 17)
    for each field:
      compute an int hash for it (c)
      multiply total by prime and add this field's hash  (total = total * 31 + c)
    return total
  

• Multiplication used to avoid same hash value for anagrams (1, 2, 3 vs 2, 1, 3)
• Initial non-zero value to make sure different result if different number of first few fields are 0

PlayingCard's hashCode

@Override
public int hashCode() {
  int total = 17;
  total = total * 31 + this.value;
  total = total * 31 + this.suit.hashCode();   //or .ordinal() for enums
  return total;
}

• Many good IDEs can generate this method (and .equals) for you.
  • You may or may not agree with their implementation though!

Effect of new hashCode()

  // hashCode
  System.out.printf("%x\n", fourC.hashCode());  // 3312f22a (404d with .ordinal())
  System.out.printf("%x\n", fourC2.hashCode()); // 3312f22a (404d with .ordinal())
  System.out.printf("%x\n", jackH.hashCode());  // 24cc5917 (4128 with .ordinal())
  
  // as set
  List<PlayingCard> hand = Arrays.asList(fourC, fourC2, jackH);
  Set<PlayingCard> set = new HashSet<PlayingCard>(hand);
  System.out.println(set);  // [4C, JH] 
  System.out.println(set.contains(new PlayingCard(4, PlayingCard.Suit.C)); // true

• Hooray: fourC and fourC2 and any other 4C have same hash value

Comparable

• Comparable also has clear rules like equals
  • x.compareTo(y) has opposite sign as y.compareTo(x)
  • transitive (x < y < z, then x < z)
  • if x == y, then both must have the same sign when compared to z.
• Strongly recommended: "A natural ordering that is consistent with equals"
  • Means: (x.compare(y) == 0) == (x.equals(y))
  • If not, should clearly indicate that in docs

Making PlayingCard Comparable

public class PlayingCard implements Comparable<PlayingCard> {

  //...

  /**
   * Natural ordering is by value only (smaller to larger).
   * This is inconsistent with equals.
   */
  @Override
  public int compareTo(PlayingCard pc) {
    return this.value - pc.value;
  }

• BTW: This subtraction trick is great only if you know your ints are small (else overflow)

Potential bugs

  // as a Set
  PlayingCard fourD = new PlayingCard(4, PlayingCard.Suit.D);
  List<PlayingCard> hand = Arrays.asList(fourC, fourD, jackH);
  Set<PlayingCard> set = new HashSet<PlayingCard>(hand);
  System.out.println(set);   // [4C, JH, 4D]
  System.out.println(set.contains(new PlayingCard(4, PlayingCard.Suit.S)));  // false

• TreeSet maintains a BST using compareTo (not equals). (Warns about this in API docs.)

  // as a Set
  PlayingCard fourD = new PlayingCard(4, PlayingCard.Suit.D);
  List<PlayingCard> hand = Arrays.asList(fourC, fourD, jackH);
  Set<PlayingCard> set = new TreeSet<PlayingCard>(hand);
  System.out.println(set);   // [4C, JH] (but no 4D)
  System.out.println(set.contains(new PlayingCard(4, PlayingCard.Suit.S)));  // true

• Supposed to be able to change Collections implementation without any change in behavior
• Wouldn't be a problem if our PlayingCard's "natural ordering was consistent with equals"
• How to fix? Either make equals depend only on value or (better) consider suit in compareTo

Job Interview Question #3

We're going to play a game.
* First person gets to announce a number between 1 and 10.
* Then, starting with second person, each player take turns adding a value 
   b/w 1 and 10 to the running total.  Announces the new total.
* First person to say "fifty" wins the game.

* Is there a strategy that always lets you win this game? If so, what is it?
* What if we change the target from 50 to a different value?  Is your strategy general?
* Does it matter to your strategy whether you are the first player?

* "Stepping stone" values: 39, 28, 17, 6 
* Determined by taking goal value and repeatedly subtracting 11
* Yes, whoever knows this strategy and gets on a "stepping stone" first controls the game.  

Job Interview Question #4

Assume you have a dictionary of valid English words.
Given a word as input, (efficiently) give all the valid anagrams of that word.
Example: nails, snail, slain are anagrams of each other.

This will be your A11...

Job Interview Question #5

You own 25 horses but no watch, clock, or way of measuring time.
You want to know which of your horses is the fastest.
You have a track wide enough to run only 5 horses at a time in a race.
What is the fewest number of races you'd need to run to find the fastest horse?

What if you want to find the top two fastest horses? (min # of races?)

What if you want to find the top three fastest horses? (min # of races?)

This one is fairly artificial. Who would be rich enough to own and feed 25 horses, smart enough to figure this problem out, and yet not be able to find some way to measure time? And it assumes that horses don't get tired or slower after running in multiple races in a row. And, apparently, assumes there are no ties.

Also, I only heard of this one while preparing; I didn't get it in an interview myself. Took me quite a while to figure out, though.

Hint: The last two answers are the same.

For Next Time

• A10 due Friday
• Quiz 13 coming.
• A11 to be posted soon.
• Next time: Immutability; Graphs and other advanced ADTs