Java Array Sort Descending?

Existe-t-il un moyen FACILE de sortinger un tableau dans l’ordre décroissant, comme s’il s’agissait d’un sorting par ordre croissant dans la classe Arrays ?

Ou dois-je arrêter d’être paresseux et le faire moi-même: [

Vous pouvez l’utiliser pour sortinger tous les types d’objects

sort(T[] a, Comparator c) Arrays.sort(a, Collections.reverseOrder()); 

Arrays.sort() ne peut pas être utilisé directement pour sortinger les tableaux primitifs en ordre décroissant. Si vous essayez d’appeler la méthode Arrays.sort() en transmettant le comparateur inverse défini par Collection.reverseOrder() , l’erreur sera

aucune méthode appropriée trouvée pour sort (int [], comparateur)

Cela fonctionnera bien avec le tableau Integer mais ne fonctionnera pas avec un tableau int.

La seule façon de sortinger un tableau primitif par ordre décroissant est de sortinger d’abord le tableau dans l’ordre croissant, puis d’inverser le tableau en place. Cela est également vrai pour les tableaux primitifs à deux dimensions.

Vous pouvez utiliser ceci:

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

Collections.reverseOrder() renvoie un Comparator utilisant l’ordre naturel inverse. Vous pouvez obtenir une version inversée de votre propre comparateur à l’aide de Collections.reverseOrder(myComparator) .

pour une liste

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

pour un tableau

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

sans comparateur explicite:

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

avec comparateur explicite:

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

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

  1. multipliez le tableau par -1
  2. Trier
  3. multiplier encore avec -1

Littéralement parlé:

 array = -Arrays.sort(-array) 

Java 8:

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

Mise à jour: reversed() inverse le comparateur spécifié. En général, les comparateurs sont en ordre croissant, ce qui change l’ordre en décroissant.

Pour le tableau qui contient des éléments de primitives s’il y a org.apache.commons.lang(3) à disposition un moyen simple d’inverser le tableau (après l’avoir sortingé) est d’utiliser:

 ArrayUtils.reverse(array); 

Je ne sais pas quel était votre cas d’utilisation, mais en plus des autres réponses, une autre option (paresseuse) consiste à toujours sortinger par ordre croissant, comme vous l’indiquez, mais ensuite à la place.

Vous devez d’abord sortinger votre tableau en utilisant:

  Collections.sort(Myarray); 

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

  Collections.reverse(Myarray); 

Une autre solution est que si vous utilisez l’interface Comparable , vous pouvez changer les valeurs de sortie que vous avez 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 

magnitude est un atsortingbut avec un type de données double dans mon programme. C'était le sorting de ma fréq de classe définie dans l'ordre inverse par son ampleur. Donc, pour corriger cela, vous changez les valeurs renvoyées par < 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 

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

La beauté (à mon avis) de cette solution est qu'elle peut être utilisée pour sortinger les classes définies par l'utilisateur, et même plus que celles-ci par un atsortingbut spécifique. Si l'implémentation d'une interface Comparable vous semble décourageante, je vous encourage à ne pas penser de cette manière, ce n'est pas le cas. Ce lien sur la manière de mettre en œuvre des méthodes comparables m'a beaucoup facilité la tâche. Les personnes espérant pouvoir utiliser cette solution et que votre joie sera même comparable à la mienne.

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

ou

 array.sort(function(a, b) {return a - b;}); //ascending 
 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; } 

Il suffit d’utiliser cette méthode pour sortinger un tableau de type double dans l’ordre décroissant, vous pouvez l’utiliser pour sortinger les tableaux de tout autre type (comme int, float, etc.) en changeant simplement le type de retour, le type d’argument et la variable type “x” au type correspondant. vous pouvez également changer “> =” à “<=" dans la condition if pour que l'ordre soit croissant.

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’objects. Dire:

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

Cela a fonctionné pour moi:

 package doublearraysort; import java.util.Arrays; import java.util.Collections; public class Gpa { public static void main(Ssortingng[] 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); } } } 

Sortie:

 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