Triez les tableaux de types primitifs dans l'ordre décroissant

Question

J'ai un grand choix de types primitifs (double). Comment trier les éléments par ordre décroissant ?

Malheureusement, l'API Java ne prend pas en charge le tri des types primitifs avec un comparateur.

Une solution de contournement serait de trier et puis inverser:

 double[] array = new double[1048576];
...
Arrays.sort(array);
// reverse the array
for(int i=0;i<array.length/2;i++) {
     // swap the elements
     double temp = array[i];
     array[i] = array[array.length-(i+1)];
     array[array.length-(i+1)] = temp;
}
 

C'est lent - particulièrement si le tableau est déjà assez bien trié.

Quelle est la meilleure alternative?

Answer 1

Je pense qu'il serait préférable de ne pas réinventer la roue et d'utiliser Arrays.sort ().

Oui, j'ai vu la partie "descendant". Le tri est la partie la plus difficile et vous souhaitez bénéficier de la simplicité et de la rapidité du code de bibliothèque Java. Une fois que cela est fait, vous inversez simplement le tableau, qui est une opération O (n) relativement peu coûteuse. voici un code que j'ai trouvé pour le faire en aussi peu que 4 lignes.

Answer 2

La goyave a des méthodes pour la conversion des primitives de tableaux à des Listes de types wrapper. La part belle est que ces listes sont des affichages en direct, pour les opérations sur leur travail sur le sous-jacent tableaux (similaire à l' Arrays.asList(), mais pour les primitives).

De toute façon, chacune de ces Listes peuvent être transmises à l' Collections.reverse():

int[] intArr = { 1, 2, 3, 4, 5 };
float[] floatArr = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f };
double[] doubleArr = { 1.0d, 2.0d, 3.0d, 4.0d, 5.0d };
byte[] byteArr = { 1, 2, 3, 4, 5 };
short[] shortArr = { 1, 2, 3, 4, 5 };
Collections.reverse(Ints.asList(intArr));
Collections.reverse(Floats.asList(floatArr));
Collections.reverse(Doubles.asList(doubleArr));
Collections.reverse(Bytes.asList(byteArr));
Collections.reverse(Shorts.asList(shortArr));
System.out.println(Arrays.toString(intArr));
System.out.println(Arrays.toString(floatArr));
System.out.println(Arrays.toString(doubleArr));
System.out.println(Arrays.toString(byteArr));
System.out.println(Arrays.toString(shortArr));

Sortie:

[5, 4, 3, 2, 1]
[5.0, 4.0, 3.0, 2.0, 1.0]
[5.0, 4.0, 3.0, 2.0, 1.0]
[5, 4, 3, 2, 1]
[5, 4, 3, 2, 1]

Answer 3

Votre mise en œuvre (l'un dans la question) est plus rapide que par exemple un emballage avec toList() et à l'aide d'un comparateur à base de méthode. Auto-boxing, et jusqu'au comparateur de méthodes ou enveloppé Collections d'objets est beaucoup plus que juste inverser.

Bien sûr, vous pouvez écrire votre propre tri. Qui pourrait ne pas être la réponse que vous cherchez, mais notez que si votre commentaire sur "si le tableau est déjà trié assez bien" se produit fréquemment, vous pourriez bien faire pour choisir un algorithme de tri qui gère ce cas (par exemple, insertion) plutôt que d'utiliser Arrays.sort() (ce qui est mergesort, ou d'insertion si le nombre d'éléments est petit).

Answer 4

Il y a eu une certaine confusion à propos de Arrays.asList dans les autres réponses. Si vous dites

double[] arr = new double[]{6.0, 5.0, 11.0, 7.0};
List xs = Arrays.asList(arr);
System.out.println(xs.size());  // prints 1

ensuite, vous aurez une Liste avec les 1 élément. La Liste résultante a le double tableau[] comme son propre élément. Ce que vous voulez est d'avoir un List<Double> dont les éléments sont les éléments de l' double[].

Malheureusement, aucune solution n'impliquant des Comparateurs de travail pour une primitive de tableau. Arrays.sort accepte uniquement un Comparateur en étant passé une Object[]. Et pour les raisons décrites ci-dessus, Arrays.asList ne vous laissera pas vous faire une Liste de tous les éléments de votre tableau.

Donc, malgré ma précédente réponse au commentaire ci-dessous de référence, il n'y a pas de meilleur moyen que manuellement l'inversion de la matrice après le tri. Toute autre approche (telles que copier les éléments dans un Double[] et inverse le tri et la copie de dos) serait plus de code et plus lent.