Java tableau Trier descendant?
https://stackoverflow.com/questions/1694751
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianQuestion
Yat-il un moyen facile de trier un tableau dans l'ordre décroissant comme la façon dont ils ont une sorte dans l'ordre croissant dans la section classe Arrays ?
Ou dois-je cesser d'être paresseux et faire moi-même: [
La solution
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 directement utilisé pour trier des tableaux primitifs dans l'ordre décroissant. Si vous essayez d'appeler la méthode Arrays.sort() en passant par Comparator inverse défini Collection.reverseOrder(), il jette l'erreur
pas de méthode appropriée trouvée pour trier (int [], le comparateur)
Cela fonctionne bien avec tableau entier, mais ne fonctionnera pas avec un tableau int.
La seule façon de trier une matrice primitive dans l'ordre décroissant est, tout d'abord trier le tableau dans l'ordre croissant, puis inverser la matrice en place. Cela est également vrai pour les tableaux primitifs en deux dimensions.
Autres conseils
Vous pouvez utiliser ceci:
Arrays.sort(data, Collections.reverseOrder());
Collections.reverseOrder() renvoie 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());
une alternative pourrait être (pour les numéros !!!)
- multiplier la matrice par -1
- sort
- multiplier une fois de plus avec -1
Littéralement parlé:
array = -Arrays.sort(-array)
sans comparaison explicite:
Collections.sort(list, Collections.reverseOrder());
avec comparateur explicite:
Collections.sort(list, Collections.reverseOrder(new Comparator()));
Java 8:
Arrays.sort(list, comparator.reversed());
Mise à jour:
reversed() inverse le comparateur spécifié. Habituellement, l'ordre croissant des comparateurs, donc cela change l'ordre de descendre.
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 votre cas d'utilisation a toutefois été en plus d'autres réponses ici une autre option (paresseux) est encore trier dans l'ordre croissant comme vous l'indiquez mais itérer dans inverse pour la place .
D'abord, vous devez 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 faites usage de Comparable Interface 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;
}
Si magnitude est un attribut avec le type de données à double dans mon programme. Ce triait ma classe définie fréq dans l'ordre inverse par lui de grandeur. Ainsi, afin de corriger cela, vous changez les valeurs renvoyées par la < et >. Cela vous donne ce qui suit:
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 cette compareTo, nous appelons simplement Arrays.sort(mFreq) qui vous donnera la freq [] mFreq de tableau trié.
La beauté (à mon avis) de cette solution est qu'il peut être utilisé pour trier les classes définies par l'utilisateur, et plus encore que ce genre elles par un attribut spécifique. Si la mise en œuvre d'une interface Comparable semble intimidante pour vous, je vous encourage à ne pas penser de cette façon, il est en fait pas. Ce lien sur la façon de mettre en œuvre comparable a fait des choses beaucoup plus facile pour moi. personnes Espérant peuvent faire usage de 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
Il est pas directement possible d'inverser trier un tableau de primitives (à savoir, 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 des types primitifs (de int).
Cependant, nous pouvons utiliser Java 8 Stream première zone du 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]
Je sais que c'est un fil assez vieux, mais voici une version mise à jour pour Java Entiers et 8:
Arrays.sort(array, (o1, o2) -> o2 - o1);
Notez qu'il est "o1 - o2". Pour la normale par ordre croissant (ou Comparator.comparingInt ())
Ceci fonctionne également pour tout autre type d'objets. Dis:
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(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);
}
}
}
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
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 trier un tableau de type double dans l'ordre décroissant, vous pouvez l'utiliser pour trier les tableaux d'un autre type (comme int, float, et etc) en changeant le « type de retour », l ' « argument Type » et la variable "type de x" du type correspondant. vous pouvez également changer « > = » à « <= » dans la condition if de faire l'ordre croissant.
Vous pouvez utiliser flux opérations ( Collections.stream () ) avec Comparator. inverseOrdre () .
Par exemple, supposons que vous avez 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 articles dans leur ordre « naturel » que vous pouvez utiliser le trié () méthode (ou à laisser et obtenir le même résultat):
items.stream()
.sorted()
.forEach(item -> System.out.println(item));
Ou de les imprimer dans l'ordre décroissant (inverse), vous pouvez utiliser le 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 la collecte d'avoir mis en œuvre Comparable (tout comme Integer, String, etc.).
