Java Array Ordenar descendente?

¿Hay alguna manera FÁCIL de ordenar una matriz en orden descendente, como la forma en que tienen una ordenación en orden ascendente en la clase Arrays ?

¿O tengo que dejar de ser flojo y hacerlo yo mismo: [

Puedes usar esto para ordenar todo tipo de objetos

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

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

Arrays.sort()no se puede usar directamente para ordenar matrices primitivas en orden descendente. Si intenta llamar al Arrays.sort()método pasando Comparador inverso definido por Collections.reverseOrder(), arrojará el error

no se encontró un método adecuado para ordenar (int [], comparador)

Eso funcionará bien con 'Array of Objects' como Integer array, pero no funcionará con una matriz primitiva como int array.

La única forma de ordenar una matriz primitiva en orden descendente es, primero ordenar la matriz en orden ascendente y luego invertir la matriz en su lugar. Esto también es cierto para las matrices primitivas bidimensionales.

para una lista

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

para una matriz

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

Puedes usar esto:

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

Collections.reverseOrder()devuelve a Comparatorusando el orden natural inverso. Puede obtener una versión invertida de su propio comparador utilizando Collections.reverseOrder(myComparator).

Una alternativa podría ser (para los números !!!)

1. multiplicar la matriz por -1
2. ordenar
3. multiplicar una vez más con -1

Hablado literalmente:

array = -Arrays.sort(-array)

sin comparador explícito:

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

con comparador explícito:

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

Java 8:

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

Actualización: reversed()invierte el comparador especificado. Por lo general, los comparadores ordenan ascendente, por lo que esto cambia el orden a descendente.

Para la matriz que contiene elementos de primitivas si hay org.apache.commons.lang(3)a disposición una forma fácil de invertir la matriz (después de ordenarla) es usar:

ArrayUtils.reverse(array);

Primero necesitas ordenar tu matriz usando:

Collections.sort(Myarray);

Luego debe invertir el orden de ascendente a descendente usando:

Collections.reverse(Myarray);

No sé cuál fue su caso de uso, sin embargo, además de otras respuestas aquí, otra opción (perezosa) es ordenar en orden ascendente como lo indica, pero luego iterar en orden inverso .

No es directamente posible ordenar en reversa una matriz de primitivas (es decir, int[] arr = {1, 2, 3};) usando Arrays.sort()y Collections.reverseOrder()porque esos métodos requieren tipos de referencia ( Integer) en lugar de tipos primitivos ( int).

Sin embargo, podemos usar Java 8 Stream para encuadrar primero la matriz para ordenar en orden 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]

Otra solución es que si está utilizando la interfaz Comparable , puede cambiar los valores de salida que había especificado en su compareTo (Object bCompared).

Por ejemplo :

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

Donde magnitud es un atributo con tipo de datos doble en mi programa. Esto estaba ordenando mi frecuencia de clase definida en orden inverso por su magnitud. Entonces, para corregir eso, cambia los valores devueltos por <y >. Esto te da lo siguiente:

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

Para hacer uso de este compareTo, simplemente llamamos al Arrays.sort(mFreq)que le dará la matriz ordenada freq [] mFreq.

La belleza (en mi opinión) de esta solución es que se puede usar para ordenar las clases definidas por el usuario, e incluso más que eso, ordenarlas por un atributo específico. Si la implementación de una interfaz comparable le parece desalentadora, le animo a que no piense de esa manera, en realidad no lo es. Este enlace sobre cómo implementar comparables me facilitó mucho las cosas. Las personas que esperan pueden hacer uso de esta solución, y que su alegría será incluso comparable a la mía.

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

o

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

Sé que este es un hilo bastante antiguo, pero aquí hay una versión actualizada para Integers y Java 8:

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

Tenga en cuenta que es "o1 - o2" para el orden ascendente normal (o Comparator.comparingInt ()).

Esto también funciona para cualquier otro tipo de objetos. Decir:

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

Esto funcionó para mí:

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

Salida:

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

simplemente use este método para ordenar una matriz de tipo doble en orden descendente, puede usarla para ordenar matrices de cualquier otro tipo (como int, float, etc.) simplemente cambiando el "tipo de retorno", el "tipo de argumento" y la variable "x" tipo al tipo correspondiente. También puede cambiar "> =" a "<=" en la condición if para que el orden sea ascendente.

Puede usar operaciones de transmisión ( Collections.stream () ) con Comparator.reverseOrder () .

Por ejemplo, digamos que tiene esta colección:

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

Para imprimir los elementos en su orden "natural", puede utilizar el método sorted () (o dejarlo y obtener el mismo resultado):

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

O para imprimirlos en orden descendente (inverso), puede usar el método ordenado que toma un Comparador y revertir el orden:

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

Tenga en cuenta que esto requiere que la colección haya implementado Comparable (al igual que Integer, String, etc.).

Aquí hay un montón de problemas: las personas sugieren soluciones para valores no primitivos, intentan implementar algunos algos de clasificación desde el suelo, dan soluciones que involucran bibliotecas adicionales, muestran algunos hacky, etc. La respuesta a la pregunta original es 50 / 50. Para aquellos que solo quieren copiar / pegar:

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

arrOfObjectses {6,5,4,3,2,1}ahora Si tiene una matriz de algo distinto de ints, use el objeto correspondiente en lugar de Integer.

Para las discusiones anteriores, aquí hay un ejemplo sencillo para ordenar las matrices primitivas en orden descendente.

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

Salida:

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étodo simple para ordenar una matriz int descendente:

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

Otra forma 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()  );

Es bueno que a veces practiquemos sobre un ejemplo, aquí hay 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]);}}

compilando ...

javac sortdec.java

llamándolo ...

java sortdesc

SALIDA

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

Si quieres probar una matriz alfanumérica ...

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

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

obtendrá la SALIDA de la siguiente manera:

50AA
20AA
10FF

fuente