@Beta @GwtCompatible public final class Comparators extends Object
Comparator
instances. For many other helpful
comparator utilities, see either Comparator
itself (for Java 8 or later), or
com.google.common.collect.Ordering
(otherwise).
Ordering
In light of the significant enhancements to Comparator
in Java 8, the overwhelming
majority of usages of Ordering
can be written using only builtin JDK APIs. Because of
this, and because it's awkward to have to convert comparators into Ordering
instances,
Ordering
and its methods are planned for deletion. This class is intended to
"fill the gap" and provide those features of Ordering
not already provided by the JDK.
Modifier and Type  Method and Description 

static <T> Comparator<Optional<T>> 
emptiesFirst(Comparator<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<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> 
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.

public static <T,S extends T> Comparator<Iterable<S>> lexicographical(Comparator<T> comparator)
[] < [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]
).
public static <T> boolean isInOrder(Iterable<? extends T> iterable, Comparator<T> comparator)
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.public static <T> boolean isInStrictOrder(Iterable<? extends T> iterable, Comparator<T> comparator)
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.public static <T> Collector<T,?,List<T>> least(int k, Comparator<? super T> comparator)
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)
(worstcase 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.
IllegalArgumentException
 if k < 0
public static <T> Collector<T,?,List<T>> greatest(int k, Comparator<? super T> comparator)
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)
(worstcase 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.
IllegalArgumentException
 if k < 0
@Beta public static <T> Comparator<Optional<T>> emptiesFirst(Comparator<T> valueComparator)
Optional
values which treats Optional.empty()
as less
than all other values, and orders the rest using valueComparator
on the contained
value.@Beta public static <T> Comparator<Optional<T>> emptiesLast(Comparator<T> valueComparator)
Optional
values which treats Optional.empty()
as greater
than all other values, and orders the rest using valueComparator
on the contained
value.Copyright © 2010–2017. All rights reserved.