Existe-t-il un moyen FACILE de trier un tableau dans l'ordre décroissant, comme dans un ordre croissant dans le tri Arrays class?Java Array Tri descendant?
Ou dois-je cesser d'être paresseux et faire moi-même: [
Vous pouvez utiliser cette
sort(T[] a, Comparator<? super T> c)
Arrays.sort(a, Collections.reverseOrder());
Vous pouvez utiliser ceci:
Arrays.sort(data, Collections.reverseOrder());
Collections.reverseOrder() retourne un Comparator en utilisant l'ordre naturel inverse. Vous pouvez obtenir une version inversée de votre propre comparateur en utilisant Collections.reverseOrder(myComparator).
pour une liste
Collections.sort(list ,Collections.reverseOrder());
pour un tableau
Arrays.sort(array, Collections.reverseOrder());
int [] tableau = {2,4,3,6,8,7}; Arrays.sort (array, Collections.reverseOrder()); est en train de me donner une erreur! L'erreur est: "La méthode sort (int []) dans le type Arrays n'est pas applicable aux arguments (int [], Comparateur
int n'est pas un objet. Essayez d'utiliser Integer [] à la place. – Ornithopter
Pourquoi Integer [] fonctionne-t-il et pas int []? – OpMt
Pour tableau qui contient des éléments de primitives s'il est org.apache.commons.lang(3) à disposition moyen facile d'inverser array (après leur tri) est d'utiliser :
ArrayUtils.reverse(array);
Je ne sais pas ce que cependant était votre cas d'utilisation, en plus o Les réponses à cette question sont les suivantes: une autre option (paresseuse) consiste à trier toujours dans l'ordre croissant comme indiqué, puis à itérer dans inverser l'ordre à la place.
une alternative pourrait être (pour les numéros !!!)
Littéralement parlé:
array = -Arrays.sort(-array)
' {__________ lol ________} ' –
Cette méthode est réellement créative si nous classons des nombres, même si elle n'est pas générique et pourrait causer des problèmes de débordement ... – hackjutsu
Ceci est une très bonne réponse pour les types primitifs . Tu es un génie. –
sans COMPARATO explicite r:
Collections.sort(list, Collections.reverseOrder());
avec comparateur explicite:
Collections.sort(list, Collections.reverseOrder(new Comparator()));
Java 8:
Arrays.sort(list, comparator.reversed());
Update: reversed() inverse le comparateur spécifié. Habituellement, les comparateurs passent en ordre croissant, donc cela change l'ordre de décroissant.
Vous devez d'abord trier votre tableau en utilisant:
Collections.sort(Myarray);
Ensuite, vous devez inverser l'ordre d'ascendant à descendant en utilisant:
Collections.reverse(Myarray);
Une autre solution est que si vous êtes en utilisant l'interface comparable, vous pouvez changer les valeurs de sortie que vous avez spécifié 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;
}
Où magnitude est un attribut avec le type de données à double dans mon programme. Cela triait ma classe définie freq dans l'ordre inverse par sa magnitude. Donc, pour corriger cela, vous changez les valeurs retournées par les < 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 même plus que les trier par un attribut spécifique. Si la mise en œuvre d'une interface comparable vous semble décourageante, je vous encourage à ne pas penser ainsi, ce n'est pas le cas. Ce link on how to implement comparable a rendu les choses beaucoup plus faciles pour moi. Espérant que les gens peuvent faire usage de cette solution, et que votre joie sera même comparable au mien.
array.sort(function(a, b) {return b - a;}); //descending
ou
array.sort(function(a, b) {return a - b;}); //ascending
Je sais que c'est un fil assez vieux, mais est ici une version mise à jour pour Entiers et Java 8:
Arrays.sort(array, (o1, o2) -> o2 - o1);
Notez qu'il est « o1 - o2 "pour l'ordre croissant normal (ou Comparator.comparingInt()).
Cela fonctionne également pour tous les autres types d'objets. Dis:
Arrays.sort(array, (o1, o2) -> o2.getValue() - o1.getValue());
Il ne peut pas trier les tableaux de primitives –
Convertissez vos primitives à leurs objets respectifs. Entier pour int, Double pour double, Boolean pour booléen, etc. – Ishmael
si vous voulez toujours utiliser votre [comparateur] personnalisé (http://docs.oracle.com/javase/7/docs/api/java/util/Comparator .html): 'Collections.reverseOrder (this)' –