Binary search is an example of an algorithm that runs in logarithmic time.
It runs in so fast because every step, the search space is chopped in 
half.  The number of times to divide n by 2 before it is rounded down to 0
is log_2 n.  Think about how you would quickly guess a number between 1 
and 1000 by hearing bigger or smaller.

Binary search provides a fast way of doing indexOf (see the big-Oh notes) 
if the array is sorted.  We'll implement it recursively.

public int bsearch(int[] arr, int val) {
  return bsearch(arr,val,0,arr.length-1);
}

int bsearch(int[] arr, int val, int lo, int hi) {
  if (hi<lo) return -1;
  int mid = (lo+hi)/2;
  if (arr[mid]==val) return mid;
  else if (arr[mid]<val) return bsearch(arr,val,mid+1,hi);
  else return bsearch(arr,val,lo,mid-1);
}

A subtlety (and a long-outstanding bug in a standard implementation) is 
that for large lo and hi, there's integer overflow.  A better 
implementation is mid = lo + (hi-lo)/2.

The binary search code works great for int arrays, but it would be nice
to have it work on more generic arrays.  We can compare any object
that implements Comparable, which requires a compareTo method.
compareTo returns a negative number if this is less than other, 0 if they 
are equal, and a positive number if this is bigger than other.

The binary search code would then look like:

int bsearch(Comparable[] arr, int val, int lo, int hi) {
  if (hi<lo) return -1;
  int mid = (lo+hi)/2;
  int cmp = arr[mid].compareTo(val);
  if (cmp==0) return mid;
  else if (cmp<0) return bsearch(arr,val,mid+1,hi);
  else return bsearch(arr,val,lo,mid-1);
}

Suppose we have a simple class to store dollars and cents.  Let's make 
have .equals (a review) and .compareTo.; for compareTo to be registered, 
the class needs to implement Comparable.

public class Money implements Comparable {
  int dollars;
  int cents;

  public boolean equals(Object other) {
    if (!(other instanceof Money)) return false;
    Money m = (Money)other;
    return (100*dollars+cents == 100*m.dollars+m.cents);
  }

  public int compareTo(Object other) {
    Money m = (Money) other;
    return (100*dollars+cents) - (100*m.dollars+m.cents);     
  }
  
}

Note that compareTo will throw a ClassCastException if other is of the 
wrong type, whereas equals returns false.

Implementing equals lets a class be used with most collections and 
algorithms that operate on arrays/collections.  Implementing compareTo 
lets the class be used with sorted collections and algorithms that sort 
arrays/collections or operate on sorted arrays/collections.