Le tableau Java descend?

y a-t-il un moyen facile de trier un tableau dans l'ordre décroissant comme comment ils ont un tri dans l'ordre ascendant dans la classe tableaux ?

ou dois-je cesser d'être paresseux et le faire moi-même: [

227
demandé sur I Like to Code 2009-11-08 02:05:06

14 réponses

Vous pouvez l'utiliser pour trier tous les types 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 par ordre décroissant. Si vous essayez d'appeler la méthode Arrays.sort() en passant le comparateur inversé défini par Collection.reverseOrder() , il lancera l'erreur

pas de méthode appropriée trouvé pour le tri(int[],comparateur)

qui fonctionnera très bien avec le tableau entier mais will ne fonctionne pas avec un tableau int.

la seule façon de trier un tableau primitif dans l'ordre décroissant est, d'abord trier le tableau dans l'ordre ascendant puis inverser le tableau en place. Ceci est également vrai pour les tableaux primitifs bidimensionnels.

268
répondu jhamon 2018-04-17 14:51:03

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) .

87
répondu William 2016-02-19 22:55:33

pour une liste

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

pour un tableau

Arrays.sort(array, Collections.reverseOrder());
79
répondu Ornithopter 2013-06-25 04:31:58

sans comparateur explicite:

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

avec comparateur explicite:

Collections.sort(list, Collections.reverseOrder(new Comparator()));
46
répondu Milan 2014-10-18 02:13:03

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

  1. multipliez le tableau par -1
  2. trier
  3. multiplier de nouveau avec -1

Littéralement parlé:

array = -Arrays.sort(-array)
41
répondu FHDougherty 2014-09-05 17:19:53

Java 8:

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

mise à jour: reversed() inverse le comparateur spécifié. Habituellement, les comparateurs ordonnent Ascendant, donc cela change l'ordre en descendant.

6
répondu Michel Jung 2017-08-28 10:59:38

pour un tableau qui contient des éléments de primitives s'il y a org.apache.commons.lang(3) à disposition. la manière facile d'inverser le tableau (après le tri) est d'utiliser:

ArrayUtils.reverse(array);
4
répondu Josip Maslac 2014-02-27 10:27:43

Je ne sais pas ce que votre cas d'utilisation était, mais en plus d'autres réponses ici une autre option (paresseux) est de toujours trier dans l'ordre ascendant que vous indiquez, mais puis itérer dans inverse ordre à la place.

3
répondu SK9 2014-02-27 10:51:42

vous devez d'abord trier votre tableau en utilisant:

        Collections.sort(Myarray);

ensuite, vous devez inverser l'ordre de la montée à la descente en utilisant:

        Collections.reverse(Myarray);
2
répondu Masoud 2016-02-26 19:35:49

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(objet B-compared).

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 type de données double dans mon programme. Cela triait ma classe définie freq par ordre de grandeur. Afin de corriger cela, vous changez les valeurs retourné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 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 des classes définies par l'utilisateur, et même plus que cela 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 comparable a rendu les choses beaucoup plus facile pour moi. En espérant que les personnes puissent faire usage de cette solution, et que votre joie sera même comparable à la mienne.

2
répondu Chris - Jr 2017-05-23 12:02:48
array.sort(function(a, b) {return b - a;}); //descending 

ou

array.sort(function(a, b) {return a - b;}); //ascending
1
répondu AzFalconer 2017-06-19 05:10:42
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 de tous les autres types(comme int, float, et etc) juste en changeant le" type de retour", le" type d'argument "et la variable" x " type au type correspondant. vous pouvez également modifier ">=""<=", dans la condition if pour faire de l'ordre ascendant.

1
répondu Mohsen 2018-04-29 10:09:35

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

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

noter qu'il s'agit de" o1 - o2 " pour l'ordre ascendant normal (ou comparateur.comparingInt()).

cela fonctionne également pour tout autre type d'objets. Dis:

Arrays.sort(array, (o1, o2) -> o2.getValue() - o1.getValue());
0
répondu sebschaef 2018-01-03 18:13:17

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
0
répondu Fred Denson 2018-03-24 20:29:32