# Interface Comparator<T>

All Known Implementing Classes:
  `CaseInsensitiveOrder`

public interface Comparator<T>
A `Comparator` is used to compare two objects to determine their ordering with respect to each other. On a given `Collection`, a `Comparator` can be used to obtain a sorted `Collection` which is totally ordered. For a `Comparator` to be consistent with equals, its {code #compare(Object, Object)} method has to return zero for each pair of elements (a,b) where a.equals(b) holds true. It is recommended that a `Comparator` implements `Serializable`.

Since:
  1.2

- ## Method Summary

  Modifier and Type
  Method
  Description
  `int`
  `compare(T object1, T object2)`
  Compares the two specified objects to determine their relative ordering.
  `boolean`
  `equals(Object object)`
  Compares this `Comparator` with the specified `Object` and indicates whether they are equal.

- ## Method Details

  - ### compare

    int compare(T object1, T object2)
    Compares the two specified objects to determine their relative ordering. The ordering implied by the return value of this method for all possible pairs of `(object1, object2)` should form an equivalence relation. This means that
    - `compare(a,a)` returns zero for all `a`
    - the sign of `compare(a,b)` must be the opposite of the sign of `compare(b,a)` for all pairs of (a,b)
    - From `compare(a,b) > 0` and `compare(b,c) > 0` it must follow `compare(a,c) > 0` for all possible combinations of `(a,b,c)`
    Parameters:
      `object1` - an `Object`.
      `object2` - a second `Object` to compare with `object1`.
    Returns:
      an integer invalid input: '<' 0 if `object1` is less than `object2`, 0 if they are equal, and > 0 if `object1` is greater than `object2`.
    Throws:
      `ClassCastException` - if objects are not of the correct type.

  - ### equals

    boolean equals(Object object)
    Compares this `Comparator` with the specified `Object` and indicates whether they are equal. In order to be equal, `object` must represent the same object as this instance using a class-specific comparison.

    A `Comparator` never needs to override this method, but may choose so for performance reasons.

    Overrides:
      `equals` in class `Object`
    Parameters:
      `object` - the `Object` to compare with this comparator.
    Returns:
      boolean `true` if specified `Object` is the same as this `Object`, and `false` otherwise.
    See Also:
      - `Object.hashCode()`
      - `Object.equals(Object)`