| << Chapter < Page | Chapter >> Page > |
Previous modules have discussed the use of the Comparable interface. This module discusses and illustrates the use of the Comparator interface.
The Comparable interface establishes natural ordering. The sorting order established by a Comparator may be different or may be the same as the natural order.
A Comparator can be used to establish a sorting order for objects that don't have a natural ordering .
The use of a Comparator is an alternative to the implementation of the Comparable interface. For example, a TreeSet object instantiated with the benefit of a Comparator object doesn't require the objects in its collection to implement Comparable .
The code in this module is written with no thought given to Generics . As a result, if you copy and compile this code, you will probably get a warning about unchecked or unsafe operations .
While you will ultimately need to understand how to use Generics, that is a very complex topic. An understanding of Generics is beyond the scope of thiscourse. Therefore, for purposes of this course, you can simply ignore those warnings.
Previous modules have discussed the use of the Comparable interface to establish the natural ordering of elements in a sorted set. Although the name of the Comparable interface is similar to the name of the Comparator interface, they are different interfaces. Don't be confused by the similarity of the names.
This module will begin the discussion of an alternative approach to sorting, using the Comparator interface to establish sorting order. The discussion will be continued in future modules.
The sorting order established by a Comparator may be different from the natural ordering . The Comparator interface can also be used to establish sorting order for objects that do not implement the Comparable interface and therefore do not have a natural ordering .
Let's begin with a little quiz to test your prior knowledge of the Collections Framework.
What output is produced by the program shown in Listing 1 ?
| Listing 1 . The program named Comparator02. |
|---|
//File Comparator02.java
//Copyright 2001, R.G.Baldwinimport java.util.*;
import java.io.Serializable;public class Comparator02{
public static void main(String args[]){
new Worker().doIt();}//end main()
}//end class Comparator02class Worker{
public void doIt(){Iterator iter;
Collection ref;ref = new TreeSet(new TheComparator());
Populator.fillIt(ref);iter = ref.iterator();
while(iter.hasNext()){System.out.print(iter.next());
}//end while loopSystem.out.println();
}//end doIt()}// end class Worker
class Populator{public static void fillIt(Collection ref){
ref.add(new MyClass(4));ref.add(new MyClass(4));
ref.add(new MyClass(3));ref.add(new MyClass(2));
ref.add(new MyClass(1));}//end fillIt()
}//end class Populatorclass MyClass{
int data;MyClass(){
data = 0;}//end noarg constructor
MyClass(int data){this.data = data;
}//end parameterized constructorpublic String toString(){
return "" + data;}//end overridden toString()
}//end MyClassclass TheComparator
implements Comparator,Serializable{public int compare(Object o1,Object o2){
if(!(o1 instanceof MyClass))throw new ClassCastException();
if(!(o2 instanceof MyClass))throw new ClassCastException();
if(((MyClass)o1).data<((MyClass)o2).data)
return -1;if(((MyClass)o1).data>((MyClass)o2).data)
return 1;else return 0;
}//end compare()public boolean equals(Object o){
if(!(o instanceof TheComparator))return false;
else return true;}//end overridden equals()
}//end class TheComparator |
Notification Switch
Would you like to follow the 'Object-oriented programming (oop) with java' conversation and receive update notifications?
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|