Tri de tableau Java décroissant?


Réponses:


330

Vous pouvez l'utiliser pour trier toutes sortes d'objets

sort(T[] a, Comparator<? super T> c) 

Arrays.sort(a, Collections.reverseOrder());

Arrays.sort()ne peut pas être utilisé directement pour trier les tableaux primitifs dans l'ordre décroissant. Si vous essayez d'appeler la Arrays.sort()méthode en passant le Comparateur inversé défini par Collections.reverseOrder(), cela générera l'erreur

aucune méthode appropriée n'a été trouvée pour le tri (int [], comparateur)

Cela fonctionnera très bien avec 'Array of Objects' comme le tableau Integer mais ne fonctionnera pas avec un tableau primitif tel que int array.

La seule façon de trier un tableau primitif par ordre décroissant est de d'abord trier le tableau par ordre croissant, puis d'inverser le tableau en place. Cela est également vrai pour les tableaux primitifs bidimensionnels.


115
Il ne peut pas trier les tableaux de primitives
Masood_mj

14
Convertissez vos primitives en leurs objets respectifs. Entier pour int, Double pour double, Booléen pour booléen, etc.
Ishmael

12
si vous souhaitez toujours utiliser votre comparateur personnalisé :Collections.reverseOrder(this)
Sebastian Hojas

