Class Ordering<T>

java.lang.Object
cloud.opencode.base.collections.Ordering<T>
Type Parameters:
T - the type to compare | 要比较的类型
All Implemented Interfaces:
Serializable, Comparator<T>
public abstract class Ordering<T> extends Object implements Comparator<T>, Serializable
Ordering - Fluent Comparator Builder Ordering - 流式比较器构建器

A fluent API for building complex comparators with method chaining. Provides natural ordering, null handling, reverse, compound, and transform operations.

用于通过方法链构建复杂比较器的流式 API。提供自然排序、空值处理、反转、复合和转换操作。

Features | 主要功能:

  • Natural ordering - 自然排序
  • Null handling (nullsFirst, nullsLast) - 空值处理
  • Reverse ordering - 反转排序
  • Compound ordering - 复合排序
  • Transform-based ordering - 基于转换的排序
  • Min/max operations - 最小/最大操作

Usage Examples | 使用示例:

// Natural ordering - 自然排序
Ordering<String> natural = Ordering.natural();

// Reverse ordering - 反转排序
Ordering<String> reversed = Ordering.natural().reverse();

// Null-safe ordering - 空值安全排序
Ordering<String> nullsFirst = Ordering.natural().nullsFirst();

// Compound ordering - 复合排序
Ordering<Person> byAge = Ordering.natural().onResultOf(Person::getAge);
Ordering<Person> byName = Ordering.natural().onResultOf(Person::getName);
Ordering<Person> compound = byAge.compound(byName);

// Sort collection - 排序集合
List<String> sorted = Ordering.natural().sortedCopy(strings);

// Min/max - 最小/最大
String min = Ordering.natural().min(strings);
String max = Ordering.natural().max(strings);

Performance | 性能特性:

  • compare: O(1) to O(k) where k is compound depth - compare: O(1) 到 O(k)，k 是复合深度
  • sortedCopy: O(n log n) - sortedCopy: O(n log n)
  • min/max: O(n) - min/max: O(n)

Security | 安全性:

  • Thread-safe: Yes (immutable) - 线程安全: 是（不可变）
  • Null-safe: Configurable - 空值安全: 可配置
