Comparators (Java Platform SE 8 b92)

java.lang.Object
- java.util.Comparators

```
public class Comparators
extends Object
```
This class consists of static utility methods for comparators. Mostly factory method that returns a Comparator.
Unless otherwise noted, passing a null argument to a method in this class will cause a NullPointerException to be thrown.

Since:

1.8

See Also:

Comparator

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static <K,V> Comparator<Map.Entry<K,V>>`	`byKey(Comparator<? super K> cmp)` Gets a comparator compares `Map.Entry` by key using the given `Comparator`.
`static <K,V> Comparator<Map.Entry<K,V>>`	`byValue(Comparator<? super V> cmp)` Gets a comparator compares `Map.Entry` by value using the given `Comparator`.
`static <T,U extends Comparable<? super U>> Comparator<T>`	`comparing(Function<? super T,? extends U> keyExtractor)` Accepts a function that extracts a `Comparable` sort key from a type `T`, and returns a `Comparator<T>` that compares by that sort key.
`static <T> Comparator<T>`	`comparing(ToDoubleFunction<? super T> keyExtractor)` Accepts a function that extracts a `double` value from a type `T`, and returns a `Comparator<T>` that compares by that value.
`static <T> Comparator<T>`	`comparing(ToIntFunction<? super T> keyExtractor)` Accepts a function that extracts an `int` value from a type `T`, and returns a `Comparator<T>` that compares by that value.
`static <T> Comparator<T>`	`comparing(ToLongFunction<? super T> keyExtractor)` Accepts a function that extracts a `long` value from a type `T`, and returns a `Comparator<T>` that compares by that value.
`static <T> Comparator<T>`	`compose(Comparator<? super T> first, Comparator<? super T> second)` Constructs a lexicographic order from two `Comparator`s.
`static <T> BinaryOperator<T>`	`greaterOf(Comparator<? super T> comparator)` Constructs a `BinaryOperator` which returns the greater of two elements according to the specified `Comparator`
`static <T> BinaryOperator<T>`	`lesserOf(Comparator<? super T> comparator)` Constructs a `BinaryOperator` which returns the lesser of two elements according to the specified `Comparator`
`static <T extends Comparable<? super T>> Comparator<T>`	`naturalOrder()` Gets a comparator compares `Comparable` type in natural order.
`static <K extends Comparable<? super K>,V> Comparator<Map.Entry<K,V>>`	`naturalOrderKeys()` Gets a comparator compares `Map.Entry` in natural order on key.
`static <K,V extends Comparable<? super V>> Comparator<Map.Entry<K,V>>`	`naturalOrderValues()` Gets a comparator compares `Map.Entry` in natural order on value.
`static <T extends Comparable<? super T>> Comparator<T>`	`reverseOrder()` Returns a comparator that imposes the reverse of the natural ordering.
`static <T> Comparator<T>`	`reverseOrder(Comparator<T> cmp)` Returns a comparator that imposes the reverse ordering of the specified `Comparator`.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - reverseOrder
```
public static <T extends Comparable<? super T>> Comparator<T> reverseOrder()
```
    Returns a comparator that imposes the reverse of the natural ordering.
    The returned comparator is serializable.
    
    Type Parameters:
    
    T - Comparable type
    
    Returns:
    
    A comparator that imposes the reverse of the natural ordering on a collection of objects that implement the Comparable interface.
    
    See Also:
    
    Comparable
  - reverseOrder
```
public static <T> Comparator<T> reverseOrder(Comparator<T> cmp)
```
    Returns a comparator that imposes the reverse ordering of the specified Comparator.
    The returned comparator is serializable (assuming the specified comparator is also serializable).
    
    Type Parameters:
    
    T - the element type to be compared
    
    Parameters:
    
    cmp - a comparator whose ordering is to be reversed by the returned comparator
    
    Returns:
    
    A comparator that imposes the reverse ordering of the specified comparator.
  - naturalOrder
```
public static <T extends Comparable<? super T>> Comparator<T> naturalOrder()
```
    Gets a comparator compares Comparable type in natural order.
    
    Type Parameters:
    
    T - Comparable type
  - naturalOrderKeys
```
public static <K extends Comparable<? super K>,V> Comparator<Map.Entry<K,V>> naturalOrderKeys()
```
    Gets a comparator compares Map.Entry in natural order on key.
    
    Type Parameters:
    
    K - Comparable key type
    
    V - value type
  - naturalOrderValues
```
public static <K,V extends Comparable<? super V>> Comparator<Map.Entry<K,V>> naturalOrderValues()
```
    Gets a comparator compares Map.Entry in natural order on value.
    
    Type Parameters:
    
    K - key type
    
    V - Comparable value type
  - byKey
```
public static <K,V> Comparator<Map.Entry<K,V>> byKey(Comparator<? super K> cmp)
```
    Gets a comparator compares Map.Entry by key using the given Comparator.
    The returned comparator is serializable assuming the specified comparators are also serializable.
    
    Type Parameters:
    
    K - key type
    
    V - value type
    
    Parameters:
    
    cmp - the key Comparator
  - byValue
```
public static <K,V> Comparator<Map.Entry<K,V>> byValue(Comparator<? super V> cmp)
```
    Gets a comparator compares Map.Entry by value using the given Comparator.
    
    Type Parameters:
    
    K - key type
    
    V - value type
    
    Parameters:
    
    cmp - the value Comparator
  - comparing
```
public static <T,U extends Comparable<? super U>> Comparator<T> comparing(Function<? super T,? extends U> keyExtractor)
```
    Accepts a function that extracts a Comparable sort key from a type T, and returns a Comparator<T> that compares by that sort key. For example, if a class Person has a String-valued getter getLastName, then comparing(Person::getLastName) would return a Comparator<Person> that compares Person objects by their last name.
    
    Type Parameters:
    
    T - the original element type
    
    U - the Comparable type for comparison
    
    Parameters:
    
    keyExtractor - the function used to extract the Comparable sort key
  - comparing
```
public static <T> Comparator<T> comparing(ToIntFunction<? super T> keyExtractor)
```
    Accepts a function that extracts an int value from a type T, and returns a Comparator<T> that compares by that value.
    The returned comparator is serializable assuming the specified function is also serializable.
    
    Type Parameters:
    
    T - the original element type
    
    Parameters:
    
    keyExtractor - the function used to extract the integer value
    
    See Also:
    
    comparing(Function)
  - comparing
```
public static <T> Comparator<T> comparing(ToLongFunction<? super T> keyExtractor)
```
    Accepts a function that extracts a long value from a type T, and returns a Comparator<T> that compares by that value.
    The returned comparator is serializable assuming the specified function is also serializable.
    
    Type Parameters:
    
    T - the original element type
    
    Parameters:
    
    keyExtractor - the function used to extract the long value
    
    See Also:
    
    comparing(Function)
  - comparing
```
public static <T> Comparator<T> comparing(ToDoubleFunction<? super T> keyExtractor)
```
    Accepts a function that extracts a double value from a type T, and returns a Comparator<T> that compares by that value.
    The returned comparator is serializable assuming the specified function is also serializable.
    
    Type Parameters:
    
    T - the original element type
    
    Parameters:
    
    keyExtractor - the function used to extract the double value
    
    See Also:
    
    comparing(Function)
  - compose
```
public static <T> Comparator<T> compose(Comparator<? super T> first,
                                        Comparator<? super T> second)
