适用于任何对象类型的快速排序工具类

目的：适用于任何对象类型的排序类，采用快速排序实现

测试：采用的1KW的Integer包装类测试，效率比原生低了5倍量级，所以请根据实际情况使用（原生大约2.5s，该工具类11s）。

源代码如下：

import java.util.List;
import java.util.function.BiFunction;

/**
 * Java快排工具类
 * 环境：JDK > 1.8
 *
 * @author caochong
 * @since 1.0
 */
public class QuickSort<T> {

    // 原数组
    private List<T> metaArray;

    // 倒序方式
    private boolean reverse = true;


    /**
     * 获取数组
     *
     * @return 原数组
     */
    public List<T> get() {
        return metaArray;
    }

    /**
     * 设定元数组
     *
     * @param metaArray 原数组
     * @return QuickSort实例对象
     */
    public QuickSort<T> setMetaArray(List<T> metaArray) {
        this.metaArray = metaArray;
        return this;
    }

    // 比较器和状态值
    private BiFunction<T, T, Integer> comparator;
    private boolean isComparator = false;

    /**
     * 设置比较器。如果设置了比较器，排序方式将默认按照比较器处理
     *
     * @param func 比较器
     * @return QuickSort实例对象
     */
    public QuickSort<T> setComparator(BiFunction<T, T, Integer> func) {
        if (func == null) {
            throw new RuntimeException("比较器错误");
        }
        this.comparator = func;
        this.isComparator = true;
        return this;
    }

    /**
     * 设置是否倒序
     *
     * @param reverse 是否按原比较器倒序，默认按照比较器的比较值或者{@link Comparable}接口方法处理在
     * @return QuickSort实例对象
     */
    public QuickSort<T> setReverse(boolean reverse) {
        this.reverse = !reverse;
        return this;
    }

    /**
     * 执行快排
     * 执行之前需设置原数据，否则异常
     */
    public void build() {
        if (metaArray == null) {
            throw new RuntimeException("未设置操作数据");
        }
        quickSort(metaArray, 0, metaArray.size() - 1);
    }

    /**
     * 默认的快排处理，将使用输入类型的比较器进行比较
     *
     * @param arr List数组
     */
    public void quickSort(List<T> arr) {
        quickSort(arr, 0, arr.size() - 1);
    }

    /**
     * 快排处理核心
     *
     * @param arr   原数组
     * @param left  左指针
     * @param right 右指针
     */
    private void quickSort(List<T> arr, int left, int right) {
        if (left < right) {
            int partitionIndex = partition(arr, left, right);
            quickSort(arr, left, partitionIndex - 1);
            quickSort(arr, partitionIndex + 1, right);
        }
    }

    /**
     * 快排处理核心 -> 基准比较
     *
     * @param arr   原数组
     * @param left  左指针
     * @param right 右指针
     */
    private int partition(List<T> arr, int left, int right) {
        // 设定基准值（pivot）
        int pivot = left;
        int index = pivot + 1;
        for (int i = index; i <= right; i++) {
            if (compare(arr.get(i), arr.get(pivot))) { // arr.get(i) < arr.get(pivot)
                swap(arr, i, index);
                index++;
            }
        }
        swap(arr, pivot, index - 1);
        return index - 1;
    }

    /**
     * 比较处理
     */
    @SuppressWarnings("unchecked")
    private boolean compare(T i, T j) {
        if (isComparator) {
            return reverse == comparator.apply(i, j) < 0;
        } else {
            if (i instanceof Comparable) {
                Comparable<T> ci = (Comparable<T>) i;
                return reverse == ci.compareTo(j) < 0;
            }
            throw new RuntimeException("排序对象未实现java.lang.Comparable接口，或设置比较处理器");
        }
    }

    /**
     * 原数据交换
     */
    private void swap(List<T> arr, int i, int j) {
        T temp = arr.get(i);
        arr.set(i, arr.get(j));
        arr.set(j, temp);
    }

}