Package no.digipost

Class DiggCompare

java.lang.Object
no.digipost.DiggCompare
public final class DiggCompare extends Object
Utilities for comparing values.

  • Method Summary

    Modifier and Type
    Method
    Description
    static <T extends Comparable<T>>
    T
    max(T t1, T t2)
    Choose the greater of two Comparable objects.
    static <T> T
    maxBy(Comparator<? super T> comparator, T t1, T t2)
    Choose the greater of two objects by using a Comparator.
    static <T, U extends Comparable<? super U>>
    T
    maxBy(Function<? super T,U> propertyExtractor, T t1, T t2)
    Choose the greater of two objects by comparing a Comparable value resolved from each object.
    static <T extends Comparable<T>>
    T
    min(T t1, T t2)
    Choose the lesser of two Comparable objects.
    static <T> T
    minBy(Comparator<? super T> propertyComparator, T t1, T t2)
    Choose the lesser of two objects by using a given Comparator.
    static <T, U extends Comparable<? super U>>
    T
    minBy(Function<? super T,U> propertyExtractor, T t1, T t2)
    Choose the lesser of two objects by comparing a Comparable value resolved from each object.
    static <T> Comparator<T>
    prioritize(List<T> elementsOrderedByPriority)
    Create a comparator which will use a given list of already prioritized elements to determine the order of given elements.
    static <T> Comparator<T>
    prioritize(T... elementsOrderedByPriority)
    Create a comparator which will use a given list of already prioritized elements to determine the order of given elements.
    static <T> Comparator<T>
    prioritizeIf(Predicate<? super T>... predicatesOrderedByPriority)
    Create a comparator which will use the given predicates in prioritized order to determine the order of any given elements.
    static <T> Comparator<T>
    prioritizeIf(List<? extends Predicate<? super T>> predicatesOrderedByPriority)
    Create a comparator which will use a given list of predicates in prioritized order to determine the order of given elements.

    Methods inherited from class java.lang.Object

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

  • Method Details

    • min

      public static <T extends Comparable<T>> T min(T t1, T t2)
      Choose the lesser of two Comparable objects. In the case where the objects are considered equal by Comparable.compareTo(Object), the first argument is returned.
      Returns:
      the least of the two given objects.

    • max

      public static <T extends Comparable<T>> T max(T t1, T t2)
      Choose the greater of two Comparable objects. In the case where the objects are considered equal by Comparable.compareTo(Object), the first argument is returned.
      Returns:
      the greatest of the two given objects.

    • minBy

      public static <T> T minBy(Comparator<? super T> propertyComparator, T t1, T t2)
      Choose the lesser of two objects by using a given Comparator. In the case where the objects are considered equal by Comparable.compareTo(Object), the first argument is returned.

      This is the static method equivalent of applying the resulting function from BinaryOperator.minBy(Comparator) with the given comparator as argument.

      Returns:
      the least of the two given objects.

    • minBy

      public static <T, U extends Comparable<? super U>> T minBy(Function<? super T,U> propertyExtractor, T t1, T t2)
      Choose the lesser of two objects by comparing a Comparable value resolved from each object. In the case where the objects are considered equal by Comparable.compareTo(Object), the first argument is returned.

      This is the static method equivalent of applying the resulting function from BinaryOperator.minBy(Comparator) with comparing(propertyExtractor) as argument.

      Returns:
      the least of the two given objects.

    • maxBy

      public static <T> T maxBy(Comparator<? super T> comparator, T t1, T t2)
      Choose the greater of two objects by using a Comparator. In the case where the objects are considered equal by Comparable.compareTo(Object), the first argument is returned.

      This is the static method equivalent of applying the resulting function from BinaryOperator.maxBy(Comparator) with the given comparator as argument.

      Returns:
      the least of the two given objects.

    • maxBy

      public static <T, U extends Comparable<? super U>> T maxBy(Function<? super T,U> propertyExtractor, T t1, T t2)
      Choose the greater of two objects by comparing a Comparable value resolved from each object. In the case where the objects are considered equal by Comparable.compareTo(Object), the first argument is returned.

      This is the static method equivalent of applying the resulting function from BinaryOperator.maxBy(Comparator) with comparing(propertyExtractor) as argument.

      Returns:
      the least of the two given objects.

    • prioritize

      @SafeVarargs public static <T> Comparator<T> prioritize(T... elementsOrderedByPriority)
      Create a comparator which will use a given list of already prioritized elements to determine the order of given elements. Two elements present in the prioritized list are compared according to their position in the list. An element not present in the elements is always considered as less prioritized than a present element. Two elements not present are considered equal.
      Parameters:
      elementsOrderedByPriority - The elements which order is used to determine the order of elements given to the comparator.
      Returns:
      the comparator
      See Also:

    • prioritize

      public static <T> Comparator<T> prioritize(List<T> elementsOrderedByPriority)
      Create a comparator which will use a given list of already prioritized elements to determine the order of given elements. Two elements present in the prioritized list are compared according to their position in the list. An element not present in the elements is always considered as less prioritized than a present element. Two elements not present are considered equal.
      Parameters:
      elementsOrderedByPriority - The elements which order is used to determine the order of elements given to the comparator.
      Returns:
      the comparator

    • prioritizeIf

      public static <T> Comparator<T> prioritizeIf(List<? extends Predicate<? super T>> predicatesOrderedByPriority)
      Create a comparator which will use a given list of predicates in prioritized order to determine the order of given elements. The indexes of the first predicates which pass two compared elements will determine the comparison result. An element not passing any of the predicates is always considered as less prioritized than a passing element. Two elements not passing any predicate are considered equal.
      Parameters:
      predicatesOrderedByPriority - The predicates which order is used to determine the order of elements given to the comparator.
      Returns:
      the comparator

    • prioritizeIf

      @SafeVarargs public static <T> Comparator<T> prioritizeIf(Predicate<? super T>... predicatesOrderedByPriority)
      Create a comparator which will use the given predicates in prioritized order to determine the order of any given elements. The indexes of the first predicates which pass two compared elements will determine the comparison result. An element not passing any of the predicates is always considered as less prioritized than a passing element. Two elements not passing any predicate are considered equal.
      Parameters:
      predicatesOrderedByPriority - The predicates which order is used to determine the order of elements given to the comparator.
      Returns:
      the comparator