Сортировка массива Java по убыванию?

есть ли простой способ отсортировать массив в порядке убывания, например, как у них есть сортировка в порядке возрастания в массивы класс?

или я должен перестать лениться и сделать это сам: [

14 ответов


вы можете использовать это для сортировки всех видов объектов

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

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

Arrays.sort() нельзя использовать напрямую для сортировки примитивных массивов в порядке убывания. Если вы попытаетесь вызвать Arrays.sort() метод путем проходить обратный компаратор определенный Collection.reverseOrder() , он будет бросать ошибку

нет подходящего метода для сортировки (int[],comparator)

это будет отлично работать с целочисленным массивом, но не будет работать с массивом int.

единственный способ сортировка примитивного массива в порядке убывания, сначала сортировка массива в порядке возрастания, а затем обратный массив на месте. Это также верно для двумерных примитивных массивов.


вы можете использовать это:

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

Collections.reverseOrder() возвращает Comparator используя обратный порядок. Вы можете получить перевернутую версию собственного компаратора, используя Collections.reverseOrder(myComparator).


список

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

массива

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

без явного компаратор:

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

с явными компаратор:

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

альтернативой может быть (для цифры!!!)

  1. умножение массива на -1
  2. вроде
  3. умножьте еще раз на -1

дословно говорится:

array = -Arrays.sort(-array)

Java 8:

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

обновление: reversed() реверсирует указанный компаратор. Обычно компараторы упорядочивают по возрастанию, поэтому это изменяет порядок на нисходящий.


для массива, который содержит элементы примитивов, если есть org.apache.commons.lang(3) в распоряжении простой способ обратить массив (после его сортировки) - использовать:

ArrayUtils.reverse(array);

Я не знаю, каков был ваш вариант использования, однако в дополнение к другим ответам здесь другой (ленивый) вариант-все еще сортировать в порядке возрастания, как вы указываете, но затем повторять в реверс порядок.


сначала нужно отсортировать массив, используя:

        Collections.sort(Myarray);

затем вам нужно изменить порядок от восходящего к нисходящему, используя:

        Collections.reverse(Myarray);

еще один решение заключается в том, что если вы используете сравнима интерфейс вы можете переключать выходные значения, которые вы указали в своем compareTo (Object bCompared).

Например :

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

здесь величины является атрибутом с типом данных двойной в моей программе. Это сортировка моего определенного класса freq в обратном порядке по величине. Поэтому, чтобы исправить это, вы переключите значения, возвращаемые < и >. Это дает вам следующее :

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

чтобы использовать этот compareTo, мы просто называем Arrays.sort(mFreq), который даст вам в отсортированном массиве freq [] mFreq.

красота (на мой взгляд) этого решения заключается в том, что его можно использовать для сортировки пользовательских классов и даже более того сортировать их по определенному атрибуту. Если реализация сопоставимого интерфейса кажется вам сложной, я бы рекомендовал вам не думать, что на самом деле это не так. Это ссылка на то, как реализовать comparable сделал вещи намного легче для меня. Надеясь, что люди могут использовать это решение, и что ваша радость будет даже сравнима в шахты.


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

или

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

просто используйте этот метод для сортировки массива типа double в порядке убывания, вы можете использовать его для сортировки массивов любых других типов (например, int, float и т. д.), просто изменив "тип возврата", "тип аргумента" и переменную "x" на соответствующий тип. вы также можете изменить "> = " на "


Я знаю, что это очень старая нить, но вот обновленная версия для целых чисел и Java 8:

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

обратите внимание, что это" o1 - o2 " для нормального восходящего порядка (или компаратора.comparingInt ()).

Это также работает для любых других видов объектов. Скажи:

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

это сработало для меня:

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

выход:

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