Java Array Sort decrescente?

Existe alguma maneira FÁCIL de classificar uma matriz em ordem decrescente, como a classificação em ordem crescente na classe Arrays ?

Ou tenho que parar de ser preguiçoso e fazer isso sozinho: [

Você pode usar isso para classificar todos os tipos de objetos

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

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

Arrays.sort()não pode ser usado diretamente para classificar matrizes primitivas em ordem decrescente. Se você tentar chamar o Arrays.sort()método passando o comparador reverso definido por Collections.reverseOrder(), ele lançará o erro

nenhum método adequado encontrado para classificação (int [], comparador)

Isso funcionará bem com 'Matriz de objetos', como matriz inteira, mas não funcionará com uma matriz primitiva, como int array.

A única maneira de classificar uma matriz primitiva em ordem decrescente é, primeiro classifique a matriz em ordem crescente e depois inverta a matriz no lugar. Isso também é válido para matrizes primitivas bidimensionais.

para uma lista

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

para uma matriz

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

Você pode usar isto:

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

Collections.reverseOrder()retorna a Comparatorusando a ordem natural inversa. Você pode obter uma versão invertida do seu próprio comparador usando Collections.reverseOrder(myComparator).

uma alternativa poderia ser (para números !!!)

1. multiplique a matriz por -1
2. ordenar
3. multiplique mais uma vez com -1

Literalmente falado:

array = -Arrays.sort(-array)

sem comparador explícito:

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

com comparador explícito:

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

Java 8:

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

Atualização: reversed()inverte o comparador especificado. Geralmente, os comparadores ordenam em ordem crescente, então isso altera a ordem para decrescente.

Para a matriz que contém elementos de primitivas, se houver org.apache.commons.lang(3)uma maneira fácil de reverter a matriz (após a classificação), use:

ArrayUtils.reverse(array);

Primeiro você precisa classificar sua matriz usando:

Collections.sort(Myarray);

Em seguida, você precisa reverter a ordem de ascendente para descendente usando:

Collections.reverse(Myarray);

Não sei qual era o seu caso de uso, no entanto, além de outras respostas aqui, outra opção (lenta) ainda é classificar em ordem crescente, conforme indicado, mas iterar na ordem inversa .

Não é diretamente possível reverter a classificação de uma matriz de primitivas (isto é, int[] arr = {1, 2, 3};) usando Arrays.sort()e Collections.reverseOrder()porque esses métodos requerem tipos de referência ( Integer) em vez de tipos primitivos ( int).

No entanto, podemos usar o Java 8 Stream para colocar primeiro a matriz em ordem inversa:

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

Outra solução é que, se você estiver usando a interface Comparable , poderá alterar os valores de saída especificados em compareTo (Object bCompared).

Por exemplo :

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

Onde magnitude é um atributo com o tipo de dados duplo no meu programa. Isso estava classificando minha freq de classe definida em ordem inversa por sua magnitude. Portanto, para corrigir isso, você alterna os valores retornados por <e >. Isso fornece o seguinte:

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 fazer uso deste compareTo, simplesmente chamamos o Arrays.sort(mFreq)que fornecerá a matriz classificada freq [] mFreq.

A beleza (na minha opinião) dessa solução é que ela pode ser usada para classificar classes definidas pelo usuário e, mais do que isso, classificá-las por um atributo específico. Se a implementação de uma interface comparável lhe parecer assustadora, encorajo você a não pensar dessa maneira, na verdade não é. Este link sobre como implementar comparáveis tornou as coisas muito mais fáceis para mim. As pessoas que esperam podem fazer uso dessa solução e que sua alegria será comparável à minha.

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

ou

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

Eu sei que este é um segmento bastante antigo, mas aqui está uma versão atualizada para Inteiros e Java 8:

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

Observe que é "o1 - o2" para a ordem crescente normal (ou Comparator.comparingInt ()).

Isso também funciona para quaisquer outros tipos de objetos. Dizer:

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

Isso funcionou para mim:

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

Resultado:

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

basta usar esse método para classificar uma matriz do tipo double em ordem decrescente, você pode usá-lo para classificar matrizes de outros tipos (como int, float e etc) apenas alterando o "tipo de retorno", o "tipo de argumento" e a variável "x" tipo para o tipo correspondente. você também pode alterar "> =" para "<=" na condição if para tornar a ordem crescente.

Você pode usar operações de fluxo ( Collections.stream () ) com Comparator.reverseOrder () .

Por exemplo, digamos que você tenha esta coleção:

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

Para imprimir os itens na ordem "natural", você pode usar o método Sorted () (ou deixar de fora e obter o mesmo resultado):

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

Ou, para imprimi-los em ordem decrescente (reversa), você pode usar o método classificado que utiliza um Comparador e inverte a ordem:

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

Observe que isso requer que a coleção tenha implementado Comparable (como Integer, String, etc.).

Há muita confusão acontecendo aqui - as pessoas sugerem soluções para valores não primitivos, tentam implementar alguns algos de classificação desde o início, fornecem soluções que envolvem bibliotecas adicionais, exibem algumas hacky etc. A resposta para a pergunta original é 50 / 50 Para quem quer apenas copiar / colar:

// 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}agora. Se você tiver uma matriz de algo diferente de ints - use o objeto correspondente em vez de Integer.

Para as discussões acima, aqui está um exemplo fácil de classificar as matrizes primitivas em ordem 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]);
        }
    }
}

Resultado:

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 simples para classificar uma 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;
}

Outra maneira com o 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()  );

É bom, às vezes, praticarmos um exemplo, aqui está um 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

chamando isso ...

java sortdesc

RESULTADO

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

Se você quiser experimentar uma matriz alfanumérica ...

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

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

você receberá a SAÍDA da seguinte forma:

50AA
20AA
10FF

fonte