Сортировка массивов примитивных типов в порядке убывания

Java Primitive включает функции для сортировки примитивных 9X_sorting-algorithm массивов на основе настраиваемого компаратора. Используя 9X_sort его и Java 8, ваш образец может быть записан 9X_sort как:

double[] array = new double[1048576]; ... Primitive.sort(array, (d1, d2) -> Double.compare(d2, d1), false); 

Если вы используете Maven, вы можете 9X_sorting-algorithm включить его с помощью:

 net.mintern primitive 1.2.1 

Когда вы передаете 9X_java-se false в качестве третьего аргумента для sort, он 9X_oraclejdk использует нестабильную сортировку, простое 9X_core-java редактирование встроенного в Java dual-pivot quicksort. Это 9X_j2se означает, что скорость должна быть близка 9X_java-libraries к скорости встроенной сортировки.

Полное 9X_jre раскрытие: я написал библиотеку Java Primitive.

Вот однострочный, с использованием потоков 9X_core-java в Java 8

int arr = new int[]{1,2,3,4,5}; Arrays.stream(arr).boxed().sorted(Collections.reverseOrder()).mapToInt(Integer::intValue).toArray(); 

Guava имеет методы для преобразования примитивных 9X_array-sorting массивов в списки типов оболочек. Приятно 9X_openjdk то, что эти списки представляют собой живые 9X_sorted представления, поэтому операции с ними работают 9X_core-java и с базовыми массивами (аналогично Arrays.asList(), но 9X_core-java для примитивов).

В любом случае каждый из 9X_sort этих списков можно передать в Collections.reverse():

int[] intArr = { 1, 2, 3, 4, 5 }; float[] floatArr = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f }; double[] doubleArr = { 1.0d, 2.0d, 3.0d, 4.0d, 5.0d }; byte[] byteArr = { 1, 2, 3, 4, 5 }; short[] shortArr = { 1, 2, 3, 4, 5 }; Collections.reverse(Ints.asList(intArr)); Collections.reverse(Floats.asList(floatArr)); Collections.reverse(Doubles.asList(doubleArr)); Collections.reverse(Bytes.asList(byteArr)); Collections.reverse(Shorts.asList(shortArr)); System.out.println(Arrays.toString(intArr)); System.out.println(Arrays.toString(floatArr)); System.out.println(Arrays.toString(doubleArr)); System.out.println(Arrays.toString(byteArr)); System.out.println(Arrays.toString(shortArr)); 

Вывод:

[5, 4, 3, 2, 1]
[5.0, 4.0, 3.0, 2.0, 1.0]
[5.0, 4.0, 3.0, 2.0, 1.0]
[5, 4, 3, 2, 1]
[5, 4, 3, 2, 1]

Ваша реализация (та, о которой идет речь) быстрее, чем, например, упаковка 9X_sorting с помощью toList() и использование метода на основе 9X_java компаратора. Автоматическая упаковка и запуск 9X_java методов компаратора или обернутых объектов 9X_jdk коллекций намного медленнее, чем просто 9X_array-sorting реверсирование.

Конечно, вы можете написать 9X_date-sorting свою сортировку. Возможно, это не тот ответ, который 9X_core-java вы ищете, но обратите внимание, что если ваш 9X_array-sorting комментарий о том, что «массив уже отсортирован 9X_j2se достаточно хорошо» случается часто, вы можете 9X_java-api выбрать алгоритм сортировки, который обрабатывает 9X_oraclejdk в этом случае хорошо (например, вставка), а 9X_sorting не использовать Arrays.sort() (который является сортировкой 9X_array-sorting слиянием или вставкой, если количество элементов 9X_jdk невелико).

Вы не можете использовать компараторы для 9X_jre сортировки примитивных массивов.

Лучше всего 9X_core-java реализовать (или позаимствовать реализацию) алгоритма 9X_sorted сортировки, который является appropriate для вашего 9X_java-se варианта использования для сортировки массива 9X_java-api (в обратном порядке в вашем случае).

