Comment trier un tableau d'entiers en utilisant un comparateur personnalisé ?

Question

J'ai besoin de trier un tableau d'entiers en utilisant un comparateur personnalisé, mais la bibliothèque Java ne fournit pas de fonction de tri pour les entiers avec des comparateurs (les comparateurs ne peuvent être utilisés qu'avec des objets). Existe-t-il un moyen simple de le faire ?

Answer 1

Si vous ne pouvez pas changer le type de votre tableau d'entrée, la méthode suivante fonctionnera :

final int[] data = new int[] { 5, 4, 2, 1, 3 };
final Integer[] sorted = ArrayUtils.toObject(data);
Arrays.sort(sorted, new Comparator<Integer>() {
    public int compare(Integer o1, Integer o2) {
        // Intentional: Reverse order for this demo
        return o2.compareTo(o1);
    }
});
System.arraycopy(ArrayUtils.toPrimitive(sorted), 0, data, 0, sorted.length);

Cela utilise ArrayUtils du projet commons-lang pour convertir facilement entre int[] y Integer[] crée une copie du tableau, effectue le tri, puis copie les données triées sur l'original.

Answer 2

Que diriez-vous d'utiliser des flux (Java 8) ?

int[] ia = {99, 11, 7, 21, 4, 2};
ia = Arrays.stream(ia).
    boxed().
    sorted((a, b) -> b.compareTo(a)). // sort descending
    mapToInt(i -> i).
    toArray();

Ou en place :

int[] ia = {99, 11, 7, 21, 4, 2};
System.arraycopy(
        Arrays.stream(ia).
            boxed().
            sorted((a, b) -> b.compareTo(a)). // sort descending
            mapToInt(i -> i).
            toArray(),
        0,
        ia,
        0,
        ia.length
    );

Answer 3

Vous pouvez utiliser IntArrays.quickSort(array, comparator) de la bibliothèque fastutil.

Answer 4

Si vous ne voulez pas copier le tableau (disons qu'il est très grand), vous pouvez créer un wrapper List<Integer> qui peuvent être utilisés dans un tri :

final int[] elements = {1, 2, 3, 4};
List<Integer> wrapper = new AbstractList<Integer>() {

        @Override
        public Integer get(int index) {
            return elements[index];
        }

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

        @Override
        public Integer set(int index, Integer element) {
            int v = elements[index];
            elements[index] = element;
            return v;
        }

    };

Et maintenant vous pouvez faire un tri sur cette liste enveloppante en utilisant un comparateur personnalisé.

Answer 5

Vous n'avez pas besoin d'une bibliothèque externe :

Integer[] input = Arrays.stream(arr).boxed().toArray(Integer[]::new);
Arrays.sort(input, (a, b) -> b - a); // reverse order
return Arrays.stream(input).mapToInt(Integer::intValue).toArray();