CompoundComparator (Spring Framework 3.2.1.RELEASE API)
Date: 2013-01-24

org.springframework.util.comparator

## Class CompoundComparator<T>

- java.lang.Object
- - org.springframework.util.comparator.CompoundComparator<T>

- All Implemented Interfaces:
    Serializable, Comparator<T>

      public class CompoundComparator<T>
      extends Object
      implements Comparator<T>, Serializable

  A comparator that chains a sequence of one or more more Comparators.

  A compound comparator calls each Comparator in sequence until a single Comparator returns a non-zero result, or the comparators are exhausted and zero is returned.

  This facilitates in-memory sorting similar to multi-column sorting in SQL. The order of any single Comparator in the list can also be reversed.

  Since:
    1.2.2
  Author:
    Keith Donald, Juergen Hoeller
  See Also:
    Serialized Form

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `CompoundComparator()` Construct a CompoundComparator with initially no Comparators.
    `CompoundComparator(Comparator... comparators)` Construct a CompoundComparator from the Comparators in the provided array.

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `addComparator(Comparator<T> comparator)` Add a Comparator to the end of the chain.
    `void` | `addComparator(Comparator<T> comparator, boolean ascending)` Add a Comparator to the end of the chain using the provided sort order.
    `int` | `compare(T o1, T o2)`
    `boolean` | `equals(Object obj)`
    `int` | `getComparatorCount()` Returns the number of aggregated comparators.
    `int` | `hashCode()`
    `void` | `invertOrder()` Invert the sort order of each sort definition contained by this compound comparator.
    `void` | `invertOrder(int index)` Invert the sort order of the sort definition at the specified index.
    `void` | `setAscendingOrder(int index)` Change the sort order at the given index to ascending.
    `void` | `setComparator(int index, Comparator<T> comparator)` Replace the Comparator at the given index.
    `void` | `setComparator(int index, Comparator<T> comparator, boolean ascending)` Replace the Comparator at the given index using the given sort order.
    `void` | `setDescendingOrder(int index)` Change the sort order at the given index to descending sort.
    `String` | `toString()`

    - ### Methods inherited from class java.lang.Object

      `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

- - ### Constructor Detail

    - #### CompoundComparator

          public CompoundComparator()

      Construct a CompoundComparator with initially no Comparators. Clients must add at least one Comparator before calling the compare method or an IllegalStateException is thrown.

    - #### CompoundComparator

          public CompoundComparator(Comparator... comparators)

      Construct a CompoundComparator from the Comparators in the provided array.

      All Comparators will default to ascending sort order, unless they are InvertibleComparators.

      Parameters:
        `comparators` - the comparators to build into a compound comparator
      See Also:
        `InvertibleComparator`

  - ### Method Detail

    - #### addComparator

          public void addComparator(Comparator<T> comparator)

      Add a Comparator to the end of the chain.

      The Comparator will default to ascending sort order, unless it is a InvertibleComparator.

      Parameters:
        `comparator` - the Comparator to add to the end of the chain
      See Also:
        `InvertibleComparator`

    - #### addComparator

          public void addComparator(Comparator<T> comparator,
                           boolean ascending)

      Add a Comparator to the end of the chain using the provided sort order.
      Parameters:
        `comparator` - the Comparator to add to the end of the chain
        `ascending` - the sort order: ascending (true) or descending (false)

    - #### setComparator

          public void setComparator(int index,
                           Comparator<T> comparator)

      Replace the Comparator at the given index.

      The Comparator will default to ascending sort order, unless it is a InvertibleComparator.

      Parameters:
        `index` - the index of the Comparator to replace
        `comparator` - the Comparator to place at the given index
      See Also:
        `InvertibleComparator`

    - #### setComparator

          public void setComparator(int index,
                           Comparator<T> comparator,
                           boolean ascending)

      Replace the Comparator at the given index using the given sort order.
      Parameters:
        `index` - the index of the Comparator to replace
        `comparator` - the Comparator to place at the given index
        `ascending` - the sort order: ascending (true) or descending (false)

    - #### invertOrder

          public void invertOrder()

      Invert the sort order of each sort definition contained by this compound comparator.

    - #### invertOrder

          public void invertOrder(int index)

      Invert the sort order of the sort definition at the specified index.
      Parameters:
        `index` - the index of the comparator to invert

    - #### setAscendingOrder

          public void setAscendingOrder(int index)

      Change the sort order at the given index to ascending.
      Parameters:
        `index` - the index of the comparator to change

    - #### setDescendingOrder

          public void setDescendingOrder(int index)

      Change the sort order at the given index to descending sort.
      Parameters:
        `index` - the index of the comparator to change

    - #### getComparatorCount

          public int getComparatorCount()

      Returns the number of aggregated comparators.

    - #### compare

          public int compare(T o1,
                    T o2)

      Specified by:
        `compare` in interface `Comparator<T>`

    - #### equals

          public boolean equals(Object obj)

      Specified by:
        `equals` in interface `Comparator<T>`
      Overrides:
        `equals` in class `Object`

    - #### hashCode

          public int hashCode()

      Overrides:
        `hashCode` in class `Object`

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `Object`