Я думаю, что самым простым решением остается:

1. Получение естественного порядка массива
2. Нахождение максимума в отсортированном массиве, который затем является последним элементом.
3. Использование цикла for с оператором декремента

Как 9X_oraclejdk уже говорили другие: использование toList 9X_openjdk требует дополнительных усилий, Arrays.sort 9X_sorted (array, Collections.reverseOrder()) не работает 9X_date-sorting с примитивами, и использование дополнительной 9X_core-java структуры кажется слишком сложным, когда 9X_.java все, что вам нужно, уже встроено и, следовательно, наверное, и 9X_core-java быстрее ...

Пример кода:

import java.util.Arrays; public class SimpleDescending { public static void main(String[] args) { // unsorted array int[] integerList = {55, 44, 33, 88, 99}; // Getting the natural (ascending) order of the array Arrays.sort(integerList); // Getting the last item of the now sorted array (which represents the maximum, in other words: highest number) int max = integerList.length-1; // reversing the order with a simple for-loop System.out.println("Array in descending order:"); for(int i=max; i>=0; i--) { System.out.println(integerList[i]); } // You could make the code even shorter skipping the variable max and use // "int i=integerList.length-1" instead of int "i=max" in the parentheses of the for-loop } } 

Before sorting the given array multiply each element by -1 
затем используйте Arrays.sort (arr), затем 9X_java снова умножьте каждый элемент на -1

for(int i=0;i

В других ответах была некоторая путаница 9X_sorting по поводу Arrays.asList. Если вы скажете

double[] arr = new double[]{6.0, 5.0, 11.0, 7.0}; List xs = Arrays.asList(arr); System.out.println(xs.size()); // prints 1 

тогда у вас будет 9X_.java список с 1 элементом. Результирующий список 9X_sorting-algorithm имеет массив double [] в качестве собственного 9X_.java элемента. Вам нужно иметь List, элементы которого 9X_java-api являются элементами double[].

К сожалению, никакое 9X_array-sorting решение с использованием компараторов не 9X_.java будет работать для примитивного массива. Arrays.sort принимает 9X_array-sorting компаратор только при передаче Object[]. И по причинам, описанным 9X_j2se выше, Arrays.asList не позволит вам создать список из 9X_.java элементов вашего массива.

Итак, несмотря 9X_java на мой предыдущий ответ, на который ссылаются 9X_array-sorting комментарии ниже, нет лучшего способа, чем 9X_sort вручную изменить массив после сортировки. Любой 9X_sorting-algorithm другой подход (например, копирование элементов 9X_openjdk в Double[] и обратная сортировка и копирование их 9X_java обратно) потребует больше кода и будет медленнее.

Если производительность важна, а список 9X_sorting обычно уже отсортирован достаточно хорошо.

Пузырьковая 9X_sort сортировка должна быть одним из самых медленных 9X_j2se способов сортировки, но я видел случаи, когда 9X_date-sorting наилучшей производительностью была простая 9X_.java двунаправленная пузырьковая сортировка.

Так 9X_core-java что это может быть один из немногих случаев, когда 9X_j2se вы можете извлечь выгоду из написания кода 9X_java-api самостоятельно. Но вам действительно нужно 9X_sorting-algorithm сделать это правильно (убедитесь, что хотя 9X_sorting-algorithm бы кто-то еще подтвердил ваш код, докажите, что 9X_sorting-algorithm он работает и т. Д.)

Как заметил кто-то другой, может 9X_sort быть даже лучше начать с отсортированного 9X_array-sorting массива и сохранять его отсортированным, пока 9X_sorting вы меняете содержимое. Это может работать 9X_javax даже лучше.

Для числовых типов отрицание элементов до 9X_sorted и после сортировки кажется вариантом. Скорость 9X_javax относительно одиночного реверса после сортировки 9X_sorted зависит от кеша, и если обратный ход не 9X_java-se быстрее, любая разница вполне может быть 9X_sort потеряна из-за шума.