Matrice Java Ordinamento decrescente?

Esiste un modo FACILE per ordinare un array in ordine decrescente come il modo in cui hanno un ordinamento in ordine crescente nella classe Array ?

O devo smettere di essere pigro e farlo da solo: [

Puoi usarlo per ordinare tutti i tipi di oggetti

sort(T[] a, Comparator<? super T> c) 

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

Arrays.sort()non può essere utilizzato direttamente per ordinare le matrici primitive in ordine decrescente. Se si tenta di chiamare il Arrays.sort()metodo passando il comparatore inverso definito da Collections.reverseOrder(), verrà generato l'errore

nessun metodo adatto trovato per l'ordinamento (int [], comparatore)

Funzionerà perfettamente con 'Array of Objects' come Integer array ma non funzionerà con un array primitivo come int array.

L'unico modo per ordinare un array primitivo in ordine decrescente è, prima ordinare l'array in ordine crescente e quindi invertire l'array in posizione. Ciò vale anche per le matrici primitive bidimensionali.

per un elenco

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

per un array

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

Puoi usare questo:

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

Collections.reverseOrder()ritorna a Comparatorusando l'ordine naturale inverso. Puoi ottenere una versione invertita del tuo comparatore usando Collections.reverseOrder(myComparator).

un'alternativa potrebbe essere (per i numeri !!!)

1. moltiplicare l'array per -1
2. ordinare
3. moltiplicare ancora una volta per -1

Letteralmente parlato:

array = -Arrays.sort(-array)

senza comparatore esplicito:

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

con comparatore esplicito:

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

Java 8:

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

Aggiornamento: reversed()inverte il comparatore specificato. Di solito, i comparatori ordinano in ordine crescente, quindi questo cambia l'ordine in decrescente.

Per una matrice che contiene elementi di primitive se è disponibile org.apache.commons.lang(3)un modo semplice per invertire la matrice (dopo averla ordinata) è usare:

ArrayUtils.reverse(array);

Per prima cosa devi ordinare il tuo array usando:

Collections.sort(Myarray);

Quindi è necessario invertire l'ordine da crescente a decrescente utilizzando:

Collections.reverse(Myarray);

Non so quale sia stato il tuo caso d'uso, tuttavia oltre alle altre risposte qui un'altra opzione (pigra) è quella di ordinare in ordine crescente come indicato, ma invece di scorrere invece in ordine inverso .

Non è possibile direttamente invertire un array di primitive (cioè, int[] arr = {1, 2, 3};) usando Arrays.sort()e Collections.reverseOrder()perché quei metodi richiedono tipi di riferimento ( Integer) invece di tipi primitivi ( int).

Tuttavia, possiamo usare Java 8 Stream per prima casella l'array per ordinare in ordine inverso:

// 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]

Un'altra soluzione è che se stai usando l' interfaccia Comparable puoi cambiare i valori di output che hai specificato in compareTo (Object bCompared).

Per esempio :

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

Dove magnitudo è un attributo con tipo di dati doppio nel mio programma. Questo stava ordinando la mia classe di frequenza definita in ordine inverso per grandezza. Quindi, per correggerlo, si cambiano i valori restituiti da <e >. Questo ti dà quanto segue:

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

Per utilizzare questo confronto, chiamiamo semplicemente Arrays.sort(mFreq)che ti darà l'array ordinato freq [] mFreq.

Il bello (a mio avviso) di questa soluzione è che può essere utilizzato per ordinare le classi definite dall'utente e anche più di quelle ordinarle per un attributo specifico. Se l'implementazione di un'interfaccia comparabile ti sembra scoraggiante, ti incoraggio a non pensare in quel modo, in realtà non lo è. Questo link su come implementare comparabili ha reso le cose molto più facili per me. Sperando che le persone possano avvalersi di questa soluzione e che la tua gioia sarà persino paragonabile alla mia.

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

o

array.sort(function(a, b) {return a - b;}); //ascending

So che questo è un thread piuttosto vecchio, ma ecco una versione aggiornata per Integers e Java 8:

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

Si noti che è "o1 - o2" per il normale ordine crescente (o Comparator.comparingInt ()).

Questo funziona anche con qualsiasi altro tipo di oggetto. Dire:

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

Questo ha funzionato per me:

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

Produzione:

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

usa questo metodo per ordinare una matrice di tipo double in ordine decrescente, puoi usarla per ordinare array di qualsiasi altro tipo (come int, float, ecc.) semplicemente cambiando il "tipo restituito", il "tipo argomento" e la variabile "x" digita al tipo corrispondente. puoi anche cambiare "> =" in "<=" nella condizione if per rendere l'ordine crescente.

È possibile utilizzare le operazioni di streaming ( Collections.stream () ) con Comparator.reverseOrder () .

Ad esempio, supponiamo di avere questa raccolta:

List<String> items = new ArrayList<>();
items.add("item01");
items.add("item02");
items.add("item03");
items.add("item04");
items.add("item04");

Per stampare gli articoli nel loro ordine "naturale" puoi usare il metodo sort () (o lasciarlo fuori e ottenere lo stesso risultato):

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

Oppure per stamparli in ordine decrescente (inverso), è possibile utilizzare il metodo ordinato che utilizza un comparatore e invertire l'ordine:

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

Nota che ciò richiede che la raccolta abbia implementato Comparable (come Integer, String, ecc.).

C'è un sacco di casino qui - le persone suggeriscono soluzioni per valori non primitivi, cercano di implementare alcuni algos di ordinamento da terra, offrono soluzioni che coinvolgono librerie aggiuntive, mettendo in mostra alcuni hacky ecc. La risposta alla domanda originale è 50 / 50. Per coloro che vogliono solo copiare / incollare:

// 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());

arrOfObjectsè {6,5,4,3,2,1}adesso. Se hai una matrice di qualcosa di diverso da ints, usa l' oggetto corrispondente invece di Integer.

Per le discussioni precedenti, ecco un semplice esempio per ordinare le matrici primitive in ordine decrescente.

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

Produzione:

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

Metodo semplice per ordinare un array int decrescente:

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

Un altro modo con 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()  );

Va bene a volte ci esercitiamo su un esempio, eccone uno completo:

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

compilandolo ...

javac sortdec.java

chiamandolo ...

java sortdesc

PRODUZIONE

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

Se vuoi provare un array alfanumerico ...

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

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

otterrai l'USCITA come segue:

50AA
20AA
10FF

fonte