Collections.reverseOrder () ne prend aucun paramètre (sauf s'il me manque quelque chose?), À la place, j'ai utilisé myComparator.reversed ().
jsaven

1
Arrays.sort () ne peut pas être utilisé directement pour trier les tableaux primitifs dans l'ordre décroissant. Si vous essayez d'appeler la méthode Arrays.sort () en passant le Comparateur inversé défini par Collection.reverseOrder (), cela générera l'erreur - "aucune méthode appropriée trouvée pour le tri (int [], comparator <object>)" fonctionne correctement avec un tableau entier mais ne fonctionnera pas avec un tableau int. La seule façon de trier un tableau primitif dans l'ordre décroissant est de d'abord trier le tableau dans l'ordre croissant, puis d'inverser le tableau en place. Cela est également vrai pour les tableaux primitifs bidimensionnels.
akuriako

96

pour une liste

Collections.sort(list, Collections.reverseOrder());

pour un tableau

Arrays.sort(array, Collections.reverseOrder());

26
int [] array = {2,4,3,6,8,7}; Arrays.sort (array, Collections.reverseOrder ()); me donne une erreur! L'erreur est: "La méthode sort (int []) dans le type Arrays n'est pas applicable pour les arguments (int [], Comparator <Object>)"
Dixit Singla

8
int n'est pas un objet. Essayez d'utiliser Integer [] à la place.
Ornithoptère

6
int est un type principal alors que Integer ne l'est pas. C'est pourquoi Integer a des méthodes comme parse, toString, etc.
Ornithopter

91

Vous pouvez utiliser ceci:

    Arrays.sort(data, Collections.reverseOrder());

Collections.reverseOrder()renvoie un en Comparatorutilisant l'ordre naturel inverse. Vous pouvez obtenir une version inversée de votre propre comparateur en utilisant Collections.reverseOrder(myComparator).


8
L'OP veut trier un tableau. Collections.sort()prend un Listparamètre d'entrée, pas un tableau.
Pascal Thivent

61

une alternative pourrait être (pour les chiffres !!!)

  1. multipliez le tableau par -1
  2. Trier
  3. multipliez à nouveau avec -1

Littéralement parlé:

array = -Arrays.sort(-array)

7
Cette méthode est réellement créative si nous trions des nombres, même si elle n'est pas générique et pourrait causer des problèmes de débordement ...
hackjutsu

3
C'est une très bonne réponse pour les types primitifs. Tu es un génie.
Halil İbrahim Oymacı

2
Sauf que ça va échouer pour Integer.MIN_VALUE(ou tout autre utilisation primitive). Ce serait mieux sort(), alors reverse(), mais vous devrez faire l'inverse vous-même, car ils n'ont pas ajouté d' Arrays.reverse()implémentations.
Andreas

1
@Halil İbrahim Oymacı: -la syntaxe du tableau ne fonctionne pas pour moi: "mauvais type d'opérande int [] pour l'opérateur unaire '-'"
Ligne

8
@line Vous devez multiplier -1 par le tableau. Le code ci-dessus est un pseudo-code. Vous pouvez multiplier -1 sur un tableau dans une boucle for puis appeler la méthode Array.sort (), enfin vous multipliez -1 sur un nouveau tableau.
Halil İbrahim Oymacı

47

sans comparateur explicite:

Collections.sort(list, Collections.reverseOrder());

avec comparateur explicite:

Collections.sort(list, Collections.reverseOrder(new Comparator()));

10

Java 8:

Arrays.sort(list, comparator.reversed());

Mettre à jour: reversed()inverse le comparateur spécifié. Habituellement, les comparateurs ordonnent en ordre croissant, ce qui modifie l'ordre en ordre décroissant.


1
Cela fonctionne parfaitement avec les objets mais pas avec les primitives. Pour trier la primitive int, vous devez trier dans l'ordre ASC, puis inverser la réponse.
Russell Sk.

5

Pour un tableau qui contient des éléments de primitives s'il existe org.apache.commons.lang(3)un moyen simple d'inverser un tableau (après l'avoir trié), il faut utiliser:

ArrayUtils.reverse(array);

1
Pourquoi le trier d'abord par ordre croissant puis utiliser une bibliothèque externe pour revenir à cet ordre, alors que cela peut être fait en une seule étape?
Betlista

Et cette seule étape étant?
Josip Maslac

5
Oui mais (comme indiqué dans les commentaires de ces réponses) cela ne fonctionne pas pour les primitives que ma réponse adresse. Bien sûr, ma réponse n'est certainement pas optimale, mais j'ai trouvé qu'elle répondait aux critères de «facilité» que l'auteur d'origine a mis en évidence - c'est-à-dire. Arrays.sort(primitives); ArrayUtils.reverse(primitives);
Josip Maslac

5

Vous devez d'abord trier votre tableau en utilisant:

Collections.sort(Myarray);

Ensuite, vous devez inverser l'ordre de croissant à décroissant en utilisant:

Collections.reverse(Myarray);

4

Je ne sais pas quel était votre cas d'utilisation, mais en plus des autres réponses ici, une autre option (paresseuse) consiste à toujours trier dans l'ordre croissant comme vous l'indiquez, mais à répéter à la place dans l' ordre inverse .


4

Il n'est pas directement possible d'inverser le tri d'un tableau de primitives (c'est-à-dire int[] arr = {1, 2, 3};) en utilisant Arrays.sort()et Collections.reverseOrder()parce que ces méthodes nécessitent des types de référence ( Integer) au lieu de types primitifs (int ).

Cependant, nous pouvons utiliser Java 8 Stream pour d'abord encadrer le tableau pour trier dans l'ordre inverse:

// an array of ints
int[] arr = {1, 2, 3, 4, 5, 6};

// an array of reverse sorted ints
int[] arrDesc = Arrays.stream(arr).boxed()
    .sorted(Collections.reverseOrder())
    .mapToInt(Integer::intValue)
    .toArray();

System.out.println(Arrays.toString(arrDesc)); // outputs [6, 5, 4, 3, 2, 1]

3

Une autre solution est que si vous utilisez l' interface Comparable , vous pouvez changer les valeurs de sortie que vous aviez spécifiées dans votre compareTo (Object bCompared).

Par exemple :

public int compareTo(freq arg0) 
{
    int ret=0;
    if(this.magnitude>arg0.magnitude)
        ret= 1;
    else if (this.magnitude==arg0.magnitude)
        ret= 0;
    else if (this.magnitude<arg0.magnitude)
        ret= -1;
    return ret;
}

magnitude est un attribut avec le type de données double dans mon programme. Cela triait ma fréquence de classe définie dans l'ordre inverse par sa magnitude. Donc, pour corriger cela, vous changez les valeurs renvoyées par le <et >. Cela vous donne les éléments suivants:

public int compareTo(freq arg0) 
{
    int ret=0;
    if(this.magnitude>arg0.magnitude)
        ret= -1;
    else if (this.magnitude==arg0.magnitude)
        ret= 0;
    else if (this.magnitude<arg0.magnitude)
        ret= 1;
    return ret;
}

Pour utiliser ce compareTo, nous appelons simplement Arrays.sort(mFreq)qui vous donnera le tableau triéfreq [] mFreq .

La beauté (à mon avis) de cette solution est qu'elle peut être utilisée pour trier les classes définies par l'utilisateur, et encore plus que les trier par un attribut spécifique. Si la mise en œuvre d'une interface comparable vous semble intimidante, je vous encourage à ne pas penser de cette façon, ce n'est pas le cas. Ce lien sur la façon de mettre en œuvre des choses comparables m'a beaucoup facilité la tâche. En espérant que les personnes puissent utiliser cette solution, et que votre joie sera même comparable à la mienne.


2
array.sort(function(a, b) {return b - a;}); //descending 

ou

array.sort(function(a, b) {return a - b;}); //ascending

5
En quoi est-ce pertinent pour la question Java?
Dmitry Ginzburg

0

Je sais que c'est un fil assez ancien, mais voici une version mise à jour pour Integers et Java 8:

Arrays.sort(array, (o1, o2) -> o2 - o1);

Notez qu'il s'agit de "o1 - o2" pour l'ordre croissant normal (ou Comparator.comparingInt ()).

Cela fonctionne également pour tous les autres types d'objets. Dire:

Arrays.sort(array, (o1, o2) -> o2.getValue() - o1.getValue());

1
Cela ne fonctionne que pour les tableaux de types de référence, pas les tableaux de types primitifs.
kimbaudi

0

Cela a fonctionné pour moi:

package doublearraysort;

import java.util.Arrays;
import java.util.Collections;

public class Gpa {


    public static void main(String[] args) {
        // initializing unsorted double array
        Double[] dArr = new Double[] {                 
            new Double(3.2),
            new Double(1.2),
            new Double(4.7),
            new Double(3.3),
            new Double(4.6),
           };
        // print all the elements available in list
        for (double number : dArr) {
            System.out.println("GPA = " + number);
        }

        // sorting the array
        Arrays.sort(dArr, Collections.reverseOrder());

        // print all the elements available in list again
        System.out.println("The sorted GPA Scores are:");
        for (double number : dArr) {
            System.out.println("GPA = " + number);
        }
    }
}

Production:

GPA = 3.2
GPA = 1.2
GPA = 4.7
GPA = 3.3
GPA = 4.6
The sorted GPA Scores are:
GPA = 4.7
GPA = 4.6
GPA = 3.3
GPA = 3.2
GPA = 1.2

0
public double[] sortArrayAlgorithm(double[] array) { //sort in descending order
    for (int i = 0; i < array.length; i++) {
        for (int j = 0; j < array.length; j++) {
            if (array[i] >= array[j]) {
                double x = array[i];
                array[i] = array[j];
                array[j] = x;
            }
        }
    }
    return array;
}

utilisez simplement cette méthode pour trier un tableau de type double dans l'ordre décroissant, vous pouvez l'utiliser pour trier des tableaux de tout autre type (comme int, float, etc.) simplement en changeant le "type de retour", le "type d'argument" et la variable "x" type au type correspondant. vous pouvez également changer "> =" en "<=" dans la condition if pour rendre l'ordre croissant.


0

Vous pouvez utiliser des opérations de flux ( Collections.stream () ) avec Comparator.reverseOrder () .

Par exemple, supposons que vous ayez cette collection:

List<String> items = new ArrayList<>();
items.add("item01");
items.add("item02");
items.add("item03");
items.add("item04");
items.add("item04");

Pour imprimer les éléments dans leur ordre "naturel", vous pouvez utiliser la méthode sorted () (ou la laisser de côté et obtenir le même résultat):

items.stream()
     .sorted()
     .forEach(item -> System.out.println(item));

Ou pour les imprimer dans l'ordre décroissant (inverse), vous pouvez utiliser la méthode triée qui prend un comparateur et inverser l'ordre:

items.stream()
     .sorted(Comparator.reverseOrder())
     .forEach(item -> System.out.println(item));

Notez que cela nécessite que la collection ait implémenté Comparable (tout comme Integer, String, etc.).


0

Il y a beaucoup de gâchis ici - les gens suggèrent des solutions pour les valeurs non primitives, essayent d'implémenter des algues de tri à partir du sol, donnent des solutions impliquant des bibliothèques supplémentaires, en montrant certaines hacky etc. La réponse à la question d'origine est 50 / 50. Pour ceux qui veulent juste copier / coller:

// our initial int[] array containing primitives
int[] arrOfPrimitives = new int[]{1,2,3,4,5,6};

// we have to convert it into array of Objects, using java's boxing
Integer[] arrOfObjects = new Integer[arrOfPrimitives.length];
for (int i = 0; i < arrOfPrimitives.length; i++) 
    arrOfObjects[i] = new Integer(arrOfPrimitives[i]);

// now when we have an array of Objects we can use that nice built-in method
Arrays.sort(arrOfObjects, Collections.reverseOrder());

arrOfObjectsest {6,5,4,3,2,1}maintenant. Si vous avez un tableau autre que ints - utilisez l' objet correspondant à la place de Integer.


0

Pour les discussions ci-dessus, voici un exemple simple pour trier les tableaux primitifs dans l'ordre décroissant.

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] nums = { 5, 4, 1, 2, 9, 7, 3, 8, 6, 0 };
        Arrays.sort(nums);

        // reverse the array, just like dumping the array!
        // swap(1st, 1st-last) <= 1st: 0, 1st-last: nums.length - 1
        // swap(2nd, 2nd-last) <= 2nd: i++,  2nd-last: j--
        // swap(3rd, 3rd-last) <= 3rd: i++,  3rd-last: j--
        //
        for (int i = 0, j = nums.length - 1, tmp; i < j; i++, j--) {
            tmp = nums[i];
            nums[i] = nums[j];
            nums[j] = tmp;
        }

        // dump the array (for Java 4/5/6/7/8/9)
        for (int i = 0; i < nums.length; i++) {
            System.out.println("nums[" + i + "] = " + nums[i]);
        }
    }
}