Since:
JDK 25, opencode-base-collections V1.0.0
Author:
Leon Soo www.LeonSoo.com
See Also:

  • Constructor Details

    • Ordering

      public Ordering()

  • Method Details

    • natural

      public static <C extends Comparable<? super C>> Ordering<C> natural()
      Return natural ordering for Comparable types. 返回 Comparable 类型的自然排序。
      Type Parameters:
      C - the Comparable type | Comparable 类型
      Returns:
      natural ordering | 自然排序

    • from

      public static <T> Ordering<T> from(Comparator<T> comparator)
      Return ordering based on a Comparator. 返回基于 Comparator 的排序。
      Type Parameters:
      T - the type | 类型
      Parameters:
      comparator - the comparator | 比较器
      Returns:
      ordering | 排序

    • explicit

      @SafeVarargs public static <T> Ordering<T> explicit(T... valuesInOrder)
      Return explicit ordering based on provided order of elements. 返回基于提供的元素顺序的显式排序。
      Type Parameters:
      T - the type | 类型
      Parameters:
      valuesInOrder - values in desired order | 期望顺序的值
      Returns:
      explicit ordering | 显式排序

    • explicit

      public static <T> Ordering<T> explicit(List<T> valuesInOrder)
      Return explicit ordering based on provided order of elements. 返回基于提供的元素顺序的显式排序。
      Type Parameters:
      T - the type | 类型
      Parameters:
      valuesInOrder - values in desired order | 期望顺序的值
      Returns:
      explicit ordering | 显式排序

    • allEqual

      public static <T> Ordering<T> allEqual()
      Return ordering that considers all values equal. 返回将所有值视为相等的排序。
      Type Parameters:
      T - the type | 类型
      Returns:
      all-equal ordering | 全相等排序

    • arbitrary

      public static Ordering<Object> arbitrary()
      Return arbitrary but consistent ordering based on identity hash code. 返回基于身份哈希码的任意但一致的排序。
      Returns:
      arbitrary ordering | 任意排序

    • usingToString

      public static Ordering<Object> usingToString()
      Return ordering that compares using toString(). 返回使用 toString() 比较的排序。
      Returns:
      toString ordering | toString 排序

    • reverse

      public Ordering<T> reverse()
      Return reverse ordering. 返回反转排序。
      Returns:
      reversed ordering | 反转排序

    • nullsFirst

      public Ordering<T> nullsFirst()
      Return ordering that places nulls first. 返回将空值放在前面的排序。
      Returns:
      nulls-first ordering | 空值优先排序

    • nullsLast

      public Ordering<T> nullsLast()
      Return ordering that places nulls last. 返回将空值放在后面的排序。
      Returns:
      nulls-last ordering | 空值最后排序

    • compound

      public Ordering<T> compound(Comparator<? super T> secondary)
      Return compound ordering. 返回复合排序。
      Parameters:
      secondary - secondary ordering | 次要排序
      Returns:
      compound ordering | 复合排序

    • onResultOf

      public <F> Ordering<F> onResultOf(Function<F, ? extends T> function)
      Return ordering based on a function result. 返回基于函数结果的排序。
      Type Parameters:
      F - the type to order | 要排序的类型
      Parameters:
      function - the function | 函数
      Returns:
      transformed ordering | 转换排序

    • sortedCopy

      public List<T> sortedCopy(Iterable<T> elements)
      Return a sorted copy of the elements. 返回元素的排序副本。
      Parameters:
      elements - elements to sort | 要排序的元素
      Returns:
      sorted list | 排序列表

    • immutableSortedCopy

      public ImmutableList<T> immutableSortedCopy(Iterable<T> elements)
      Return an immutable sorted copy of the elements. 返回元素的不可变排序副本。
      Parameters:
      elements - elements to sort | 要排序的元素
      Returns:
      immutable sorted list | 不可变排序列表

    • isOrdered

      public boolean isOrdered(Iterable<? extends T> iterable)
      Check if elements are in sorted order. 检查元素是否有序。
      Parameters:
      iterable - elements to check | 要检查的元素
      Returns:
      true if ordered | 如果有序则返回 true

    • isStrictlyOrdered

      public boolean isStrictlyOrdered(Iterable<? extends T> iterable)
      Check if elements are in strict sorted order. 检查元素是否严格有序。
      Parameters:
      iterable - elements to check | 要检查的元素
      Returns:
      true if strictly ordered | 如果严格有序则返回 true

    • min

      public T min(Iterator<T> iterator)
      Return the minimum element from iterator. 从迭代器返回最小元素。
      Parameters:
      iterator - elements | 元素
      Returns:
      minimum element | 最小元素
      Throws:
      NoSuchElementException - if empty | 如果为空

    • min

      public T min(Iterable<T> iterable)
      Return the minimum element. 返回最小元素。
      Parameters:
      iterable - elements | 元素
      Returns:
      minimum element | 最小元素
      Throws:
      NoSuchElementException - if empty | 如果为空

    • min

      public T min(T a, T b)
      Return the minimum of two values. 返回两个值中的最小值。
      Parameters:
      a - first value | 第一个值
      b - second value | 第二个值
      Returns:
      minimum value | 最小值

    • min

      @SafeVarargs public final T min(T a, T b, T c, T... rest)
      Return the minimum of multiple values. 返回多个值中的最小值。
      Parameters:
      a - first value | 第一个值
      b - second value | 第二个值
      c - third value | 第三个值
      rest - remaining values | 其余值
      Returns:
      minimum value | 最小值

    • max

      public T max(Iterator<T> iterator)
      Return the maximum element from iterator. 从迭代器返回最大元素。
      Parameters:
      iterator - elements | 元素
      Returns:
      maximum element | 最大元素
      Throws:
      NoSuchElementException - if empty | 如果为空

    • max

      public T max(Iterable<T> iterable)
      Return the maximum element. 返回最大元素。
      Parameters:
      iterable - elements | 元素
      Returns:
      maximum element | 最大元素
      Throws:
      NoSuchElementException - if empty | 如果为空

    • max

      public T max(T a, T b)
      Return the maximum of two values. 返回两个值中的最大值。
      Parameters:
      a - first value | 第一个值
      b - second value | 第二个值
      Returns:
      maximum value | 最大值

    • max

      @SafeVarargs public final T max(T a, T b, T c, T... rest)
      Return the maximum of multiple values. 返回多个值中的最大值。
      Parameters:
      a - first value | 第一个值
      b - second value | 第二个值
      c - third value | 第三个值
      rest - remaining values | 其余值
      Returns:
      maximum value | 最大值

    • leastOf

      public List<T> leastOf(Iterator<T> iterator, int k)
      Return the least k elements from iterator. 从迭代器返回最小的 k 个元素。
      Parameters:
      iterator - elements | 元素
      k - number of elements | 元素数量
      Returns:
      least k elements | 最小的 k 个元素

    • leastOf

      public List<T> leastOf(Iterable<T> iterable, int k)
      Return the least k elements. 返回最小的 k 个元素。
      Parameters:
      iterable - elements | 元素
      k - number of elements | 元素数量
      Returns:
      least k elements | 最小的 k 个元素

    • greatestOf

      public List<T> greatestOf(Iterator<T> iterator, int k)
      Return the greatest k elements from iterator. 从迭代器返回最大的 k 个元素。
      Parameters:
      iterator - elements | 元素
      k - number of elements | 元素数量
      Returns:
      greatest k elements | 最大的 k 个元素

    • greatestOf

      public List<T> greatestOf(Iterable<T> iterable, int k)
      Return the greatest k elements. 返回最大的 k 个元素。
      Parameters:
      iterable - elements | 元素
      k - number of elements | 元素数量
      Returns:
      greatest k elements | 最大的 k 个元素

    • binarySearch

      public int binarySearch(List<? extends T> sortedList, T key)
      Perform binary search on a sorted list. 在排序列表上执行二分查找。
      Parameters:
      sortedList - the sorted list | 排序列表
      key - the key to search | 要搜索的键
      Returns:
      index of the key, or -(insertion point + 1) | 键的索引，或 -(插入点 + 1)