Java Array Ordenar descendente?

Respuestas:

330

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.

Rifat
fuente
115
No puede ordenar matrices de primitivas
Masood_mj
14
Convierte tus primitivas en sus respectivos objetos. Entero para int, doble para doble, booleano para booleano, etc.
Ismael
12
si aún quieres usar tu comparador personalizado :Collections.reverseOrder(this)
Sebastian Hojas
Collections.reverseOrder () no toma parámetros (a menos que me falte algo?), En su lugar utilicé myComparator.reversed ().
jsaven
1
Arrays.sort () no se puede usar directamente para ordenar matrices primitivas en orden descendente. Si intenta llamar al método Arrays.sort () pasando el Comparador inverso definido por Collection.reverseOrder (), arrojará el error: "no se encontró ningún método adecuado para sort (int [], comparator <object>)" Eso funciona bien con la matriz Integer pero no funcionará con una matriz int. 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.
akuriako
96

para una lista

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

para una matriz

Arrays.sort(array, Collections.reverseOrder());
Ornitóptero
fuente
26
int [] array = {2,4,3,6,8,7}; Arrays.sort (array, Collections.reverseOrder ()); me está dando un error! El error es: "El método sort (int []) en el tipo Arrays no es aplicable para los argumentos (int [], Comparator <Object>)"
Dixit Singla
8
int no es un objeto. Intente usar Integer [] en su lugar.
Ornithopter
66
int es un tipo primario mientras que Integer no lo es. Es por eso que Integer tiene métodos como parse, toString, etc.
Ornithopter
91

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

Guillermo
fuente
8
El OP quiere ordenar una matriz. Collections.sort()toma un Listparámetro de entrada, no una matriz.
Pascal Thivent
61

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)
FHDougherty
fuente
77
Este método es realmente creativo si estamos ordenando números, a pesar de que no es genérico y podría causar problemas de desbordamiento ...
hackjutsu
3
Esta es una muy buena respuesta para los tipos primitivos. Eres un genio.
Halil İbrahim Oymacı
2
Excepto que va a fallar por Integer.MIN_VALUE(o cualquier primitiva se utiliza). Sería mejor sort(), entonces reverse(), pero tendrás que hacer la inversión tú mismo, ya que no agregaron Arrays.reverse()implementaciones.
Andreas
1
@Halil İbrahim Oymacı: la sintaxis de matriz no funciona para mí: "tipo de operando incorrecto int [] para operador unario '-'"
Línea del
8
@line Debe multiplicar -1 a la matriz. El código anterior es pseudocódigo. Puede multiplicar -1 a la matriz en un bucle for y luego llamar al método Array.sort (), por último, multiplicar -1 a la matriz nuevamente.
Halil İbrahim Oymacı
47

sin comparador explícito:

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

con comparador explícito:

Collections.sort(list, Collections.reverseOrder(new Comparator()));
Milán
fuente
10

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.

Michel Jung
fuente
1
Funciona perfectamente con objetos pero no con primitivas. Para sort primitive int, debe ordenar en orden ASC y luego invertir la respuesta.
Russell Sk.
5

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);
Josip Maslac
fuente
1
¿Por qué ordenarlo primero en orden ascendente y luego usar una biblioteca externa para revertir este orden, cuando se puede hacer en un solo paso?
Betlista
¿Y ese ser un paso?
Josip Maslac
55
Sí, pero (como se indica en los comentarios a esas respuestas) eso no funciona para las primitivas que mi respuesta aborda. Por supuesto, mi respuesta ciertamente no es la óptima, pero encontré que cumple con los criterios de ser "fácil" que el autor original enfatizó, es decir. Arrays.sort(primitives); ArrayUtils.reverse(primitives);
Josip Maslac
5

Primero necesitas ordenar tu matriz usando:

Collections.sort(Myarray);

Luego debe invertir el orden de ascendente a descendente usando:

Collections.reverse(Myarray);
Masoud
fuente
4

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 .

SK9
fuente
4

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]
kimbaudi
fuente
3

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.

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

o

array.sort(function(a, b) {return a - b;}); //ascending
AzFalconer
fuente
55
¿Cómo es eso relevante para la pregunta de Java?
Dmitry Ginzburg
0

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());
sebschaef
fuente
1
Esto solo funciona para matrices de tipos de referencia, no para matrices de tipos primitivos.
kimbaudi
0

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
Fred Denson
fuente
0
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.

Seyyed Mohsen Mousavi
fuente
0

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

J Woodchuck
fuente
0

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.

bola curva
fuente
0

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
蔡宗容
fuente
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;
}
Será
fuente
0

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()  );
zemiak
fuente
0

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

PYK
fuente