集合類lambda值逆序排序(備忘工具)

場景

在使用collection.stream場景時，有時候需要對元素進行執行規則排序，有時候又需要逆序，雖然Comparator提供了排序以及逆序，但是逆序時不僅需要繼續調用reversed()方法，還得是準確類型才能逆.

逆序工具

• 工具類

package com.littlehow.utils;

import java.util.Collections;
import java.util.Comparator;
import java.util.Objects;
import java.util.function.Function;
import java.util.function.ToDoubleFunction;
import java.util.function.ToIntFunction;
import java.util.function.ToLongFunction;

/**
 * lambda表達式排序時便於倒排
 */
public class Comparators {

    /**
     * 根據指定值倒排(int類型)
     * @see Comparator#comparingInt(ToIntFunction) .reversed()
     * @param key
     * @param <T>
     * @return
     */
    public static <T> Comparator<T> reverseIntSort(ToIntFunction<? super T> key) {
        Objects.requireNonNull(key);
        return (v1, v2) -> Integer.compare(key.applyAsInt(v2), key.applyAsInt(v1));
    }

    /**
     * 根據指定值倒排(long類型)
     * @see Comparator#comparingLong(ToLongFunction) .reversed()
     * @param key
     * @param <T>
     * @return
     */
    public static <T> Comparator<T> reverseLongSort(ToLongFunction<? super T> key) {
        Objects.requireNonNull(key);
        return (v1, v2) -> Long.compare(key.applyAsLong(v2), key.applyAsLong(v1));
    }


    /**
     * 根據指定值倒排(double類型)
     * @see Comparator#comparingDouble(ToDoubleFunction) .reversed()
     * @param key
     * @param <T>
     * @return
     */
    public static <T> Comparator<T> reverseDoubleSort(ToDoubleFunction<? super T> key) {
        Objects.requireNonNull(key);
        return (v1, v2) -> Double.compare(key.applyAsDouble(v2), key.applyAsDouble(v1));
    }

    /**
     * 對可排序的類型進行倒排, 兼容reverseIntSort/reverseLongSort/reverseDoubleSort
     * @see Comparator#comparing(Function) .reversed()
     * @param key
     * @param <T>
     * @param <U>
     * @return
     */
    public static <T, U extends Comparable<? super U>> Comparator<T> reverseSort(Function<? super T, ? extends U> key) {
        Objects.requireNonNull(key);
        return (v1, v2) -> key.apply(v2).compareTo(key.apply(v1));
    }

    /**
     * 對自身可排序的進行逆序
     * @see Comparator#reverseOrder()
     * @param <T>
     * @return
     */
    public static <T extends Comparable<? super T>> Comparator<T> reverseSort() {
        return Collections.reverseOrder();
    }
}

• 測試類

import com.littlehow.utils.Comparators;
import lombok.Builder;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

public class ComparatorTest {
    public static void main(String[] args) {
        //對int類型進行排序
        List<A> as = new ArrayList<>();
        as.add(A.builder().v(3).build());
        as.add(A.builder().v(1).build());
        as.add(A.builder().v(4).build());
        as.add(A.builder().v(2).build());
        //對as進行正向排序
        System.out.println(as.stream().sorted(Comparator.comparingInt(P::getV)).collect(Collectors.toList()));
        //原始提供的逆序方式,不能使用父類P::getV()
        System.out.println(as.stream().sorted(Comparator.comparingInt(A::getV).reversed()).collect(Collectors.toList()));
        //對as進行逆向排序
        System.out.println(as.stream().sorted(Comparators.reverseIntSort(P::getV)).collect(Collectors.toList()));
        //原始順序(不變)
        System.out.println(as);

        //對long類型進行排序
        List<B> bs = new ArrayList<>();
        bs.add(B.builder().v(32L).build());
        bs.add(B.builder().v(19L).build());
        bs.add(B.builder().v(44L).build());
        bs.add(B.builder().v(26L).build());

        //對bs進行正向排序
        System.out.println(bs.stream().sorted(Comparator.comparingLong(P::getV)).collect(Collectors.toList()));
        //對bs進行逆向排序
        System.out.println(bs.stream().sorted(Comparators.reverseLongSort(P::getV)).collect(Collectors.toList()));
        //原始順序(不變)
        System.out.println(bs);

        //對double類型進行排序
        List<C> cs = new ArrayList<>();
        cs.add(C.builder().v(1.1).build());
        cs.add(C.builder().v(1.3).build());
        cs.add(C.builder().v(1.5).build());
        cs.add(C.builder().v(1.2).build());

        //對cs進行正向排序
        System.out.println(cs.stream().sorted(Comparator.comparingDouble(P::getV)).collect(Collectors.toList()));
        //對cs進行逆向排序
        System.out.println(cs.stream().sorted(Comparators.reverseDoubleSort(P::getV)).collect(Collectors.toList()));
        //原始順序(不變)
        System.out.println(cs);

        //對可排序的類型進行排序
        List<D> ds = new ArrayList<>();
        ds.add(D.builder().v("2").build());
        ds.add(D.builder().v("1").build());
        ds.add(D.builder().v("4").build());
        ds.add(D.builder().v("3").build());
        ds.add(D.builder().v("5").build());

        //對ds進行正向排序
        System.out.println(ds.stream().sorted(Comparator.comparing(P::getV)).collect(Collectors.toList()));
        //原始提供的逆序方式,不能使用父類P::getV()
        System.out.println(ds.stream().sorted(Comparator.comparing(D::getV).reversed()).collect(Collectors.toList()));
        //對ds進行逆向排序
        System.out.println(ds.stream().sorted(Comparators.reverseSort(P::getV)).collect(Collectors.toList()));
        //原始順序(不變)
        System.out.println(ds);

        //自身就是可排序的排序
        List<String> ss = new ArrayList<>();
        ss.add("8");
        ss.add("9");
        ss.add("5");
        ss.add("4");
        ss.add("7");
        ss.add("6");
        //對ss進行正向排序
        System.out.println(ss.stream().sorted().collect(Collectors.toList()));
        //對ss進行反向排序
        System.out.println(ss.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList()));
        //原始順序(不變)
        System.out.println(ss);

    }
}

class P<T> {
    protected T v;

    protected T getV() {
        return v;
    }

    public String toString() {
        return Objects.toString(v);
    }
}

class A extends P<Integer> {
    @Builder
    A(Integer v) {
        this.v = v;
    }
}

class B extends P<Long> {
    @Builder
    B(Long v) {
        this.v = v;
    }
}

class C extends P<Double> {
    @Builder
    C(Double v) {
        this.v = v;
    }
}

class D extends P<String> {
    @Builder
    D(String v) {
        this.v = v;
    }
}