com.annimon.stream

Class ComparatorCompat<T>

java.lang.Object

com.annimon.stream.ComparatorCompat<T>

All Implemented Interfaces:

java.util.Comparator<T>

public final class ComparatorCompat<T>
extends java.lang.Object
implements java.util.Comparator<T>

Backported default and static methods from Java 8 Comparator interface.

Since:

1.1.6

Constructor Summary

Constructors

Constructor and Description
ComparatorCompat(java.util.Comparator<? super T> comparator)

Method Summary

Modifier and Type	Method and Description
static <T> ComparatorCompat<T>	chain(java.util.Comparator<T> comparator) Allows to build comparators with method chaining.
java.util.Comparator<T>	comparator() Deprecated. As of release 1.1.7, it is unnecessary to call this method.
int	compare(T o1, T o2)
static <T,U extends java.lang.Comparable<? super U>> ComparatorCompat<T>	comparing(Function<? super T,? extends U> keyExtractor) Returns a comparator that uses a function that extracts a Comparable sort key to be compared.
static <T,U> ComparatorCompat<T>	comparing(Function<? super T,? extends U> keyExtractor, java.util.Comparator<? super U> keyComparator) Returns a comparator that uses a function that extracts a sort key to be compared with the specified comparator.
static <T> ComparatorCompat<T>	comparingDouble(ToDoubleFunction<? super T> keyExtractor) Returns a comparator that uses a function that extracts a double sort key to be compared.
static <T> ComparatorCompat<T>	comparingInt(ToIntFunction<? super T> keyExtractor) Returns a comparator that uses a function that extracts an int sort key to be compared.
static <T> ComparatorCompat<T>	comparingLong(ToLongFunction<? super T> keyExtractor) Returns a comparator that uses a function that extracts a long sort key to be compared.
static <T extends java.lang.Comparable<? super T>> ComparatorCompat<T>	naturalOrder() Returns a comparator with natural order.
static <T> ComparatorCompat<T>	nullsFirst() Returns a comparator that considers null to be less than non-null and all non-null values to be equal.
static <T> ComparatorCompat<T>	nullsFirst(java.util.Comparator<? super T> comparator) Returns a comparator that considers null to be less than non-null.
static <T> ComparatorCompat<T>	nullsLast() Returns a comparator that considers null to be greater than non-null and all non-null values to be equal.
static <T> ComparatorCompat<T>	nullsLast(java.util.Comparator<? super T> comparator) Returns a comparator that considers null to be greater than non-null.
ComparatorCompat<T>	reversed() Reverses the order of comparator.
static <T> java.util.Comparator<T>	reversed(java.util.Comparator<T> comparator) Returns a comparator that reverses the order of the specified comparator.
static <T extends java.lang.Comparable<? super T>> ComparatorCompat<T>	reverseOrder() Returns a comparator with reverse order.
ComparatorCompat<T>	thenComparing(java.util.Comparator<? super T> other) Adds the given comparator to the chain.
static <T> java.util.Comparator<T>	thenComparing(java.util.Comparator<? super T> c1, java.util.Comparator<? super T> c2) Returns a comparator that uses c2 comparator if c1 comparator considers two elements equal.
<U extends java.lang.Comparable<? super U>> ComparatorCompat<T>	thenComparing(Function<? super T,? extends U> keyExtractor) Adds the comparator, that uses a function for extract a Comparable sort key, to the chain.
<U> ComparatorCompat<T>	thenComparing(Function<? super T,? extends U> keyExtractor, java.util.Comparator<? super U> keyComparator) Adds the comparator, that uses a function for extract a sort key, to the chain.
ComparatorCompat<T>	thenComparingDouble(ToDoubleFunction<? super T> keyExtractor) Adds the comparator, that uses a function for extract a double sort key, to the chain.
ComparatorCompat<T>	thenComparingInt(ToIntFunction<? super T> keyExtractor) Adds the comparator, that uses a function for extract an int sort key, to the chain.
ComparatorCompat<T>	thenComparingLong(ToLongFunction<? super T> keyExtractor) Adds the comparator, that uses a function for extract a long sort key, to the chain.

Methods inherited from class java.lang.Object

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

Methods inherited from interface java.util.Comparator

comparing, comparing, comparingDouble, comparingInt, comparingLong, equals, thenComparing, thenComparing, thenComparingDouble, thenComparingInt, thenComparingLong

Constructor Detail

ComparatorCompat

public ComparatorCompat(@NotNull
                        java.util.Comparator<? super T> comparator)

