Comparator接口方法详解

Comparator接口方法详解

1.静态方法

1.comparing

<T, U extends Comparable<? super U>> Comparator<T> comparing(Function<? super T, ? extends U> keyExtractor)
<T, U> Comparator<T> comparing(Function<? super T, ? extends U> keyExtractor,Comparator<? super U> keyComparator)    
<T> Comparator<T> comparingInt(ToIntFunction<? super T> keyExtractor)   
<T> Comparator<T> comparingDouble(ToDoubleFunction<? super T> keyExtractor)
<T> Comparator<T> comparingLong(ToLongFunction<? super T> keyExtractor) 

比较器构建

 //自然正向排序，接收一个类型的key，返回一个按该key进行比较的比较器
 Comparator<DemoObj> comparing = Comparator.comparing(DemoObj::getAmount);
 Comparator<DemoObj> comparingInt = Comparator.comparingInt(DemoObj::getAmount);
 Comparator<DemoObj> comparingDouble = Comparator.comparingDouble(DemoObj::getAmount);
 Comparator<DemoObj> comparingLong = Comparator.comparingLong(DemoObj::getAmount);

 //接收一个类型的key，第二个参数为自定义排序规则，返回比较器
 Comparator<DemoObj> comparing1 = Comparator.comparing(DemoObj::getAmount, (x, y) -> x.compareTo(y));

使用示例

//自然正向排序，用金额排序返回金额
 List<Integer> collect = list.stream().map(DemoObj::getAmount).sorted().collect(Collectors.toList());
//自然正向排序，用金额排序返回金额，返回DemoObj对象
 List<DemoObj> collect1 = list.stream().sorted(Comparator.comparingInt(DemoObj::getAmount)).collect(Collectors.toList());

2.naturalOrder、reverseOrder

<T extends Comparable<? super T>> Comparator<T> naturalOrder()
<T extends Comparable<? super T>> Comparator<T> reverseOrder()

使用示例

//自然排序。返回的比较器是可序列化的，并且在比较null时抛出NullPointerException
List<Integer> collect2 = list.stream().map(DemoObj::getAmount).sorted(Comparator.naturalOrder()).collect(Collectors.toList());
//逆向排序，跟naturalOrder相反
List<Integer> collect3 = list.stream().map(DemoObj::getAmount).sorted(Comparator.reverseOrder()).collect(Collectors.toList());

3.nullsFirst、nullsLast

<T> Comparator<T> nullsFirst(Comparator<? super T> comparator)
<T> Comparator<T> nullsLast(Comparator<? super T> comparator)

比较器构建

Comparator<DemoObj> nullsFirstComparator = Comparator.nullsFirst(Comparator.comparing(DemoObj::getAmount));
Comparator<DemoObj> nullsLastComparator = Comparator.nullsLast(Comparator.comparing(DemoObj::getAmount));

使用示例

//允许null元素比较，null在前面,非空元素通过指定的比较器比较
 List<DemoObj> list = new ArrayList<>();
 list.add(new DemoObj("222", 22));
 list.add(new DemoObj("111", 11));
 list.add(null);
 Comparator<DemoObj> nullsFirstComparator = Comparator.nullsFirst(Comparator.comparing(DemoObj::getAmount));
 List<DemoObj> collect4 = list.stream().sorted(nullsFirstComparator).collect(Collectors.toList());

//允许null元素比较，null在后面，,非空元素通过指定的比较器比较
 Comparator<DemoObj> nullsLastComparator = Comparator.nullsLast(Comparator.comparing(DemoObj::getAmount));
 List<DemoObj> collect5 = list.stream().sorted(nullsLastComparator).collect(Collectors.toList());

2.默认方法

1.compare、reversed

int compare(T o1, T o2); //比较
Comparator<T> reversed() //逆序

使用示例

Comparator<Integer> comparing2 = Integer::compare;
//比较两个数，大于等于小于分别返回 -1 0 1
int compare = comparing2.compare(2, 3);

// reversed 逆序
Comparator<DemoObj> comparing3 = Comparator.comparing(DemoObj::getAmount).reversed();
List<DemoObj> collect6 = list.stream().sorted(comparing3).collect(Collectors.toList());

2.thenComparing

设置多个排序顺序，相同数据按下一级顺序排序

