com.google.common.collect

Class Comparators

java.lang.Object

com.google.common.collect.Comparators

@GwtCompatible
public final class Comparators
extends Object

Provides static methods for working with Comparator instances. For many other helpful comparator utilities, see either Comparator itself (for Java 8 or later), or com.google.common.collect.Ordering (otherwise).

Relationship to Ordering

In light of the significant enhancements to Comparator in Java 8, the overwhelming majority of usages of Ordering can be written using only built-in JDK APIs. This class is intended to "fill the gap" and provide those features of Ordering not already provided by the JDK.

Since:

21.0

Author:

Louis Wasserman

Method Summary

Modifier and Type	Method and Description
static <T> Comparator<Optional<T>>	emptiesFirst(Comparator<? super T> valueComparator) Returns a comparator of Optional values which treats Optional.empty() as less than all other values, and orders the rest using valueComparator on the contained value.
static <T> Comparator<Optional<T>>	emptiesLast(Comparator<? super T> valueComparator) Returns a comparator of Optional values which treats Optional.empty() as greater than all other values, and orders the rest using valueComparator on the contained value.
static <T> Collector<T,?,List<T>>	greatest(int k, Comparator<? super T> comparator) Returns a Collector that returns the k greatest (relative to the specified Comparator) input elements, in descending order, as an unmodifiable List.
static <T> boolean	isInOrder(Iterable<? extends T> iterable, Comparator<T> comparator) Returns true if each element in iterable after the first is greater than or equal to the element that preceded it, according to the specified comparator.
static <T> boolean	isInStrictOrder(Iterable<? extends T> iterable, Comparator<T> comparator) Returns true if each element in iterable after the first is strictly greater than the element that preceded it, according to the specified comparator.
static <T> Collector<T,?,List<T>>	least(int k, Comparator<? super T> comparator) Returns a Collector that returns the k smallest (relative to the specified Comparator) input elements, in ascending order, as an unmodifiable List.
static <T,S extends T> Comparator<Iterable<S>>	lexicographical(Comparator<T> comparator) Returns a new comparator which sorts iterables by comparing corresponding elements pairwise until a nonzero result is found; imposes "dictionary order." If the end of one iterable is reached, but not the other, the shorter iterable is considered to be less than the longer one.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

lexicographical

@Beta
public static <T,S extends T> Comparator<Iterable<S>> lexicographical(Comparator<T> comparator)

Returns a new comparator which sorts iterables by comparing corresponding elements pairwise until a nonzero result is found; imposes "dictionary order." If the end of one iterable is reached, but not the other, the shorter iterable is considered to be less than the longer one. For example, a lexicographical natural ordering over integers considers [] < [1] < [1, 1] < [1, 2] < [2].

Note that Collections.reverseOrder(lexicographical(comparator)) is not equivalent to lexicographical(Collections.reverseOrder(comparator)) (consider how each would order [1] and [1, 1]).

isInOrder

@Beta
public static <T> boolean isInOrder(Iterable<? extends T> iterable,
                                          Comparator<T> comparator)

Returns true if each element in iterable after the first is greater than or equal to the element that preceded it, according to the specified comparator. Note that this is always true when the iterable has fewer than two elements.

isInStrictOrder

@Beta
public static <T> boolean isInStrictOrder(Iterable<? extends T> iterable,
                                                Comparator<T> comparator)

Returns true if each element in iterable after the first is strictly greater than the element that preceded it, according to the specified comparator. Note that this is always true when the iterable has fewer than two elements.

least

public static <T> Collector<T,?,List<T>> least(int k,
                                               Comparator<? super T> comparator)

Returns a Collector that returns the k smallest (relative to the specified Comparator) input elements, in ascending order, as an unmodifiable List. Ties are broken arbitrarily.

For example:

 Stream.of("foo", "quux", "banana", "elephant")
     .collect(least(2, comparingInt(String::length)))
 // returns {"foo", "quux"}
 

This Collector uses O(k) memory and takes expected time O(n) (worst-case O(n log k)), as opposed to e.g. Stream.sorted(comparator).limit(k), which currently takes O(n log n) time and O(n) space.

Throws:

IllegalArgumentException - if k < 0

Since:

22.0

greatest

public static <T> Collector<T,?,List<T>> greatest(int k,
                                                  Comparator<? super T> comparator)

Returns a Collector that returns the k greatest (relative to the specified Comparator) input elements, in descending order, as an unmodifiable List. Ties are broken arbitrarily.

For example:

 Stream.of("foo", "quux", "banana", "elephant")
     .collect(greatest(2, comparingInt(String::length)))
 // returns {"elephant", "banana"}
 

This Collector uses O(k) memory and takes expected time O(n) (worst-case O(n log k)), as opposed to e.g. Stream.sorted(comparator.reversed()).limit(k), which currently takes O(n log n) time and O(n) space.

Throws:

IllegalArgumentException - if k < 0

Since:

22.0

emptiesFirst

@Beta
public static <T> Comparator<Optional<T>> emptiesFirst(Comparator<? super T> valueComparator)

Returns a comparator of Optional values which treats Optional.empty() as less than all other values, and orders the rest using valueComparator on the contained value.

Since:

22.0

emptiesLast

@Beta
public static <T> Comparator<Optional<T>> emptiesLast(Comparator<? super T> valueComparator)

Returns a comparator of Optional values which treats Optional.empty() as greater than all other values, and orders the rest using valueComparator on the contained value.

Since:

22.0