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

Ответ 1

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

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

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

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

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

Это будет хорошо работать с массивом Integer, но не будет работать с массивом int.

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

Ответ 2

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

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

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

Ответ 3

для списка

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

для массива

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

Ответ 4

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

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

Буквально говорят:

array = -Arrays.sort(-array)

Ответ 5

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

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

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

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

Ответ 6

Java 8:

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

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

Ответ 7

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

ArrayUtils.reverse(array);

Ответ 8

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

Ответ 9

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

Collections.sort(Myarray);

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

Collections.reverse(Myarray);

Ответ 10

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

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

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 кажется вам сложной, я бы посоветовал вам не думать так, на самом деле это не так. Эта ссылка о том, как реализовать сопоставимые, сделала вещи намного легче для меня. Надежные люди могут использовать это решение и что ваша радость будет даже сопоставима с моей.

Ответ 11

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

или

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

Ответ 12

Непосредственно невозможна обратная сортировка массива примитивов (т. Arrays.sort() 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]

Ответ 13

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

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

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

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

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

Ответ 14

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

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

Ответ 15

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, чтобы сделать заказ по возрастанию.

Ответ 16

Вы можете использовать потоковые операции (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 и т.д.).

Ответ 17

Здесь происходит много беспорядка - люди предлагают решения для непримитивных значений, пытаются реализовать некоторые алгоритмы сортировки с нуля, предлагают решения, включающие дополнительные библиотеки, демонстрируя некоторые хакерские и т.д. Ответ на оригинальный вопрос - 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 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.

Ответ 18

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

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

Ответ 19

Простой метод сортировки массива 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;
}