Method Detail

naturalOrder

@NotNull
public static <T extends java.lang.Comparable<? super T>> ComparatorCompat<T> naturalOrder()

Returns a comparator with natural order.

Specified by:

naturalOrder in interface java.util.Comparator<T>

Type Parameters:

T - the type of the objects compared by the comparator

Returns:

a comparator

reverseOrder

@NotNull
public static <T extends java.lang.Comparable<? super T>> ComparatorCompat<T> reverseOrder()

Returns a comparator with reverse order.

Specified by:

reverseOrder in interface java.util.Comparator<T>

Type Parameters:

T - the type of the objects compared by the comparator

Returns:

a comparator

See Also:

Collections.reverseOrder()

reversed

@NotNull
public static <T> java.util.Comparator<T> reversed(@Nullable
                                                            java.util.Comparator<T> comparator)

Returns a comparator that reverses the order of the specified comparator. If the specified comparator is null, this method is equivalent to reverseOrder().

Type Parameters:

T - the type of the objects compared by the comparator

Parameters:

comparator - a comparator to be reversed

Returns:

a comparator

Throws:

java.lang.NullPointerException - if comparator is null

See Also:

Collections.reverseOrder(java.util.Comparator)

thenComparing

@NotNull
public static <T> java.util.Comparator<T> thenComparing(@NotNull
                                                                 java.util.Comparator<? super T> c1,
                                                                 @NotNull
                                                                 java.util.Comparator<? super T> c2)

Returns a comparator that uses c2 comparator if c1 comparator considers two elements equal.

Type Parameters:

T - the type of the objects compared by the comparators

Parameters:

c1 - a first comparator

c2 - a second comparator

Returns:

a comparator

Throws:

java.lang.NullPointerException - if c1 or c2 is null

comparing

@NotNull
public static <T,U> ComparatorCompat<T> comparing(@NotNull
                                                           Function<? super T,? extends U> keyExtractor,
                                                           @NotNull
                                                           java.util.Comparator<? super U> keyComparator)

Returns a comparator that uses a function that extracts a sort key to be compared with the specified comparator.

Type Parameters:

T - the type of the objects compared by the comparator

U - the type of the sort key

Parameters:

keyExtractor - the function that extracts the sort key

keyComparator - the comparator used to compare the sort key

Returns:

a comparator

Throws:

java.lang.NullPointerException - if keyExtractor or keyComparator is null

comparing

@NotNull
public static <T,U extends java.lang.Comparable<? super U>> ComparatorCompat<T> comparing(@NotNull
                                                                                                   Function<? super T,? extends U> keyExtractor)

Returns a comparator that uses a function that extracts a Comparable sort key to be compared.

Type Parameters:

T - the type of the objects compared by the comparator

U - the type of the sort key

Parameters:

keyExtractor - the function that extracts the sort key

Returns:

a comparator

Throws:

java.lang.NullPointerException - if keyExtractor is null

comparingInt

@NotNull
public static <T> ComparatorCompat<T> comparingInt(@NotNull
                                                            ToIntFunction<? super T> keyExtractor)

Returns a comparator that uses a function that extracts an int sort key to be compared.

Type Parameters:

T - the type of the objects compared by the comparator

Parameters:

keyExtractor - the function that extracts the sort key

Returns:

a comparator

Throws:

java.lang.NullPointerException - if keyExtractor is null

comparingLong

@NotNull
public static <T> ComparatorCompat<T> comparingLong(@NotNull
                                                             ToLongFunction<? super T> keyExtractor)

Returns a comparator that uses a function that extracts a long sort key to be compared.

Type Parameters:

T - the type of the objects compared by the comparator

Parameters:

keyExtractor - the function that extracts the sort key

Returns:

a comparator

Throws:

java.lang.NullPointerException - if keyExtractor is null

comparingDouble

@NotNull
public static <T> ComparatorCompat<T> comparingDouble(@NotNull
                                                               ToDoubleFunction<? super T> keyExtractor)

Returns a comparator that uses a function that extracts a double sort key to be compared.

Type Parameters:

T - the type of the objects compared by the comparator

Parameters:

keyExtractor - the function that extracts the sort key

Returns:

a comparator

Throws:

java.lang.NullPointerException - if keyExtractor is null

nullsFirst

@NotNull
public static <T> ComparatorCompat<T> nullsFirst()

Returns a comparator that considers null to be less than non-null and all non-null values to be equal.

Type Parameters:

