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

Есть ли ЛЕГКИЙ способ сортировки массива в порядке убывания, например, как они сортируются в порядке возрастания в классе Arrays ?

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

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

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

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

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

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

Это будет хорошо работать с «массивом объектов», таким как массив Integer, но не будет работать с примитивным массивом, таким как массив int.

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

для списка

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

для массива

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

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

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

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

альтернатива может быть (для чисел !!!)

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

В буквальном смысле слова:

array = -Arrays.sort(-array)

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

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

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

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

Java 8:

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

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

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

ArrayUtils.reverse(array);

Сначала вам нужно отсортировать массив с помощью:

Collections.sort(Myarray);

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

Collections.reverse(Myarray);

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

Непосредственно невозможно выполнить обратную сортировку массива примитивов (то есть int[] arr = {1, 2, 3};), используя Arrays.sort()и Collections.reverseOrder()потому, что эти методы требуют ссылочных типов ( Integer) вместо примитивных типов (int ).

Однако мы можем использовать Java 8 Stream, чтобы сначала упаковать массив для сортировки в обратном порядке:

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

Другое решение заключается в том, что если вы используете Comparable интерфейс вы можете переключать выходные значения, которые вы указали в вашем 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;
}

Где величина является атрибутом с типом данных double в моей программе. Это сортировало мой определенный класс 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;
}

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

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

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

или

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

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

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

Обратите внимание, что это «o1 - o2» для обычного возрастающего порядка (или Comparator.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

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" для соответствующего типа. Вы также можете изменить "> =" на "<=" в условии if, чтобы сделать заказ по возрастанию.

Вы можете использовать потоковые операции ( Collections.stream () ) с Comparator.reverseOrder () .

Например, скажем, у вас есть эта коллекция:

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

Чтобы напечатать элементы в их «естественном» порядке, вы можете использовать метод sorted () (или опустить его и получить тот же результат):

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

Или, чтобы распечатать их в порядке убывания (в обратном порядке), вы можете использовать отсортированный метод, который принимает Comparator и обратный порядок:

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

Обратите внимание, что для этого в коллекции должен быть реализован Comparable (как и Integer, String и т. Д.).

Здесь происходит много беспорядка - люди предлагают решения для непримитивных значений, пытаются реализовать некоторые алгоритмы сортировки с нуля, предлагают решения, включающие дополнительные библиотеки, демонстрируя некоторые хакерские и т. Д. Ответ на оригинальный вопрос 50 / 50. Для тех, кто просто хочет скопировать / вставить:

// 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}настоящее время. Если у вас есть массив чего-то отличного от int - используйте соответствующий объект вместо Integer.

Для обсуждения выше, вот простой пример сортировки примитивных массивов в порядке убывания.

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

Вывод:

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

Простой метод сортировки массива int по убыванию:

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

Еще один способ с 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()  );

Хорошо, что иногда мы практикуемся на примере, вот полный пример:

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

компилируем это ...

javac sortdec.java

называя это ...

java sortdesc

ВЫВОД

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

Если вы хотите попробовать буквенно-цифровой массив ...

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

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

Вы получите ВЫХОД, как следует:

50AA
20AA
10FF

источник