CS 46B - Lecture 1

Cay S. Horstmann

Pre-class reading

• Sections 9.1 - 9.4
• Did you do the quiz?

The Comparable Interface Type

• Measurable: produces a number for each object
• Sometimes, can compare, but can't come up with an absolute number
• Example: dictionary order of strings

  "Hell" < "Hello" < "Hill"

• Comparable interface

  public interface Comparable 
  {
     int compareTo(Object otherObject)
  }

• Object is willing to compare itself against another object
• a.compareTo(b) returns a negative int if a < b, a positive int if a > b, and zero if they are the same

Implementing the Comparable Interface Type

/**
   A country with a name and area.
*/
public class Country implements Comparable
{
   /**
      Constructs a country.
      @param aName the name of the country
      @param anArea the area of the country
   */
   public Country(String aName, double anArea)
   {
      name = aName;
      area = anArea;
   }

   /**
      Gets the name of the country.
      @return the name
   */
   public String getName()
   {
      return name;
   }

   /**
      Gets the area of the country.
      @return the area
   */
   public double getArea()
   {
      return area;
   }


   /**
      Compares two countries by area.
      @param other the other country
      @return a negative number if this country has a smaller
      area than otherCountry, 0 if the areas are the same,
      a positive number otherwise
   */
   public int compareTo(Object otherObject)
   {
      Country other = (Country) otherObject;
      if (area < other.area) return -1;
      if (area > other.area) return 1;
      return 0;
   }

   private String name;
   private double area;
}

Generic Comparable

• Note the cast in the implementation of compareTo

     public int compareTo(Object otherObject)
     {
        Country other = (Country) otherObject;
        if (area < other.area) return -1;
        if (area > other.area) return 1;
        return 0;
     }

• Can avoid the cast by using type parameter

  public class Country implements Comparable<Country>
  {
     ...
     public int compareTo(Country other)
     {
        if (area < other.area) return -1;
        if (area > other.area) return 1;
        return 0;
     }
  }

Finding the Smallest Comparable

public class Util
{
   public static Comparable smallest(Comparable[] values)
   {
      Comparable smallestSoFar = values[0];
      for (int i = 1; i < values.length; i++)
         if (values[i].compareTo(smallestSoFar) < 0)
            smallestSoFar = values[i];
      return smallestSoFar;
   }   
}

public class SmallestDemo
{
   public static void main(String[] args)
   {
      String[] names = { "Fred", "Wilma", "Barney" };
      Comparable first = Util.smallest(names);
      System.out.println(first);
   }
}

Clicker Question #1

What will this program print?

public class SmallestDemo
{
   public static void main(String[] args)
   {
      String[] names = { "Fred", "Wilma", "Barney" };
      String first = Util.smallest(names);
      System.out.println(first);
   }
}

1. Fred
2. Barney
3. Nothing—the program doesn't compile
4. Nothing—the program compiles but it throws a “bad cast” exception when it runs

Clicker Question #2

What is the advantage of using the Comparable interface in the Util.smallest method?

1. None—it would have been simpler to implement Util.smallest(String[] values)
2. None—it would have been simpler to implement Util.smallest(Measurable[] values)
3. None—it would have been simpler to implement Util.smallest(Object[] values)
4. The method is reusable for arrays containing other objects that implement the Comparable interface, e.g. Country objects

Comparators

• Country implements Comparable
• Can pass array of Country to Util.smallest or Arrays.sort
• But what if I want to sort countries by name?
• Can't very well reimplement Comparable whenever the sort order changes
• Use a separate object to do the comparison
• An object of a class that implements this interface:

  public interface Comparator
  {
     int compare(Object object1, Object object2);
  }

Example: Comparing Countries by Name

import java.util.*;

public class CountryComparatorByName implements Comparator
{
   public int compare(Object object1, Object object2)
   {
      Country country1 = (Country) object1;
      Country country2 = (Country) object2;
      return country1.getName().compareTo(country2.getName());
   }
}

Clicker Question #3

Which of the following sorts an array of countries by name?

1. Arrays.countryComparatorByName(countries);
2. Arrays.sort(countries, CountryComparatorByName);
3. Arrays.sort(countries, new CountryComparatorByName());
4. Arrays.sort(new CountryComparatorByName(countries));

Finding the Smallest, Again

public class Util
{
   public static Object smallest(Object[] values, Comparator comp)
   {
      Object smallestSoFar = values[0];
      for (int i = 1; i < values.length; i++)
         if (comp(values[i], smallestSoFar) < 0)
            smallestSoFar = values[i];
      return smallestSoFar;
   }   
}

Lab

• You will work with a buddy
• Buddy list is in D2L
• No buddy? Raise your hand
• One of you (driver) fusses with the code, the other (scribe) types up answers
• Switch roles each class meeting
• Submit lab work to Desire2Learn