When comparing two objects, there are two ways to look at the comparison behavior, which creates a notion of ordering between the two objects:

*Each object knows how to compare itself*-- Comparison is considered intrinsic to the object and is part of its behavior.*Comparison is done by an external object*-- A third object is introduced that contains the ability to compare two objects.

These two different outlooks on binary object ordering will be explored below in terms of the two Java interfaces that are used to model them.

**java.lang.Comparable**

**java.lang.Comparable**

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

, defined abstractly as*int compareTo(Object rhs)*

`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 < y`

,`x.compareTo(y) == 0`

means`x == y`

, and`x.compareTo(y) > 0`

means`y < x`

.

Common data types that have a natural ordering among their values, such as `Double`

, `String`

, `Character`

, all implement `Comparable`

.

**Advantages and disadvantages **

- Advantages
- Objects carry their ability to be compared with them and thus can be involved in comparison operations anywhere.
- The comparison operation is invariant and thus consistent in all situations.

- Disadvantages
- Comparison operation cannot be changed to match different situations.

**
****java.util.Comparator**

**java.util.Comparator**

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 __homework 2__ 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

, which has exactly two methods:__Comparator__

, to model the ordering*int compare(Object x, Object y)*`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`yis "less than" x`

, and

, to model equality of*boolean equals(Object x)*`Comparators`

. Unlike the`equals`

method of most objects, equality of`Comparator`

s also requires that their comparison behavior be identical.

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`

.

**Advantages and disadvantages**

- Advantages
- Object ordering can be considered variant and be redefined for different situations.
- Creating composite comparison behavior can be easily acheived by decorating or other composite techniques.

- Disadvantages
- Objects are not intrinsically comparable, requiring the inclusion of an otherwise disconnected entity in the system.

### Exercise 1

Implement a `Comparator`

class that will compare `Integer`

objects.