Java Array Sort decrescente?

Respostas:

330

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.

Rifat
fonte
115
Ele não pode classificar matrizes de primitivos #
315 Masood_mj
14
Converta suas primitivas em seus respectivos objetos. Inteiro para int, Duplo para duplo, Booleano para booleano, etc.
Ishmael
12
se você ainda quiser usar seu comparador personalizado :Collections.reverseOrder(this)
Sebastian Hojas 23/10
Collections.reverseOrder () não aceita parâmetros (a menos que esteja faltando alguma coisa?); Em vez disso, usei myComparator.reversed ().
jsaven
1
Arrays.sort () não pode ser usado diretamente para classificar matrizes primitivas em ordem decrescente. Se você tentar chamar o método Arrays.sort () passando Comparator reverso definido por Collection.reverseOrder (), ele lançará o erro - "nenhum método adequado encontrado para sort (int [], comparador <object>)" funciona bem com matriz inteira, mas não funcionará com uma matriz int. 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.
akuriako
96

para uma lista

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

para uma matriz

Arrays.sort(array, Collections.reverseOrder());
Ornitóptero
fonte
26
int [] array = {2,4,3,6,8,7}; Arrays.sort (array, Collections.reverseOrder ()); está me dando um erro! O erro é: "O método sort (int []) no tipo Arrays não é aplicável aos argumentos (int [], Comparador <Object>)"
Dixit Singla
8
int não é um objeto. Tente usar o número inteiro [].
Ornithopter 10/10
6
int é um tipo primário, enquanto Inteiro não. É por isso que Integer tem métodos como análise, toString etc.
Ornithopter
91

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

William
fonte
8
O OP quer classificar uma matriz. Collections.sort()aceita um Listparâmetro como entrada, não uma matriz.
288 Pascal Thivent
61

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)
FHDougherty
fonte
7
Este método é realmente criativo, se estamos classificando números, mesmo que ele não é genérico e pode causar problemas para o estouro ...
hackjutsu
3
Esta é uma resposta muito boa para tipos primitivos. Você é um gênio.
Halil İbrahim Oymacı 27/10
2
Exceto que ele vai deixar para Integer.MIN_VALUE(ou qualquer primitiva é usado). Seria melhor sort(), então reverse(), mas você terá que fazer a inversão, já que eles não adicionaram Arrays.reverse()implementações.
Andreas
1
@Halil İbrahim Oymacı: -a sintaxe da matriz não funciona para mim: "tipo incorreto de operando int [] para operador unário '-'"
Line
8
@line Você deve usar -1 para ordenar. O código acima é pseudo-código. Você pode múltiplo -1 para matriz em um loop for e, em seguida, chame o método Array.sort (); por último, você multiplica -1 para matriz novamente.
Halil İbrahim Oymacı
47

sem comparador explícito:

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

com comparador explícito:

Collections.sort(list, Collections.reverseOrder(new Comparator()));
Milão
fonte
10

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.

Michel Jung
fonte
1
É um trabalho perfeito com objetos, mas não com primitivos. Para classificar int primitivo, você deve classificar em ordem ASC e, em seguida, inverter a resposta.
Russell Sk.
5

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);
Josip Maslac
fonte
1
Por que classificá-lo primeiro em ordem crescente e depois usar a biblioteca externa para reverter essa ordem, quando isso pode ser feito em uma etapa?
Betlista 17/04
E esse único passo?
Josip Maslac
5
Sim, mas (como indicado nos comentários a essas respostas) que não funciona para os primitivos que minha resposta aborda. É claro que minha resposta certamente não é a ideal, mas achei que ela atendia aos critérios de "fácil", enfatizados pelo autor original - ou seja. Arrays.sort(primitives); ArrayUtils.reverse(primitives);
Josip Maslac
5

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);
Masoud
fonte
4

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 .

SK9
fonte
4

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

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.

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

ou

array.sort(function(a, b) {return a - b;}); //ascending
AzFalconer
fonte
5
Como isso é relevante para a questão Java?
Dmitry Ginzburg
0

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());
sebschaef
fonte
1
Isso funciona apenas para matrizes de tipos de referência, não matrizes de tipos primitivos.
kimbaudi
0

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
Fred Denson
fonte
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;
}

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.

Seyyed Mohsen Mousavi
fonte
0

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

J Woodchuck
fonte
0

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.

bola curva
fonte
0

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
蔡宗容
fonte
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;
}
Vai
fonte
0

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

É 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

PYK
fonte