web-dev-qa-db-fra.com

Java Tableau Trier en ordre décroissant?

Existe-t-il un moyen FACILE de trier un tableau par ordre décroissant, comme dans l'ordre croissant dans classe de tableaux ?

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

javaarrayssortingint
246
AFK

Vous pouvez utiliser ceci pour trier tout type 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 de primitives dans l'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 renvoyée.

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

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

La seule façon de trier un tableau primitif par ordre décroissant consiste à commencer par trier le tableau par ordre croissant, puis à inverser le tableau en place. Ceci est également vrai pour les tableaux primitifs bidimensionnels.

295
user173973

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 à l’aide de Collections.reverseOrder(myComparator).

90
William

pour une liste

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

pour un tableau

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

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

  1. multiplier le tableau par -1
  2. trier
  3. multiplie encore une fois par -1

Littéralement parlé:

array = -Arrays.sort(-array)
50
FHDougherty

sans comparateur explicite:

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

avec comparateur explicite:

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

Java 8:

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

Mise à jour: reversed() inverse le comparateur spécifié. Habituellement, les comparateurs ont l’ordre croissant, ce qui change l’ordre en ordre décroissant.

7
Michel Jung

Je ne sais pas quel était votre cas d'utilisation, mais en plus d'autres réponses, une autre option (paresseuse) consiste à trier toujours dans l'ordre croissant comme vous l'indiquez, puis à effectuer une itération dans l'ordre inverse.

4
SK9

Vous devez d’abord trier votre tableau en utilisant:

Collections.sort(Myarray);

Ensuite, vous devez inverser l'ordre croissant-décroissant en utilisant:

Collections.reverse(Myarray);
4
Masoud

Pour un tableau contenant des éléments de primitives s’il existe org.Apache.commons.lang(3), un moyen simple d’inverser un tableau (après le tri) consiste à utiliser:

ArrayUtils.reverse(array);
4
Josip Maslac

Une autre solution est que si vous utilisez l'interface Comparable, vous pouvez permuter 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<arg0.magnitude)
        ret= -1;
    return ret;
}

Où magnitude est un attribut de type de données double dans mon programme. Cela triait ma classe définie freq dans l'ordre inverse de sa magnitude. Donc, pour corriger cela, vous changez les valeurs retournées par < 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 les classes définies par l’utilisateur, et même plus que cela pour 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 lien sur la façon de mettre en œuvre comparable m'a beaucoup facilité la tâche. En espérant que des personnes puissent utiliser cette solution et que votre joie sera même comparable la mienne.

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

ou

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

utilisez simplement cette méthode pour trier un tableau de type double par ordre décroissant. Vous pouvez l’utiliser pour trier des tableaux de tout autre type (comme int, float, etc.) simplement en changeant le "type de retour", le "type d’argument" et la variable "x" tapez le type correspondant. vous pouvez également remplacer "> =" par "<=" dans la condition if pour que l'ordre soit croissant.

0
Mohsen

Vous pouvez utiliser l'opération stream ( Collections.stream () ) avec Comparator.reverseOrder () .

Par exemple, supposons que vous ayez 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 éléments dans leur ordre "naturel", vous pouvez utiliser la méthode sort () (ou la laisser de côté et obtenir le même résultat):

items.stream()
     .sorted()
     .forEach(item -> System.out.println(item));

Ou pour les imprimer en ordre décroissant (inverse), vous pouvez utiliser la méthode triée qui prend un comparateur et inverse l’ordre:

items.stream()
     .sorted(Comparator.reverseOrder())
     .forEach(item -> System.out.println(item));

Notez que cela nécessite que la collection ait implémenté Comparable (de même que Integer, String, etc.).

0
J Woodchuck

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
Fred Denson

Je sais que c'est un fil de discussion 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 tout autre type d'objets. Dire:

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

Il n'est pas directement possible de trier de manière inverse un tableau de primitives (c'est-à-dire int[] arr = {1, 2, 3};) à l'aide de Arrays.sort() et Collections.reverseOrder(), car ces méthodes nécessitent des types de référence (Integer) au lieu de types primitifs ( int).

Cependant, nous pouvons utiliser Java 8 Stream pour commencer par trier le tableau à 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]
0
kimbaudi