Comparable and Comparator Interfaces

1
Comparable and Comparator Interfaces

• Ben Rodes

2
Disclaimer
3
Interfaces

• Problem You dont know what an interface is yet!
• Seems problematic
• So what is an interface?
• Its not a class!
• A group of related methods with no bodies (no
  definition, just method signatures)

4
Interfaces

• A class may implement any number of interfaces.
• To implement an interface is a contract.
• The implementer must define the interface
  functions!
• Why do this?
• We can use objects of an interface type, without
  knowing their actual instance type.
• Lets look at an example.

5
Interfaces

• public interface TimeKeeper
• public Time getTime()
• public void setTime(Time)
• .

6
Interfaces

• public class Watch implements TimeKeeper
• //Whatever fields go here
• //Constructor, methods .
• public Time getTime()
• //Define this function
• public void setTime()
• //Define this function

7
Interfaces

• You can think of Watch in these ways
• You can treat a Watch object as a TimeKeeper
• A Watch object can do TimeKeeper things
• A Watch object can be used anywhere a TimeKeeper
  is legal to use
• A Watch object has more than one type
• Its a Watch (defined by the class Watch)
• Its a TimeKeeper (defined by the interface)

8
Interfaces

• Okay but why?
• Hold on, I am getting there!
• Lets pretend you want to write some generic
  function to work on TimeKeepers

9
Interfaces

• public Time getAVGClkDiff(ArrayListltTimeKeepergt
  clocks)
• //Loop over each element in clocks
• //for each element e
• e.getTime() //Get the time, store it, take an
  average
• This may not be the exactly right syntax, but the
  right idea

10
Interfaces

• Okay, dumb example, but
• We dont care what the actual time keepers are
• Because an interface is a contract, we know a
  TimeKeeper has a getTime function, and we can
  treat each element as a TimeKeeper, rather than
  whatever instance it actually is.
• Similar idea to inheritance, but is subtly
  different.
• Interfaces do not show inheritance.
• Relationships are maintained among diverse
  objects.
• More to come later.

11
The Comparable Interface

• Comparable is an interface
• Defined in the Java API
• Contains only one method
• compareTo(SomeObject o2)
• There are functions in the Java API you can use
  to do useful things if your objects implement
  this interface.

12
Check out the Collections class

• Class Collections
• utility methods for doing operations on
  Collections
• Note very similar Arrays class
• See MSD textbook, Section 9.5, pp. 666f
• Methods (static, mostly for Lists)
• search a list for an item binarySearch()
• sort(), max(), min() -- uses compareTo() or
  Comparator object
• reverse(), fill(), shuffle(), copy(),
  replaceAll()
• List list2 Collections.unmodifiableList(list1)
  // p. 668

13
Collections Sort

• Accepts a List of comparable objects.
• How might a sort() or any other method use this?
  Imagine
• Perhaps items stored as a list of Objects
  List theList
• Inside a loop, code might look like this
  Comparable item1 (Comparable) theList.get(i)
  Comparable item2 (Comparable) theList.get(j)
  int cmpResult item1.compareTo(item2)
• Such code will work when the list stores any
  class that implements Comparable!
• But, what happens if list-elements are of
  different classes (still Comparable, but
  different)? compareTo() fails!
• Lets look at an example!

14
Example Writing compareTo()

• Imagine something like an entry in a phonebook
• Order by last name, first name, then number
• int compareTo(PhoneBookEntry item2 ) int
  retVal last.compareTo(item2.last)if ( retVal
  ! 0 ) return retValretVal first.compareTo(ite
  m2.first)if ( retVal ! 0 ) return
  retValretVal phNum - item2.phNumreturn
  retVal

15
Comparable Problems

• Lack of flexibility
• Just one way to compare is possible, because
  theres just one compareTo method per class
• Possible solutions
• Separate functions sortByName(), sortByNum(),
• We cant predict in advance how youll want to
  sort!
• Pass a parameter to indicate control
  sort(theList, byName) or sort(theList,
  byNum)
• Ugh. Same problem as before
• And the internals of sort() will grow to become
  very ugly

16
Function Objects

• We need to somehow pass how to execute
  information as a parameter to sort()
• We pass objects as parameters
• Can we pass a method/operation as an object?
• Many languages support this, but in different
  ways
• C and C pointers to functions
• C delegates
• Java function objects that
• implement a specified interface, and
• the one method in that interface does the needed
  work

17
Function Objects in Java

• Idea encapsulate a function inside a class
• Note not our usual idea of a class
• State? (None.)
• Identity? (Just need one instance.)
• Represents an entity? (Nope! Just a place to
  stash a function so it can be passed as a
  parameter.)
• Warning / caveat!
• This idea is contrary to many OO principles, but
• Useful if done in limited circumstances
• Use it when the libraries make it available
• Not often part of your own class-design
• But use it in libraries when its part of the
  framework

18
Example Comparator objects

• We want to pass a function-object to a method
• Collections.sort(someList, function-object-goes-he
  re)
• But what type should this object be?
• Use an Interface
• Interface name can be used as a type in the
  parameter list
• Interface defines the method name itself!
• Javas Comparator interface int compare(
  Object o1, Object o2)
• Notes not compareTo()! Takes two parameters!
• Define a class for each kind of comparison you
  want. E.g. Classes CmpStudentByGpa,
  CmpStudentByGpaDesc Classes CmpDogByName,
  CmpDogByBreed
• Example?

19
Writing a Comparator Class

• Example on following slides like one from MSD
  text, p. 646-647
• We have a Dog class with name, breed and gender
• But see simpler example in Java on website
• list of Student objects
• sort by name, gpa
• Also sort in descending order too
• Look at testSorting1() in TestDriver class
• Look at compareTo() in Student
• Look at use of comparator classes