Сортування Java-масиву за спаданням?

Чи є ЛЕГИЙ спосіб сортувати масив у порядку зменшення, як, наприклад, як вони мають сортування у порядку зростання у класі масивів ?

Або я повинен перестати лінуватися і робити це сам: [

Ви можете використовувати це для сортування всіх видів об'єктів

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]

Ще одне рішення полягає в тому, що якщо ви використовуєте інтерфейс Порівняння, ви можете перемикати вихідні значення, які ви вказали у своєму сравнениеTo (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;
}

Щоб скористатися цим порівняннямTo, ми просто зателефонуємо, Arrays.sort(mFreq)який дасть вам відсортований масив freq [] mFreq.

Краса (на мою думку) цього рішення полягає в тому, що його можна використовувати для сортування визначених користувачем класів і навіть більше, ніж їх сортування за певним атрибутом. Якщо реалізація порівнянного інтерфейсу здається вам грізною, я б закликав вас не думати таким чином, це насправді не так. Цей посилання про те, як реалізувати порівнянні , значно полегшила для мене речі. Сподіваючись, люди можуть скористатися цим рішенням, і що ваша радість буде навіть порівнянна з моєю.

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 тощо), просто змінивши "тип повернення", "тип аргументу" та тип змінної "х" на відповідний тип. ви також можете змінити "> =" на "<=" в умові 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");

Щоб надрукувати предмети в їх "природному" порядку, ви можете скористатися методом сортування () (або залишити його та отримати той самий результат):

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

Або, щоб надрукувати їх у порядку зменшення (зворотного), ви можете скористатись методом сортування, який бере компаратор та скасовує замовлення:

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

Зверніть увагу, для цього колекція має реалізовувати порівняно (як це роблять 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}зараз. Якщо у вас є масив чогось іншого, ніж ints - використовуйте відповідний об'єкт замість 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;
}

Іноді добре, що ми практикуємо приклад, ось повний:

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

джерело

Ще один спосіб із компаратором

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