Package org.miaixz.bus.core.xyz

Class CompareKit

java.lang.Object
org.miaixz.bus.core.xyz.CompareKit
public class CompareKit extends Object
比较工具类
Since:
Java 17+
Author:
Kimi Liu

  • Constructor Summary

    Constructors
    Constructor
    Description
    CompareKit()
     

  • Method Summary

    Modifier and Type
    Method
    Description
    static int
    compare(byte x, byte y)
    比较两个值的大小
    static int
    compare(char x, char y)
    比较两个值的大小
    static int
    compare(double x, double y)
    比较两个值的大小
    static int
    compare(int x, int y)
    比较两个值的大小
    static int
    compare(long x, long y)
    比较两个值的大小
    static int
    compare(short x, short y)
    比较两个值的大小
    static <T extends Comparable<? super T>>
    int
    compare(T c1, T c2)
    null安全的对象比较，null对象小于任何对象
    static <T extends Comparable<? super T>>
    int
    compare(T c1, T c2, boolean isNullGreater)
    null安全的对象比较
    static <T> int
    compare(T c1, T c2, Comparator<T> comparator)
    对象比较，比较结果取决于comparator，如果被比较对象为null，传入的comparator对象应处理此情况 如果传入comparator为null，则使用默认规则比较（此时被比较对象必须实现Comparable接口）
    static <T, U> Comparator<T>
    comparingIndexed(Function<? super T,? extends U> keyExtractor, boolean atEndIfMiss, U... objs)
    索引比较器 通过keyExtractor函数，提取对象的某个属性或规则，根据提供的排序数组，完成比较
    static <T, U> Comparator<T>
    comparingIndexed(Function<? super T,? extends U> keyExtractor, Iterable<U> objs)
    索引比较器 通过keyExtractor函数，提取对象的某个属性或规则，根据提供的排序数组，完成比较 objs中缺失的，默认排序在前面(atEndIfMiss=false)
    static <T, U> Comparator<T>
    comparingIndexed(Function<? super T,? extends U> keyExtractor, U[] objs)
    索引比较器 通过keyExtractor函数，提取对象的某个属性或规则，根据提供的排序数组，完成比较 objs中缺失的，默认排序在前面(atEndIfMiss=false)
    static <T> Comparator<T>
    comparingPinyin(Function<T,String> keyExtractor)
    中文比较器
    static <T> Comparator<T>
    comparingPinyin(Function<T,String> keyExtractor, boolean reverse)
    中文（拼音）比较器
    static <T extends Comparable<? super T>>
    boolean
    equals(T c1, T c2)
    null安全的检查两个对象是否相同，通过调用compare(c1, c2) == 0完成
    static <T extends Comparable<? super T>>
    boolean
    ge(T c1, T c2)
    c1是否大于或等于c2，通过调用compare(c1, c2) >= 0完成
    static <T extends Comparable<? super T>>
    boolean
    gt(T c1, T c2)
    c1是否大于c2，通过调用compare(c1, c2) > 0完成
    static <T extends Comparable<? super T>>
    boolean
    isIn(T value, T c1, T c2)
    给定的value是否在c1和c2的范围内 即 min(c1,c2) <= value <= max(c1,c2)
    static <T extends Comparable<? super T>>
    boolean
    isInExclusive(T value, T c1, T c2)
    给定的value是否在c1和c2的范围内，但是不包括边界 即 min(c1,c2) < value < max(c1,c2)
    static <T extends Comparable<? super T>>
    boolean
    le(T c1, T c2)
    c1是否小于或等于c2，通过调用compare(c1, c2) <= 0完成
    static <T extends Comparable<? super T>>
    boolean
    lt(T c1, T c2)
    c1是否大小于c2，通过调用compare(c1, c2) < 0完成
    static <T extends Comparable<? super T>>
    T
    max(T t1, T t2)
    取两个值中的最大值，大小相同返回第一个值
    static <T extends Comparable<? super T>>
    T
    min(T t1, T t2)
    取两个值中的最小值，大小相同返回第一个值
    static <E extends Comparable<? super E>>
    Comparator<E>
    natural()
    获取自然排序器，即默认排序器 如需对null友好操作如下 Comparator.nullsLast(CompareKit.natural()) Comparator.nullsFirst(CompareKit.natural())
    static <E extends Comparable<? super E>>
    Comparator<E>
    naturalReverse()
    获取反序排序器，即默认自然排序的反序排序器 如需对null友好操作如下 Comparator.nullsLast(CompareKit.naturalReverse()) Comparator.nullsFirst(CompareKit.naturalReverse())
    static <E extends Comparable<? super E>>
    Comparator<E>
    reverse(Comparator<E> comparator)
    获取反序排序器，即默认排序器 如需对null友好操作如下 Comparator.nullsLast(CompareKit.reverse()) Comparator.nullsFirst(CompareKit.reverse())

    Methods inherited from class java.lang.Object

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

  • Constructor Details

    • CompareKit

      public CompareKit()

  • Method Details

    • compare

      public static int compare(char x, char y)
      比较两个值的大小
      Parameters:
      x - 第一个值
      y - 第二个值
      Returns:
      x==y返回0，x<y返回小于0的数，x>y返回大于0的数
      See Also:

    • compare

      public static int compare(double x, double y)
      比较两个值的大小
      Parameters:
      x - 第一个值
      y - 第二个值
      Returns:
      x==y返回0，x<y返回小于0的数，x>y返回大于0的数
      See Also:

    • compare

      public static int compare(int x, int y)
      比较两个值的大小
      Parameters:
      x - 第一个值
      y - 第二个值
      Returns:
      x==y返回0，x<y返回小于0的数，x>y返回大于0的数
      See Also:

    • compare

      public static int compare(long x, long y)
      比较两个值的大小
      Parameters:
      x - 第一个值
      y - 第二个值
      Returns:
      x==y返回0，x<y返回小于0的数，x>y返回大于0的数
      See Also:

    • compare

      public static int compare(short x, short y)
      比较两个值的大小
      Parameters:
      x - 第一个值
      y - 第二个值
      Returns:
      x==y返回0，x<y返回小于0的数，x>y返回大于0的数
      See Also:

    • compare

      public static int compare(byte x, byte y)
      比较两个值的大小
      Parameters:
      x - 第一个值
      y - 第二个值
      Returns:
      x==y返回0，x<y返回-1，x>y返回1
      See Also:

    • natural

      public static <E extends Comparable<? super E>> Comparator<E> natural()
      获取自然排序器，即默认排序器
      • 如需对null友好操作如下
      • Comparator.nullsLast(CompareKit.natural())
      • Comparator.nullsFirst(CompareKit.natural())
      Type Parameters:
      E - 排序节点类型
      Returns:
      默认排序器

    • naturalReverse

      public static <E extends Comparable<? super E>> Comparator<E> naturalReverse()
      获取反序排序器，即默认自然排序的反序排序器
      • 如需对null友好操作如下
      • Comparator.nullsLast(CompareKit.naturalReverse())
      • Comparator.nullsFirst(CompareKit.naturalReverse())
      Type Parameters:
      E - 排序节点类型
      Returns:
      默认排序器

    • reverse

      public static <E extends Comparable<? super E>> Comparator<E> reverse(Comparator<E> comparator)
      获取反序排序器，即默认排序器
      • 如需对null友好操作如下
      • Comparator.nullsLast(CompareKit.reverse())
      • Comparator.nullsFirst(CompareKit.reverse())
      Type Parameters:
      E - 排序节点类型
      Parameters:
      comparator - 排序器
      Returns:
      默认排序器

    • compare

      public static <T> int compare(T c1, T c2, Comparator<T> comparator)
      对象比较，比较结果取决于comparator，如果被比较对象为null，传入的comparator对象应处理此情况 如果传入comparator为null，则使用默认规则比较（此时被比较对象必须实现Comparable接口）

      一般而言，如果c1 < c2，返回数小于0，c1==c2返回0，c1 > c2 大于0

      Type Parameters:
      T - 被比较对象类型
      Parameters:
      c1 - 对象1
      c2 - 对象2
      comparator - 比较器
      Returns:
      比较结果
      See Also:

    • compare

      public static <T extends Comparable<? super T>> int compare(T c1, T c2)
      null安全的对象比较，null对象小于任何对象
      Type Parameters:
      T - 被比较对象类型
      Parameters:
      c1 - 对象1，可以为null
      c2 - 对象2，可以为null
      Returns:
      比较结果，如果c1 < c2，返回数小于0，c1==c2返回0，c1 > c2 大于0
      See Also:

    • compare

      public static <T extends Comparable<? super T>> int compare(T c1, T c2, boolean isNullGreater)
      null安全的对象比较
      Type Parameters:
      T - 被比较对象类型（必须实现Comparable接口）
      Parameters:
      c1 - 对象1，可以为null
      c2 - 对象2，可以为null
      isNullGreater - 当被比较对象为null时是否排在后面，true表示null大于任何对象，false反之
      Returns:
      比较结果，如果c1 < c2，返回数小于0，c1==c2返回0，c1 > c2 大于0
      See Also:

    • compare

      public static <T> int compare(T o1, T o2, boolean isNullGreater)
      自然比较两个对象的大小，比较规则如下： 
       1、如果实现Comparable调用compareTo比较
 2、o1.equals(o2)返回0
 3、比较hashCode值
 4、比较toString值
      Type Parameters:
      T - 被比较对象类型
      Parameters:
      o1 - 对象1
      o2 - 对象2
      isNullGreater - null值是否做为最大值
      Returns:
      比较结果，如果o1 < o2，返回数小于0，o1==o2返回0，o1 > o2 大于0

    • comparingPinyin

      public static <T> Comparator<T> comparingPinyin(Function<T,String> keyExtractor)
      中文比较器
      Type Parameters:
      T - 对象类型
      Parameters:
      keyExtractor - 从对象中提取中文(参与比较的内容)
      Returns:
      中文比较器

    • comparingPinyin

      public static <T> Comparator<T> comparingPinyin(Function<T,String> keyExtractor, boolean reverse)
      中文（拼音）比较器
      Type Parameters:
      T - 对象类型
      Parameters:
      keyExtractor - 从对象中提取中文(参与比较的内容)
      reverse - 是否反序
      Returns:
      中文比较器

    • comparingIndexed

      public static <T, U> Comparator<T> comparingIndexed(Function<? super T,? extends U> keyExtractor, U[] objs)
      索引比较器 通过keyExtractor函数，提取对象的某个属性或规则，根据提供的排序数组，完成比较 objs中缺失的，默认排序在前面(atEndIfMiss=false)
      Type Parameters:
      T - 对象类型
      U - 数组对象类型
      Parameters:
      keyExtractor - 从对象中提取中文(参与比较的内容)
      objs - 参与排序的数组，数组的元素位置决定了对象的排序先后
      Returns:
      索引比较器

    • comparingIndexed

      public static <T, U> Comparator<T> comparingIndexed(Function<? super T,? extends U> keyExtractor, Iterable<U> objs)
      索引比较器 通过keyExtractor函数，提取对象的某个属性或规则，根据提供的排序数组，完成比较 objs中缺失的，默认排序在前面(atEndIfMiss=false)
      Type Parameters:
      T - 对象类型
      U - 数组对象类型
      Parameters:
      keyExtractor - 从对象中提取中文(参与比较的内容)
      objs - 参与排序的集合对象，数组的元素位置决定了对象的排序先后
      Returns:
      索引比较器

    • comparingIndexed

      public static <T, U> Comparator<T> comparingIndexed(Function<? super T,? extends U> keyExtractor, boolean atEndIfMiss, U... objs)
      索引比较器 通过keyExtractor函数，提取对象的某个属性或规则，根据提供的排序数组，完成比较
      Type Parameters:
      T - 对象类型
      U - 数组对象类型
      Parameters:
      keyExtractor - 从对象中提取排序键的函数(参与比较的内容)
      atEndIfMiss - 如果不在列表中是否排在后边; true:排在后边; false:排在前边
      objs - 参与排序的数组，数组的元素位置决定了对象的排序先后, 示例：int[] objs = new int[]{3, 2, 1, 4, 5,6};
      Returns:
      索引比较器

    • min

      public static <T extends Comparable<? super T>> T min(T t1, T t2)
      取两个值中的最小值，大小相同返回第一个值
      Type Parameters:
      T - 值类型
      Parameters:
      t1 - 第一个值
      t2 - 第二个值
      Returns:
      最小值

    • max

      public static <T extends Comparable<? super T>> T max(T t1, T t2)
      取两个值中的最大值，大小相同返回第一个值
      Type Parameters:
      T - 值类型
      Parameters:
      t1 - 第一个值
      t2 - 第二个值
      Returns:
      最大值

    • equals

      public static <T extends Comparable<? super T>> boolean equals(T c1, T c2)
      null安全的检查两个对象是否相同，通过调用compare(c1, c2) == 0完成
      Type Parameters:
      T - 被比较对象类型
      Parameters:
      c1 - 对象1，可以为null
      c2 - 对象2，可以为null
      Returns:
      是否相等
      See Also:

    • gt

      public static <T extends Comparable<? super T>> boolean gt(T c1, T c2)
      c1是否大于c2，通过调用compare(c1, c2) > 0完成
      Type Parameters:
      T - 被比较对象类型
      Parameters:
      c1 - 对象1，可以为null
      c2 - 对象2，可以为null
      Returns:
      c1是否大于c2
      See Also:

    • ge

      public static <T extends Comparable<? super T>> boolean ge(T c1, T c2)
      c1是否大于或等于c2，通过调用compare(c1, c2) >= 0完成
      Type Parameters:
      T - 被比较对象类型
      Parameters:
      c1 - 对象1，可以为null
      c2 - 对象2，可以为null
      Returns:
      c1是否大于或等于c2
      See Also:

    • lt

      public static <T extends Comparable<? super T>> boolean lt(T c1, T c2)
      c1是否大小于c2，通过调用compare(c1, c2) < 0完成
      Type Parameters:
      T - 被比较对象类型
      Parameters:
      c1 - 对象1，可以为null
      c2 - 对象2，可以为null
      Returns:
      c1是否小于c2
      See Also:

    • le

      public static <T extends Comparable<? super T>> boolean le(T c1, T c2)
      c1是否小于或等于c2，通过调用compare(c1, c2) <= 0完成
      Type Parameters:
      T - 被比较对象类型
      Parameters:
      c1 - 对象1，可以为null
      c2 - 对象2，可以为null
      Returns:
      c1是否小于或等于c2
      See Also:

    • isIn

      public static <T extends Comparable<? super T>> boolean isIn(T value, T c1, T c2)
      给定的value是否在c1和c2的范围内 即 min(c1,c2) <= value <= max(c1,c2)
      Type Parameters:
      T - 被比较对象类型
      Parameters:
      value - 检查的对象，可以为null
      c1 - 对象1，可以为null
      c2 - 对象2，可以为null
      Returns:
      给定的value是否在c1和c2的范围内

    • isInExclusive

      public static <T extends Comparable<? super T>> boolean isInExclusive(T value, T c1, T c2)
      给定的value是否在c1和c2的范围内，但是不包括边界 即 min(c1,c2) < value < max(c1,c2)
      Type Parameters:
      T - 被比较对象类型
      Parameters:
      value - 检查的对象，可以为null
      c1 - 对象1，可以为null
      c2 - 对象2，可以为null
      Returns:
      c1是否小于或等于c2
      See Also: