This document discusses the Comparable and Comparator interfaces in Java. Comparable allows an object to compare itself to another object, while Comparator allows two objects to be compared to each other based on arbitrary criteria. The document provides examples of implementing these interfaces to allow collections like lists to be sorted. It also discusses function objects and anonymous classes in Java.

1. Comparable/Comparator Interfaces
 Topics:
 Comparable and Comparator interfaces in JCF
 “Java Collections Framework”
 Function objects
1

2. Back to Java: Comparable / Comparator
 In computing, we often want to order a set of items
 Find the max/best or min/worst
 Sort them in order
 Note how this is different than what is needed for search
(where we just need equals)
 Need a way to compare two items
 Want a flexible way to “compare” using different criteria
 In Java, let’s us use Collection(s) methods to meet our
own special needs. (Powerful!)
2

3. Check out the Collections class
 Class Collections
 utility methods for doing operations on Collections, Lists (that
almost always contain homogenous elements)
 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
3

4. Comparable Interface
 First solution: Can we ask an object how it compares
to a second object?
 Sure: string1.compareTo(string2)
 Programming convention: Return value as follows:
 zero if the same
 negative value if first item strictly less than second
 positive value if first item strictly greater than second
 Java provides a Comparable interface
int compareTo(YourClass o)
 Note the parameter is an object of the same type as the
class in which you’re defining compareTo()
4

5. Hang on: What’s an Interface?
 When defining a class, state that it “implements” an
interface. E.g.
public class Watch implements TimeKeeper {
 What else is the meaning of the interface TimeKeeper?
 A set of methods that any implementing class must
include
 TimeKeeper interface doesn’t define how these methods
are coded
 Watch (the implementing class) is promising to include
those in its definition
5

6. Example
 A TimeKeeper Interface defined with its 2 methods:
getTime() and set Time()
 Now a Watch class is declared to implement
TimeKeeper
 Watch is promising to have these 2 methods as part
of its definition (getTime() and setTime())
 Watch can implement those how ever it wants
 It means Watch, by implementing TimeKeeper, can
handle the TimeKeeper role
6

7. Interface gives an Object another Type
 With this definition:
public class Watch implements TimeKeeper {
 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
 It’s a Watch (defined by the class Watch)
 It’s a TimeKeeper (defined by the interface)
7

8. Interface gives an Object another Type
 Interfaces are legal Java types. Therefore can be
used
 To declare variables
 As a parameter type (passing a variable to a
method)
 As a return type
8

9. Example
 If you have a method that took a TimeKeeper as a
parameter
 A Watch could be used as a parameter to that method,
because a Watch plays the role of a TimeKeeper
 If that method takes a TimeKeeper as a parameter, then
we can pass it a Watch
  You can think of the Watch object as having more than
one type. (Every Watch also fills the role as Time Keeper)
9

10. What are we getting at?
 The method sort can take an ArrayList as an argument (an
ArrayList of something) Of what? It can take an ArrayList of
anything that meets this interface called Comparable
 The parameter has to be an ArrayList of any class that
implements the comparable interface – that means it has
the compareTo() method – which means inside of sort, it
knows it can call get() to get 2 items from the ArrayList and
use the compareTo() method – its guaranteed to have it
because that class implements the Comparable interface
10

11. Writing compareTo for Your Classes
 If you ever want to put your own objects in
Collections, and use sort(), max(), min(),…
1. Make your class implement Comparable
2. Implement the compareTo() method in your class
 How to write compareTo()?
 Think about state-variables that determine natural order
 Compare them and return proper-value
 Note: For number values, you can subtract.
 For object values, call compareTo() on them.
11

12. Let’s Get Practical
 You can sort an ArrayList… BUT the ArrayList has
to have things inside it that implement the
Comparable Interface
 Can we sort an ArrayList of Strings?
 Go to API for class String (Google: “java api string”)
 On “All Implemented Interfaces” – one of them is
comparable!
 Scroll to “Method Summary” – has compareTo()
method!
 So you can definitely sort an ArrayList of Strings
12

13. 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 retVal;
retVal = first.compareTo(item2.first);
if ( retVal != 0 ) return retVal;
retVal = phNum - item2.phNum;
return retVal;
}
13

14. See Example done in class
ECLIPSE EXAMPLE
14

15. Under the Hood for Sorting
 How might a sort() or any other method use this? Imagine:
 Its parameter is of the type List<Comparable>
 ArrayList is a type-of List in Java (more on this later)
 Inside a loop, code might look like this:
Comparable item1 = theList.get(i);
Comparable item2 = 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!
15

16. Flexible Design using Comparators
 Solution #1: Make classes Comparable
 Disadvantage: just one way to compare is possible,
because there’s just one compareTo method per class
 Possible solutions:
 Separate functions: sortByName(), sortByNum(),…
 We can’t predict in advance how you’ll 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

17. 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

18. 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
it’s part of the framework
18

19. Example: Comparator objects
 We want to pass a function-object to a method:
 Collections.sort(someList, function-object-goes-here);
 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!
19

20. Example: Comparator objects
 Java’s 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
20

21. Writing a Comparator Class
 Example like one from MSD text, p. 647
 We have a Dog class with name, breed and gender
 Compare two doggies by breed and then name
public class CmpDogByBreedAndName implements Comparator<Dog> {
public int compare(Dog d1, Dog d2) {
int retVal = d1.getBreed().compareTo(d2.getBreed());
if ( retVal != 0 ) return retVal;
return d1.getName().compareTo( d2.getName() );
}
}
21

22. Use of Comparator methods
 How to use with Collections.sort()
 ArrayList dogList = …;
Collections.sort( dogList, new CmpDogByName() );
Collections.sort( dogList, new CmpDogByBreed() );
 (Do you understand what new does here?)
 Inside sort(), code looks something like this:
sort ( List theList, Comparator cmpObj ) {
// in some loop
Object item1 = list.get(i);
Object item2 = list.get(j);
cmpResult = cmpObj.compare(item1,item2);
22

23. End of Comparable/Comparator
topics
 Keep these techniques in mind as we move
forward
23

24. Java Aside: Anonymous Classes
 There’s a Java technique called anonymous classes
 One of several types of nested class definition
 You’ll very often see it in GUI programming (Swing) and
with threads
 Situation:
 Sometimes Java’s design encourages us to create some
thing that might be used just once
 That thing needs to be wrapped up in a class, say
because we need a function object
24

25. Creating and Using an Anonymous Class
 Example: sort a list of Strings by their length
 Collections.sort ( stringList, new Comparator() {
public int compare( Object o1, Object o2 ) {
return ((String) o1).length() –
((String) o2).length();
}
} ) ;
 We’ve created a new Comparator “on the fly”
 new creates a new instance, but what kind?
 Some object that implements Comparator
 Object not named, and its “true” class not named!
 What must a Comparator have? compare()
 We defined it right here, where it’s used! 25

26. Anonymous Classes: Comments
 Anonymous classes are
unlike other classes
 They have no name
 Typically only implement
methods in their interface or
superclass. No new
methods!
 Since they have no name,
can only define and use
them at one point in your
code!
 Hard to understand at first?
Sure!
 Naming an abstraction is
important for human
understanding!
 Sorting, a Collection,
Comparing
 Advice
 Keep them very short (and
simple)!
 Be ready to understand
them when you see them in
Swing and with threads
26