Comparator<T> thenComparing(Comparator<? super T> other)
<U> Comparator<T> thenComparing( Function<? super T, ? extends U> keyExtractor,Comparator<? super U> keyComparator)
<U extends Comparable<? super U>> Comparator<T> thenComparing(Function<? super T, ? extends U> keyExtractor)
Comparator<T> thenComparingInt(ToIntFunction<? super T> keyExtractor)
Comparator<T> thenComparingLong(ToLongFunction<? super T> keyExtractor)
Comparator<T> thenComparingDouble(ToDoubleFunction<? super T> keyExtractor)

使用示例

 //当comparing4排序的数据一致时，按comparing排序规则排序
 Comparator<DemoObj> comparing = Comparator.comparing(DemoObj::getAmount);
 Comparator<DemoObj> demoObjComparator = Comparator.comparing(DemoObj::getCode).thenComparing(comparing);
 List<DemoObj> collect7 = list.stream().sorted(demoObjComparator).collect(Collectors.toList());

测试示例

public class Test {
    public static void main(String[] args)  {
        List<DemoObj> list = new ArrayList<>();
        list.add(new DemoObj("222", 22));
        list.add(new DemoObj("111", 22));
        list.add(new DemoObj("111", 11));

        //自然正向排序，接收一个类型的key，返回一个按该key进行比较的比较器
        Comparator<DemoObj> comparing = Comparator.comparing(DemoObj::getAmount);
        Comparator<DemoObj> comparingInt = Comparator.comparingInt(DemoObj::getAmount);
        Comparator<DemoObj> comparingDouble = Comparator.comparingDouble(DemoObj::getAmount);
        Comparator<DemoObj> comparingLong = Comparator.comparingLong(DemoObj::getAmount);
        //接收一个类型的key，第二个参数为自定义排序规则，返回比较器
        Comparator<DemoObj> comparing1 = Comparator.comparing(DemoObj::getAmount, (x, y) -> x.compareTo(y));

        //自然正向排序，用金额排序返回金额
        List<Integer> collect = list.stream().map(DemoObj::getAmount).sorted().collect(Collectors.toList());
        //自然正向排序，用金额排序返回金额，返回DemoObj对象
        List<DemoObj> collect1 = list.stream().sorted(Comparator.comparingInt(DemoObj::getAmount)).collect(Collectors.toList());

        //自然排序。返回的比较器是可序列化的，并且在比较null时抛出NullPointerException
        List<Integer> collect2 = list.stream().map(DemoObj::getAmount).sorted(Comparator.naturalOrder()).collect(Collectors.toList());
        //逆向排序，跟naturalOrder相反
        List<Integer> collect3 = list.stream().map(DemoObj::getAmount).sorted(Comparator.reverseOrder()).collect(Collectors.toList());

        //允许null元素比较，null在前面,非空元素通过指定的比较器比较
        //list.add(null);
        Comparator<DemoObj> nullsFirstComparator = Comparator.nullsFirst(Comparator.comparing(DemoObj::getAmount));
        List<DemoObj> collect4 = list.stream().sorted(nullsFirstComparator).collect(Collectors.toList());

        //允许null元素比较，null在后面，,非空元素通过指定的比较器比较
        Comparator<DemoObj> nullsLastComparator = Comparator.nullsLast(Comparator.comparing(DemoObj::getAmount));
        List<DemoObj> collect5 = list.stream().sorted(nullsLastComparator).collect(Collectors.toList());

        Comparator<Integer> comparing2 = Integer::compare;
        //比较两个数，大于等于小于分别返回 -1 0 1
        int compare = comparing2.compare(2, 3);
        
        //逆序排序
        Comparator<DemoObj> comparing3 = Comparator.comparing(DemoObj::getAmount).reversed();
        List<DemoObj> collect6 = list.stream().sorted(comparing3).collect(Collectors.toList());

        //当comparing4排序的数据一致时，按comparing排序规则排序
        Comparator<DemoObj> comparing4 = Comparator.comparing(DemoObj::getCode);
        Comparator<DemoObj> demoObjComparator = comparing4.thenComparing(comparing);
        List<DemoObj> collect7 = list.stream().sorted(demoObjComparator).collect(Collectors.toList());
        System.out.println(collect7);
    }

    static class  DemoObj{
        private String code;
        private Integer amount;

        public DemoObj(String code, Integer amount) {
            this.code = code;
            this.amount = amount;
        }

        public String getCode() {
            return code;
        }

        public void setCode(String code) {
            this.code = code;
        }

        public Integer getAmount() {
            return amount;
        }

        public void setAmount(Integer amount) {
            this.amount = amount;
        }

        @Override
        public String toString() {
            return "DemoObj{" +
                    "code='" + code + '\'' +
                    ", amount=" + amount +
                    '}';
        }
    }
}