Scribd
Upload
36 views

22 Comparisons

The document discusses the Comparable and Comparator interfaces in Java and provides examples of implementing each to sort Student objects. Comparable requires overriding the compareTo method, while Comparator requires implementing a separate class with a compare method. The Comparator approach provides more flexibility in how collections can be sorted but requires more code. Examples are given of sorting a TreeSet of Students by score using both Comparable and Comparator.

Uploaded by

api-3805937
Copyright
© Attribution Non-Commercial (BY-NC)
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
36 views

22 Comparisons

The document discusses the Comparable and Comparator interfaces in Java and provides examples of implementing each to sort Student objects. Comparable requires overriding the compareTo method, while Comparator requires implementing a separate class with a compare method. The Comparator approach provides more flexibility in how collections can be sorted but requires more code. Examples are given of sorting a TreeSet of Students by score using both Comparable and Comparator.

Uploaded by

api-3805937
Copyright
© Attribution Non-Commercial (BY-NC)
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 16

Comparable and Comparator

Comparing our own objects


• The Object class provides public boolean
equals(Object obj) and public int hashCode()
methods
– For objects that we define, the inherited equals method
is defined as just ==, and hashCode uses the object’s
address in memory
– We can override these methods
– If we override hashCode, we must override equals
• The Object class does not provide any methods
for “less” or “greater”—however,
– There is a Comparable interface in java.lang
– There is a Comparator interface in java.util
2
Outline of a Student class
import java.util.*;

public class Student implements Comparable {

public Student(String name, int score) {...}

public int compareTo(Object o)


throws ClassCastException {...}

public static void main(String args[]) {...}


}

3
Constructor for Student
• This is the same for both methods—nothing new
here
• public Student(String name, int score) {
this.name = name;
this.score = score;
}
• We will be sorting students according to their
score
• This example will use sets, but that’s irrelevant—
comparisons happen between two objects,
whatever kind of collection they are or are not in
4
The main method, version 1
public static void main(String args[]) {
TreeSet set = new TreeSet();

set.add(new Student("Ann", 87));


set.add(new Student("Bob", 83));
set.add(new Student("Cat", 99));
set.add(new Student("Dan", 25));
set.add(new Student("Eve", 76));

Iterator iter = set.iterator();


while (iter.hasNext()) {
Student s = (Student)iter.next();
System.out.println(s.name + " " + s.score);
}
}
5
Using the TreeSet
• In the main method we have the line
TreeSet set = new TreeSet();
• Later we use an iterator to print out the values in
order, and get the following result:
Dan 25
Eve 76
Bob 83
Ann 87
Cat 99
• How did the iterator know that it should sort
Students by score, rather than, say, by name?

6
Implementing Comparable
• public class Student implements Comparable
• This means it must implement the method
public int compareTo(Object o)
• Notice that the parameter is an Object
• In order to implement this interface, our parameter must also
be an Object, even if that’s not what we want
• public int compareTo(Object o) throws ClassCastException {
if (o instanceof Student)
return score - ((Student)o).score;
else
throw new ClassCastException("Not a Student!");
}
• A ClassCastException should be thrown if we are given a non-
Student parameter
7
An improved method *

• Since casting an arbitrary Object to a Student may


throw a classCastException for us, we don’t need to
throw it explicitly
• public int compareTo(Object o) throws ClassCastException {
return score - ((Student)o).score;
}
• Moreover, since classCastException is a subclass of
RuntimeException, we don’t even need to declare
that we might throw one:
• public int compareTo(Object o) {
return score - ((Student)o).score;
}

8
*Suggested by Randall Sidlinger
Using a separate Comparator
• In the program we just finished, Student implemented
Comparable
– Therefore, it had a compareTo method
– We could sort students only by their score
• Now we will put the comparison method in a separate class
• This is more flexible (you can use a different Comparator to
sort Students by nameor by score), but it’s also clumsier
• This new class will implement Comparator instead of
Comparable
• Comparable requires a definition of compareTo but
Comparator requires a definition of compare
• Comparator also (sort of) requires equals

9
Outline of StudentComparator
import java.util.*;

public class StudentComparator


implements Comparator {

public int compare(Object o1, Object o2) {...}

public boolean equals(Object o1) {...}


}

• Note: When we are using this Comparator, we don’t need


the compareTo method in the Student class

10
The compare method
public int compare(Object o1, Object o2) {
return ((Student)o1).score - ((Student)o2).score;
}

• This differs from compareTo(Object o) in


Comparable in these ways:
– The name is different
– It takes both objects as parameters, not just one
– We have to check the type of both objects
– Both objects have to be cast to Student
– Also note that Comparable is defined in java.lang (which is
always imported automatically), but Comparator is defined in
java.util.

11
The equals method
• This method is not used to compare two Students—
it is used to compare two Comparators
• Even though it’s part of the Comparator interface,
you don’t actually need to override it, since you
inherit equals from Object anyway
• In fact, it’s always safe to ignore it
• The purpose is efficiency—you can replace one
Comparator with an equal but faster one
• My opinion: ignore this method entirely!

12
The main method
• The main method is just like before, except that
instead of

TreeSet set = new TreeSet();

We have

Comparator comp = new StudentComparator();


TreeSet set = new TreeSet(comp);

13
When to use each
• The Comparable interface is simpler and less work
– Say your class implements Comparable
– Provide a public int compareTo(Object o) method
– Use no argument in your TreeSet or TreeMap constructor
– You will use the same comparison method every time
• The Comparator interface is more flexible and more
work
– Create as many different classes that implement Comparator
as you like
– You can sort the TreeSet or TreeMap differently with each
– For example, sort Students by score or by name
14
Sorting differently
• Suppose you have students sorted by score, in a
TreeSet you call studentsByScore
• Now you want to sort them again, this time by name

Comparator myStudentNameComparator =
new MyStudentNameComparator();

TreeSet studentsByName =
new TreeSet(myStudentNameComparator);

studentsByName.addAll(studentsByScore);

15
The End

16

You might also like