Tri de tableau Java décroissant?

Existe-t-il un moyen FACILE de trier un tableau par ordre décroissant comme la façon dont ils ont un tri par ordre croissant dans la classe Arrays ?

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

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 utilisé directement pour trier les tableaux primitifs dans l'ordre décroissant. Si vous essayez d'appeler la Arrays.sort()méthode en passant le Comparateur inversé défini par Collections.reverseOrder(), cela générera l'erreur

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

Cela fonctionnera très bien avec 'Array of Objects' comme le tableau Integer mais ne fonctionnera pas avec un tableau primitif tel que int array.

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

pour une liste

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

pour un tableau

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

Vous pouvez utiliser ceci:

    Arrays.sort(data, Collections.reverseOrder());

Collections.reverseOrder()renvoie un en Comparatorutilisant l'ordre naturel inverse. Vous pouvez obtenir une version inversée de votre propre comparateur en utilisant Collections.reverseOrder(myComparator).

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

1. multipliez le tableau par -1
2. Trier
3. multipliez à nouveau avec -1

Littéralement parlé:

array = -Arrays.sort(-array)

sans comparateur explicite:

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

avec comparateur explicite:

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

Java 8:

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

Mettre à jour: reversed()inverse le comparateur spécifié. Habituellement, les comparateurs ordonnent en ordre croissant, ce qui modifie l'ordre en ordre décroissant.

Pour un tableau qui contient des éléments de primitives s'il existe org.apache.commons.lang(3)un moyen simple d'inverser un tableau (après l'avoir trié), il faut utiliser:

ArrayUtils.reverse(array);

Vous devez d'abord trier votre tableau en utilisant:

Collections.sort(Myarray);

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

Collections.reverse(Myarray);

Je ne sais pas quel était votre cas d'utilisation, mais en plus des autres réponses ici, une autre option (paresseuse) consiste à toujours trier dans l'ordre croissant comme vous l'indiquez, mais à répéter à la place dans l' ordre inverse .

Il n'est pas directement possible d'inverser le tri d'un tableau de primitives (c'est-à-dire 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 de types primitifs (int ).

Cependant, nous pouvons utiliser Java 8 Stream pour d'abord encadrer le 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]

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 (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 fréquence de classe définie dans l'ordre inverse par sa magnitude. Donc, pour corriger cela, vous changez les valeurs renvoyées par le <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 encore plus que 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 des choses comparables m'a beaucoup facilité la tâche. En espérant que les personnes puissent utiliser 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

Je sais que c'est un fil 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 tous les autres types d'objets. Dire:

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);
        }
    }
}

Production:

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;
}

utilisez simplement cette méthode pour trier un tableau de type double dans l'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" type au type correspondant. vous pouvez également changer "> =" en "<=" dans la condition if pour rendre l'ordre croissant.

Vous pouvez utiliser des opérations de flux ( 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 sorted () (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 dans l'ordre décroissant (inverse), vous pouvez utiliser la méthode 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 que la collection ait implémenté Comparable (tout comme Integer, String, etc.).

Il y a beaucoup de gâchis ici - les gens suggèrent des solutions pour les valeurs non primitives, essayent d'implémenter des algues de tri à partir du sol, donnent des solutions impliquant des bibliothèques supplémentaires, en montrant certaines hacky etc. La réponse à la question d'origine est 50 / 50. Pour ceux qui veulent juste copier / coller:

// our initial int[] array containing primitives
int[] arrOfPrimitives = new int[]{1,2,3,4,5,6};

// we have to convert it into array of Objects, using java's boxing
Integer[] arrOfObjects = new Integer[arrOfPrimitives.length];
for (int i = 0; i < arrOfPrimitives.length; i++) 
    arrOfObjects[i] = new Integer(arrOfPrimitives[i]);

// now when we have an array of Objects we can use that nice built-in method
Arrays.sort(arrOfObjects, Collections.reverseOrder());

arrOfObjectsest {6,5,4,3,2,1}maintenant. Si vous avez un tableau autre que ints - utilisez l' objet correspondant à la place de Integer.

Pour les discussions ci-dessus, voici un exemple simple pour trier les tableaux primitifs dans l'ordre décroissant.

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] nums = { 5, 4, 1, 2, 9, 7, 3, 8, 6, 0 };
        Arrays.sort(nums);

        // reverse the array, just like dumping the array!
        // swap(1st, 1st-last) <= 1st: 0, 1st-last: nums.length - 1
        // swap(2nd, 2nd-last) <= 2nd: i++,  2nd-last: j--
        // swap(3rd, 3rd-last) <= 3rd: i++,  3rd-last: j--
        //
        for (int i = 0, j = nums.length - 1, tmp; i < j; i++, j--) {
            tmp = nums[i];
            nums[i] = nums[j];
            nums[j] = tmp;
        }

        // dump the array (for Java 4/5/6/7/8/9)
        for (int i = 0; i < nums.length; i++) {
            System.out.println("nums[" + i + "] = " + nums[i]);
        }
    }
}

Production:

nums[0] = 9
nums[1] = 8
nums[2] = 7
nums[3] = 6
nums[4] = 5
nums[5] = 4
nums[6] = 3
nums[7] = 2
nums[8] = 1
nums[9] = 0

Méthode simple pour trier un tableau int décroissant:

private static int[] descendingArray(int[] array) {
    Arrays.sort(array);
    int[] descArray = new int[array.length];
    for(int i=0; i<array.length; i++) {
        descArray[i] = array[(array.length-1)-i];
    }
    return descArray;
}

Une autre façon avec Comparator

import java.util.Arrays;
import java.util.Comparator;
...

Integer[] aInt = {6,2,3,4,1,5,7,8,9,10};
Arrays.sort(aInt, Comparator.reverseOrder()  );

C'est bien parfois on s'entraine sur un exemple, en voici un plein:

sortdesc.java

import java.util.Arrays;
import java.util.Collections;
class sortdesc{
public static void main(String[] args){
       // int Array
       Integer[] intArray=new Integer[]{
                 new Integer(15),
                 new Integer(9),
                 new Integer(16),
                 new Integer(2),
                 new Integer(30)};

       // Sorting int Array in descending order
       Arrays.sort(intArray,Collections.reverseOrder());

       // Displaying elements of int Array
       System.out.println("Int Array Elements in reverse order:");
       for(int i=0;i<intArray.length;i++)
          System.out.println(intArray[i]);

       // String Array
       String[] stringArray=new String[]{"FF","PP","AA","OO","DD"};

       // Sorting String Array in descending order
       Arrays.sort(stringArray,Collections.reverseOrder());

       // Displaying elements of String Array
       System.out.println("String Array Elements in reverse order:");
       for(int i=0;i<stringArray.length;i++)
          System.out.println(stringArray[i]);}}

le compiler ...

javac sortdec.java

l'appeler ...

java sortdesc

PRODUCTION

Int Array Elements in reverse order:
30
16
15
9
2
String Array Elements in reverse order:
PP
OO
FF
DD
AA

Si vous voulez essayer un tableau alphanumérique ...

//replace this line:
String[] stringArray=new String[]{"FF","PP","AA","OO","DD"};

//with this:
String[] stringArray=new String[]{"10FF","20AA","50AA"};

tu vas obtenir la SORTIE comme suit:

50AA
20AA
10FF

la source