org.dromara.hutool.core.comparator

Class CompareUtil

java.lang.Object

org.dromara.hutool.core.comparator.CompareUtil

public class CompareUtil
extends Object

比较工具类

Author:

looly

Constructor Summary

Constructors

Constructor and Description
CompareUtil()

Method Summary

Modifier and Type	Method and 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> int	compare(T o1, T o2, boolean isNullGreater) 自然比较两个对象的大小，比较规则如下： 1、如果实现Comparable调用compareTo比较 2、o1.equals(o2)返回0 3、比较hashCode值 4、比较toString值
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接口） 一般而言，如果c1 < c2，返回数小于0，c1==c2返回0，c1 > c2 大于0
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(CompareUtil.natural()) Comparator.nullsFirst(CompareUtil.natural())
static <E extends Comparable<? super E>> Comparator<E>	naturalReverse() 获取反序排序器，即默认自然排序的反序排序器 如需对null友好操作如下 Comparator.nullsLast(CompareUtil.naturalReverse()) Comparator.nullsFirst(CompareUtil.naturalReverse())
static <E extends Comparable<? super E>> Comparator<E>	reverse(Comparator<E> comparator) 获取反序排序器，即默认排序器 如需对null友好操作如下 Comparator.nullsLast(CompareUtil.reverse()) Comparator.nullsFirst(CompareUtil.reverse())

Methods inherited from class java.lang.Object

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

Constructor Detail

CompareUtil

public CompareUtil()

Method Detail

compare

public static int compare(char x,
                          char y)

比较两个值的大小

Parameters:

x - 第一个值

y - 第二个值

Returns:

x==y返回0，x<y返回小于0的数，x>y返回大于0的数

Since:

3.0.1

See Also:

Character.compare(char, char)

compare

public static int compare(double x,
                          double y)

比较两个值的大小

Parameters:

x - 第一个值

y - 第二个值

Returns:

x==y返回0，x<y返回小于0的数，x>y返回大于0的数

Since:

3.0.1

See Also:

Double.compare(double, double)

compare

public static int compare(int x,
                          int y)

比较两个值的大小

Parameters:

x - 第一个值

y - 第二个值

Returns:

x==y返回0，x<y返回小于0的数，x>y返回大于0的数

Since:

3.0.1

See Also:

Integer.compare(int, int)

compare

public static int compare(long x,
                          long y)

比较两个值的大小

Parameters:

x - 第一个值

y - 第二个值

Returns:

x==y返回0，x<y返回小于0的数，x>y返回大于0的数

Since:

3.0.1

See Also:

Long.compare(long, long)

compare

public static int compare(short x,
                          short y)

比较两个值的大小

Parameters:

x - 第一个值

y - 第二个值

Returns:

x==y返回0，x<y返回小于0的数，x>y返回大于0的数

Since:

3.0.1

See Also:

Short.compare(short, short)

compare

public static int compare(byte x,
                          byte y)

比较两个值的大小

Parameters:

x - 第一个值

y - 第二个值

Returns:

x==y返回0，x<y返回-1，x>y返回1

Since:

3.0.1

See Also:

Byte.compare(byte, byte)

natural

public static <E extends Comparable<? super E>> Comparator<E> natural()

获取自然排序器，即默认排序器

• 如需对null友好操作如下
• Comparator.nullsLast(CompareUtil.natural())
• Comparator.nullsFirst(CompareUtil.natural())

Type Parameters:

E - 排序节点类型

Returns:

默认排序器

Since:

5.7.21

naturalReverse

public static <E extends Comparable<? super E>> Comparator<E> naturalReverse()

获取反序排序器，即默认自然排序的反序排序器

• 如需对null友好操作如下
• Comparator.nullsLast(CompareUtil.naturalReverse())
• Comparator.nullsFirst(CompareUtil.naturalReverse())

Type Parameters:

E - 排序节点类型

Returns:

默认排序器

Since:

6.0.0

reverse

public static <E extends Comparable<? super E>> Comparator<E> reverse(Comparator<E> comparator)

获取反序排序器，即默认排序器

• 如需对null友好操作如下
• Comparator.nullsLast(CompareUtil.reverse())
• Comparator.nullsFirst(CompareUtil.reverse())

Type Parameters:

E - 排序节点类型

Parameters:

comparator - 排序器

Returns:

默认排序器

Since:

6.0.0

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:

比较结果

Since:

4.6.9

See Also:

Comparator.compare(Object, Object)

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:

Comparator.compare(Object, Object)

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:

Comparator.compare(Object, Object)

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:

中文比较器

Since:

5.4.3

comparingPinyin

public static <T> Comparator<T> comparingPinyin(Function<T,String> keyExtractor,
                                                boolean reverse)

中文（拼音）比较器

Type Parameters:

T - 对象类型

Parameters:

keyExtractor - 从对象中提取中文(参与比较的内容)

reverse - 是否反序

Returns:

中文比较器

Since:

5.4.3

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:

索引比较器

Since:

5.8.0

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:

索引比较器

Since:

6.0.0

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:

索引比较器

Since:

5.8.0

min

public static <T extends Comparable<? super T>> T min(T t1,
                                                      T t2)

取两个值中的最小值，大小相同返回第一个值

Type Parameters:

T - 值类型

Parameters:

t1 - 第一个值

t2 - 第二个值

Returns:

最小值

Since:

6.0.0

max

public static <T extends Comparable<? super T>> T max(T t1,
                                                      T t2)

取两个值中的最大值，大小相同返回第一个值

Type Parameters:

T - 值类型

Parameters:

t1 - 第一个值

t2 - 第二个值

Returns:

最大值

Since:

6.0.0

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:

Comparator.compare(Object, Object)

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:

Comparator.compare(Object, Object)

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:

Comparator.compare(Object, Object)

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:

Comparator.compare(Object, Object)

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:

Comparator.compare(Object, Object)

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:

Comparator.compare(Object, Object)