```
    Constructs a lexicographic order from two Comparators. For example, if you have comparators byLastName and byFirstName, each of type Comparator<Person>, then compose(byLastName, byFirstName) creates a Comparator<Person> which sorts by last name, and for equal last names sorts by first name.
    The returned comparator is serializable assuming the specified comparators are also serializable.
    
    Type Parameters:
    
    T - the element type to be compared
    
    Parameters:
    
    first - the first comparator
    
    second - the secondary comparator used when equals on the first
  - lesserOf
```
public static <T> BinaryOperator<T> lesserOf(Comparator<? super T> comparator)
```
    Constructs a BinaryOperator which returns the lesser of two elements according to the specified Comparator
    
    Type Parameters:
    
    T - the type of the elements to be compared
    
    Parameters:
    
    comparator - A Comparator for comparing the two values
    
    Returns:
    
    a BinaryOperator which returns the lesser of its operands, according to the supplied Comparator
  - greaterOf
```
public static <T> BinaryOperator<T> greaterOf(Comparator<? super T> comparator)
```
    Constructs a BinaryOperator which returns the greater of two elements according to the specified Comparator
    
    Type Parameters:
    
    T - the type of the elements to be compared
    
    Parameters:
    
    comparator - A Comparator for comparing the two values
    
    Returns:
    
    a BinaryOperator which returns the greater of its operands, according to the supplied Comparator

Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2013, Oracle and/or its affiliates. All rights reserved.
DRAFT ea-b92

Class Comparators

Method Summary

Methods inherited from class java.lang.Object

Method Detail

reverseOrder

reverseOrder

naturalOrder

naturalOrderKeys

naturalOrderValues

byKey

byValue

comparing

comparing

comparing

comparing

compose

lesserOf

greaterOf