Production:

nums[0] = 9
nums[1] = 8
nums[2] = 7
nums[3] = 6
nums[4] = 5
nums[5] = 4
nums[6] = 3
nums[7] = 2
nums[8] = 1
nums[9] = 0

0

Méthode simple pour trier un tableau int décroissant:

private static int[] descendingArray(int[] array) {
    Arrays.sort(array);
    int[] descArray = new int[array.length];
    for(int i=0; i<array.length; i++) {
        descArray[i] = array[(array.length-1)-i];
    }
    return descArray;
}

0

Une autre façon avec Comparator

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

Integer[] aInt = {6,2,3,4,1,5,7,8,9,10};
Arrays.sort(aInt, Comparator.reverseOrder()  );

0

C'est bien parfois on s'entraine sur un exemple, en voici un plein:

sortdesc.java

import java.util.Arrays;
import java.util.Collections;
class sortdesc{
public static void main(String[] args){
       // int Array
       Integer[] intArray=new Integer[]{
                 new Integer(15),
                 new Integer(9),
                 new Integer(16),
                 new Integer(2),
                 new Integer(30)};

       // Sorting int Array in descending order
       Arrays.sort(intArray,Collections.reverseOrder());

       // Displaying elements of int Array
       System.out.println("Int Array Elements in reverse order:");
       for(int i=0;i<intArray.length;i++)
          System.out.println(intArray[i]);

       // String Array
       String[] stringArray=new String[]{"FF","PP","AA","OO","DD"};

       // Sorting String Array in descending order
       Arrays.sort(stringArray,Collections.reverseOrder());

       // Displaying elements of String Array
       System.out.println("String Array Elements in reverse order:");
       for(int i=0;i<stringArray.length;i++)
          System.out.println(stringArray[i]);}}

le compiler ...

javac sortdec.java

l'appeler ...

java sortdesc

PRODUCTION

Int Array Elements in reverse order:
30
16
15
9
2
String Array Elements in reverse order:
PP
OO
FF
DD
AA

Si vous voulez essayer un tableau alphanumérique ...

//replace this line:
String[] stringArray=new String[]{"FF","PP","AA","OO","DD"};

//with this:
String[] stringArray=new String[]{"10FF","20AA","50AA"};

tu vas obtenir la SORTIE comme suit:

50AA
20AA
10FF

la source

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.