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