T - the type of the objects compared by the comparator

Returns:

a comparator

nullsFirst

@NotNull
public static <T> ComparatorCompat<T> nullsFirst(@Nullable
                                                          java.util.Comparator<? super T> comparator)

Returns a comparator that considers null to be less than non-null. If the specified comparator is null, then the returned comparator considers all non-null values to be equal.

Specified by:

nullsFirst in interface java.util.Comparator<T>

Type Parameters:

T - the type of the objects compared by the comparator

Parameters:

comparator - a comparator for comparing non-null values

Returns:

a comparator

nullsLast

@NotNull
public static <T> ComparatorCompat<T> nullsLast()

Returns a comparator that considers null to be greater than non-null and all non-null values to be equal.

Type Parameters:

T - the type of the objects compared by the comparator

Returns:

a comparator

nullsLast

@NotNull
public static <T> ComparatorCompat<T> nullsLast(@Nullable
                                                         java.util.Comparator<? super T> comparator)

Returns a comparator that considers null to be greater than non-null. If the specified comparator is null, then the returned comparator considers all non-null values to be equal.

Specified by:

nullsLast in interface java.util.Comparator<T>

Type Parameters:

T - the type of the objects compared by the comparator

Parameters:

comparator - a comparator for comparing non-null values

Returns:

a comparator

chain

@NotNull
public static <T> ComparatorCompat<T> chain(@NotNull
                                                     java.util.Comparator<T> comparator)

Allows to build comparators with method chaining.

Type Parameters:

T - the type of the objects compared by the comparator

Parameters:

comparator - the comparator to be chained

Returns:

a ComparatorCompat instance

reversed

@NotNull
public ComparatorCompat<T> reversed()

Reverses the order of comparator.

Specified by:

reversed in interface java.util.Comparator<T>

Returns:

the new ComparatorCompat instance

See Also:

reverseOrder()

thenComparing

@NotNull
public ComparatorCompat<T> thenComparing(@NotNull
                                                  java.util.Comparator<? super T> other)

Adds the given comparator to the chain.

Specified by:

thenComparing in interface java.util.Comparator<T>

Parameters:

other - the other comparator to be used when chained comparator compares two objects that are equal

Returns:

the new ComparatorCompat instance

thenComparing

@NotNull
public <U> ComparatorCompat<T> thenComparing(@NotNull
                                                      Function<? super T,? extends U> keyExtractor,
                                                      @NotNull
                                                      java.util.Comparator<? super U> keyComparator)

Adds the comparator, that uses a function for extract a sort key, to the chain.

Type Parameters:

U - the type of the sort key

Parameters:

keyExtractor - the function that extracts the sort key

keyComparator - the comparator used to compare the sort key

Returns:

the new ComparatorCompat instance

thenComparing

@NotNull
public <U extends java.lang.Comparable<? super U>> ComparatorCompat<T> thenComparing(@NotNull
                                                                                              Function<? super T,? extends U> keyExtractor)

Adds the comparator, that uses a function for extract a Comparable sort key, to the chain.

Type Parameters:

U - the type of the sort key

Parameters:

keyExtractor - the function that extracts the sort key

Returns:

the new ComparatorCompat instance

thenComparingInt

@NotNull
public ComparatorCompat<T> thenComparingInt(@NotNull
                                                     ToIntFunction<? super T> keyExtractor)

Adds the comparator, that uses a function for extract an int sort key, to the chain.

Parameters:

keyExtractor - the function that extracts the sort key

Returns:

the new ComparatorCompat instance

thenComparingLong

@NotNull
public ComparatorCompat<T> thenComparingLong(@NotNull
                                                      ToLongFunction<? super T> keyExtractor)

Adds the comparator, that uses a function for extract a long sort key, to the chain.

Parameters:

keyExtractor - the function that extracts the sort key

Returns:

the new ComparatorCompat instance

thenComparingDouble

@NotNull
public ComparatorCompat<T> thenComparingDouble(@NotNull
                                                        ToDoubleFunction<? super T> keyExtractor)

Adds the comparator, that uses a function for extract a double sort key, to the chain.

Parameters:

keyExtractor - the function that extracts the sort key

Returns:

the new ComparatorCompat instance

comparator

@NotNull
public java.util.Comparator<T> comparator()

Deprecated. As of release 1.1.7, it is unnecessary to call this method.

Returns a chained Comparator.

Returns:

a comparator

compare

public int compare(T o1,
                   T o2)

Specified by:

compare in interface java.util.Comparator<T>