使用 Arrays.sort() 方法根据您自己的规则对 Java 数组进行排序

使用比较器对数组进行排序不适用于原始类型的数组int[]，long[]等等double[]，因此对于自定义排序，您必须将数组转换为列表List<Integer>或数组Integer[]，使用方法对其进行排序Arrays.sort(T[] arr, Comparator<? super T>) c，然后将其转换回原语数组。

在这种情况下，您应该传递一个函数来转换为原语，而不是比较器，Integer在此基础上您可以使用 构建比较器Comparator.comparingInt(ToIntFunction<? super T>) fn。

public static void sortIntArray(int[] arr, ToIntFunction<Integer> c) {
    Integer[] ints = new Integer[arr.length];
    Arrays.setAll(ints, i -> arr[i]);
    Arrays.sort(ints, Comparator.comparingInt(c));
    Arrays.setAll(arr, i -> ints[i]);
}

您还可以使用 Stream API 并返回一个新的排序数组，但请注意，它IntStream也不支持自定义排序，您必须Stream<Integer>使用以下方法将其转换为然后再返回Stream::mapToInt：

public static int[] sortInts(int[] arr, ToIntFunction<Integer> c) {
    return Arrays.stream(arr)                // IntStream
        .boxed()                             // Stream<Integer>
        .sorted(Comparator.comparingInt(c))  // Stream<Integer>
        .mapToInt(Integer::intValue)         // IntStream
        .toArray();                          // int[]
}

测试：

int[] arr = {0, -14, 191, 161, 19, 144, 195, 1};
sortIntArray(arr, Math::abs);
// или arr = sortInts(arr, Math::abs);
System.out.println(Arrays.toString(arr));

结论：

[0, 1, -14, 19, 144, 161, 191, 195]

同样，您可以传递一个用于自定义排序的方法IntUnaryOperator，该方法接收并返回 type 的结果int，然后在调用比较器时，您需要传递一个指向相应方法的链接IntUnaryOperator::applyAsInt：

public static int[] sortInts(IntUnaryOperator fun, int... arr) {    
    return Arrays.stream(arr)
        .boxed()
        .sorted(Comparator.comparingInt(fun::applyAsInt))
        // аналогия с явным анбоксингом
        // .sorted(Comparator.comparingInt(i -> fun.applyAsInt(i.intValue())))
        .mapToInt(Integer::intValue)
        .toArray();
}

Java 中有一个棘手的问题：您无法使用比较器对基元数组进行排序。标准库提供的方法涉及数组内容的两个副本。您将数据复制到数组或对象集合中，对其进行排序，然后将其复制回来。我想解决问题而不复制。

有这样一种方法：让我们创建一个AbstractList看起来像列表的后继者Integer，但将数据存储在数组中。如果这样的后继被排序，则存储数据的数组将被排序。

import java.util.Arrays;
import java.util.AbstractList;
import java.util.Comparator;

public class Temp {
    public static void main(String[] args) {
        int[] array = {0, -14, 191, 161, 19, 144, 195, 1};
    
        System.out.println(Arrays.toString(array));
        sortArray(array, Comparator.comparingInt(Math::abs));
        System.out.println(Arrays.toString(array));
    }

    public static void sortArray(int[] array, Comparator<? super Integer> c) {
        new IntList(array).sort(c);
    }

    private static class IntList extends AbstractList<Integer> {
        private final int[] array;

        IntList(int[] array) { this.array = array; }

        @Override
        public Integer get(int i) { return array[i]; }

        @Override
        public int size() { return array.length; }

        @Override
        public Integer set(int i, Integer v) {
            int old = array[i];
            array[i] = v;
            return old;
        }
    }
}

一切正常：

$ javac Temp.java && java Temp
[0, -14, 191, 161, 19, 144, 195, 1]
[0, 1, -14, 19, 144, 161, 191, 195]

如果你不怕匿名类，代码可以写得更短：

import java.util.Arrays;
import java.util.AbstractList;
import java.util.Comparator;

public class Temp {
    public static void main(String[] args) {
        int[] array = {0, -14, 191, 161, 19, 144, 195, 1};
    
        System.out.println(Arrays.toString(array));
        sortArray(array, Comparator.comparingInt(Math::abs));
        System.out.println(Arrays.toString(array));
    }

    public static void sortArray(int[] array, Comparator<? super Integer> c) {
        new AbstractList<Integer>() {
            @Override
            public Integer get(int i) { return array[i]; }

            @Override
            public int size() { return array.length; }

            @Override
            public Integer set(int i, Integer v) {
                int old = array[i];
                array[i] = v;
                return old;
            }
        }.sort(c);
    }
}