Java Array sort malejąco?

Możesz użyć tego:

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

Collections.reverseOrder() zwraca Comparator używając odwrotnego porządku naturalnego. Możesz uzyskać odwróconą wersję własnego komparatora za pomocą Collections.reverseOrder(myComparator).

Dla listy

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

Dla tablicy

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

Bez wyraźnego komparatora:

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

Z jawnym porównaniem:

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

Alternatywą może być (dla liczb!!!)

1. pomnóż tablicę przez -1
2. Sortuj
3. pomnóż jeszcze raz przez -1

Dosłownie:

array = -Arrays.sort(-array)

Java 8:

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

Update: reversed() odwraca określony komparator. Zazwyczaj komparatory kolejność rosnąco, więc to zmienia kolejność malejąco.

Dla tablicy, która zawiera elementy pierwiastków, jeśli istnieje org.apache.commons.lang(3) w dyspozycji łatwy sposób odwrócenia tablicy (po jej sortowaniu) jest użycie:

ArrayUtils.reverse(array);

Nie wiem jaki był twój przypadek użycia, jednak oprócz innych odpowiedzi tutaj inną (leniwą) opcją jest nadal sortowanie w porządku rosnącym, jak wskazujesz, ale następnie iteracja w odwrotnej kolejności.

Najpierw musisz posortować tablicę używając:

        Collections.sort(Myarray);

Następnie należy odwrócić kolejność od rosnącej do malejącej za pomocą:

        Collections.reverse(Myarray);

Innym rozwiązaniem jest to, że jeśli korzystasz z interfejsuporównywalnego , możesz zmienić wartości wyjściowe, które podałeś w swoim compareTo(Object bCompared).

Na Przykład:

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

Gdziemagnitude jest atrybutem z datatypedouble w moim programie. To było sortowanie mojej zdefiniowanej klasy freq w odwrotnym porządku według jej wielkości. Aby to poprawić, Przełącz wartości zwracane przez < i >. Daje to następujące :

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

Aby skorzystać z tego porównania, po prostu wywołujemy Arrays.sort(mFreq), co da ci posortowaną tablicę freq [] mFreq.

Piękno (moim zdaniem) tego rozwiązania polega na tym, że może ono być używane do sortowania klas zdefiniowanych przez użytkownika, a nawet więcej niż sortowanie ich według określonego atrybutu. Jeśli implementacja porównywalnego interfejsu brzmi dla Ciebie zniechęcająco, zachęcam do tego, żebyś tak nie myślał, w rzeczywistości tak nie jest. ten link jak zaimplementować porównywalne ułatwiły mi życie. Mając nadzieję, że ludzie skorzystają z tego rozwiązania i że wasza radość będzie nawet porównywalna do mojej.

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

Lub

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

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

Po prostu użyj tej metody do sortowania tablicy typu double w porządku malejącym, możesz użyć jej do sortowania tablic dowolnego innego typu (jak int, float, itd.) Po prostu zmieniając typ "return type", Typ" argument type "i zmienną" X " type na odpowiedni typ. możesz również zmienić ">=" na "

Wiem, że to dość stary wątek, ale tutaj jest zaktualizowana wersja dla liczb całkowitych i Javy 8:

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

Zauważ ,że jest to "o1-o2" dla normalnego porządku rosnącego (lub komparatora.comparingInt ()).

To działa również dla innych rodzajów obiektów. Powiedz:

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

To mi pomogło:

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

Wyjście:

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