CS 46B - Lecture 4

Cover page image

Pre-class reading

10.3 - 10.5, Special Topic 14.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);
   }
}

Lecture 4 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);
   }
}

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

Lecture 4 Clicker Question 2

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

None—it would have been simpler to implement Util.smallest(String[] values)
None—it would have been simpler to implement Util.smallest(Measurable[] values)
None—it would have been simpler to implement Util.smallest(Object[] values)
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());
   }
}

Lecture 4 Clicker Question 3

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

Arrays.countryComparatorByName(countries);
Arrays.sort(countries, CountryComparatorByName);
Arrays.sort(countries, new CountryComparatorByName());
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.compare(values[i], smallestSoFar) < 0)
            smallestSoFar = values[i];
      return smallestSoFar;
   }   
}

Inner Class

Class defined inside another class

Can be outside or inside method

class Outer
{
   class Inner { ... }
   void someMethod() 
   {
      Inner fred = new Inner();
      ...
   }
}

class Outer
{
   void someMethod()
   {
      class Inner { ... }
      Inner fred = new Inner();
      ...
   }
}

Useful for small helper classes

Example: Comparator

Want to sort an array of strings by length
Want to use Arrays.sort
But that sorts strings by dictionary order (why?)
Use Comparator instead

Need a class that implements Comparator

public static void main(String[] args)
{
   String[] names = { "Fred", "Wilma", "Barney" };
   class LengthComparator implements Comparator
   {
      public int compare(Object o1, Object o2)
      {
         return ((String) o1).length() - ((String) o2).length();
      }
   }
   Arrays.sort(names, new LengthComparator());
}

Anonymous Classes

Look at

Arrays.sort(names, new LengthComparator());

The red object is anonymous

Could have given it a name

Comparator fred = new LengthComparator();
Arrays.sort(names, fred);

Can make classes anonymous too:

Arrays.sort(names, new Comparator() 
   {
      public int compare(Object o1, Object o2)
      {
         return ((String) o1).length() - ((String) o2).length();
      }
   });

We won't use it yet, but you'll see it a lot in CS151
Or maybe not...see bonus material

Lecture 4 Clicker Question 4

Let's make Item an inner class of ArrayListAddressBook (from the lab):

public class ArrayListAddressBook 
{
   private class Item { String name; String key; String value; }
   ...
}

Which of the following is true?

All methods of the ArrayListAddressBook class can construct and access Item objects
Any code outside the ArrayListAddressBook class refers to the inner class as ArrayListAddressBook.Item
The Item class is poorly designed because the instance variables of Item should have been declared as private
The Item class should have been added to the AddressBook interface instead of the ArrayListAddressBook class

Mock Objects

Problem: How can you test code if you don't have all the pieces yet
Example: Want to write and test user interface for AddressBook

Define a class that only implements the services that you absolutely need right now

public class MockAddressBook implements AddressBook
{
   public void load(String sourceName) {}
   public void save() {}
   public void get(String name, String key) { return "Fred"; }
   public void put(String name, String key, String value) {}
   public void remove(String name, String key) {}
}

Great for team work. You can make progress while someone else writes the real address book

Later, change

AddressBook book = new MockAddressBook()

AddressBook book = new ArrayListAddressBook()

Bonus: Java 8 Lambda Expressions

Using a method such as smallest or sort is too much work
That's why you don't find many such methods in the standard library
Java 8 makes this much easier: Use a lambda expression
Works with interfaces that have a single abstract method
- Such interfaces are called functional interfaces...
- ...because instances are similar to mathematical functions
Lambda expression specifies:
- Parameters
- Code for computing the returned value
Example of a lambda expression: Comparing two strings by length
```
(String s, String t) -> s.length() - t.length()
```
- Name “lambda expression” comes from a mathematical notation that uses the greek letter lambda (λ) instead of the -> symbol

Lambda Expressions 2

In Java, a lambda expression cannot stand alone.

It must be assigned to a variable whose type is a functional interface:

Comparator<String> lengthComparator =
   (String s, String t) -> s.length() - t.length();

Now the following actions occur:
1. A class is defined that implements the functional interface. The single abstract method is defined by the lambda expression.
2. An object of that class is constructed.
3. The variable is assigned a reference to that object.
Can also pass lambda expression to a method:
```
Arrays.sort(words, (String s, String t) -> s.length() - t.length());
```
Then the parameter variable is initialized with the object

Lecture 4 Clicker Question 5

Complete this program to find the word with the fewest vowels. Use a lambda expression.

Paste your lambda expression as a reply to the "clicker" question.

Before Next Class

Read sections 11.1 - 11.3
Review Lab 2
Make sure to do the quiz
Turn in homework 2 final
No class next Monday (labor day)
Homework 3 draft due Tuesday