There are many computing tasks that require performing some sort of comparison between data objects. A few data types are endowed with a "natural" ordering of their values. The integers have a natural ordering "less or equal to", labeled "<=", defined as follows.
n <= m iff m = n + k, for some non-negative integer k (Note: a rigorous mathematical definition of the set of non-negative integers is beyond the scope of this lecture).
The above natural order of the integers is a concrete instance of an abstract concept called an order relation. An order relation on a set S is a boolean function R on S x S that is
reflexive: R(x, x) is true for all x in S,
anti-symmetric: R(x,y) and R(y,x) implies x = y, for all x, y in S, and
transitive: R(x, y) and R(y, z) implies R(x, z), for all x, y, z in S.
To model order relations that are naturally endowed in certain types of data objects, Java provides an interface called Comparable, which has exactly one method called
int compareTo(Object lhs), defined abstractly as
x.compareTo(y) < 0 means x is "less than" y,
x.compareTo(y) == 0 means x is "equal to" y, and
x.compareTo(y) > 0 means y is "less than" x.
For example, the Integer class implements the Comparable interface as follows. If x and y are Integer objects then,
x.compareTo(y) < 0 means x.intValue() < y.intValue(),
x.compareTo(y) == 0 means x.intValue() == y.intValue(), and
x.compareTo(y) > 0 means y.intValue() < x.intValue().
Common data types that have a natural ordering among their values, such as Double, String, Character, all implement Comparable.
Most of the time, the ordering among the data objects is an extrinsic operation imposed on the object by the user of the objects. For example, the Pizza objects in lecture 2 and homework 1 have no concepts of comparing among themselves, however, the user can impose an ordering on them by comparing their price/area ratios or their profits. To model extrinsic ordering relation, Java provides an interface in the java.util package called Comparator, which has exactly two methods:
int compare(Object x, Object y), to model the ordering
compare(x, y) < 0 means x is "less than" y,
compare(x, y) == 0 means x is "equal to" y, and
compare(x, y) > 0 means y is "less than" x, and
boolean equals(Object x) to model equality.
In most applications, when we implement a Comparator interface, we only need to override the compare(...) method and simply inherit the equals(...) method from Object.
Implement Comparator to compare the Integer objects.
Implement Comparator to compare the Pizza deal in lecture 2.
Implement Comparator to compare the Pizza profit in homework 1.
Recall the problem of inserting an Integer object in order into a sorted list of Integers. Instead of writing an algorithm that only works for Integer, we can write an algorithm that will work for any Object that can be compared by some Comparator. The table below contrasts the insert in order algorithm for Integer and the insert in order algorithm that uses a Comparator as a strategy (as in strategy pattern) for comparison. Both are algorithms for LRStruct, the mutable list.
import lrs.*;
public class InsertInOrderLRS implements IAlgo {
public static final InsertInOrderLRS Singleton
= new InsertInOrderLRS();
private InsertInOrderLRS() {
}
/**
* Simply inserts the given parameter n at the front.
* @param host an empty LRStruct.
* @param N an Integer to be inserted in order into host.
* @return LRStruct
*/
public Object emptyCase(LRStruct host, Object N) {
return host.insertFront(N);
}
/**
* Based on the comparison between first and N,
* inserts at the front or recurs!
* @param host a non-empty LRStruct.
* @param N an Integer to be inserted in order into host.
* @return LRStruct
*/
public Object nonEmptyCase(LRStruct host, Object N) {
int n = ((Integer)N).intValue();
int f = ((Integer)host.getFirst()).intValue();
if (n < f) {
return host.insertFront(N);
}
else {
return host.getRest().execute(this, N);
}
}
}
|
import lrs.*;
import java.util.*;
public class InsertInOrder implements IAlgo {
private Comparator _order;
public InsertInOrder(Comparator ord) {
_order = ord;
}
/**
* Simply inserts the given parameter n at the front.
* @param host an empty LRStruct.
* @param N an Object to be inserted in order into host,
* based on the given Comparator.
* @return LRStruct
*/
public Object emptyCase(LRStruct host, Object N) {
return host.insertFront(N);
}
/**
* Based on the comparison between first and N,
* inserts at the front or recurs!
* @param host a non-empty LRStruct.
* @param N an Object to be inserted in order into host,
* based on the given Comparator.
* @return LRStruct
*/
public Object nonEmptyCase(LRStruct host, Object N) {
if (_order.compare(N, host.getFirst()) < 0) {
return host.insertFront(N);
}
else {
return host.getRest().execute(this, N);
}
}
}
|
||
The InsertInOrder algorithm given in the above can be used as part of a strategy for a RAC called priority queue.