Java配列の降順ソート？

Arraysクラスで昇順に並べ替える方法のように、配列を降順に並べ替える簡単な方法はありますか？

または私は怠惰になるのをやめ、これを自分でしなければなりませんか：[

これを使用して、あらゆる種類のオブジェクトをソートできます

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

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

Arrays.sort()プリミティブ配列を降順に並べ替えるために直接使用することはできません。でArrays.sort()定義された逆コンパレータを渡してメソッドを呼び出そうとするとCollections.reverseOrder()、エラーがスローされます

sort（int []、comparator）に適したメソッドが見つかりません

これは、整数配列などの「オブジェクトの配列」では正常に機能しますが、int配列などのプリミティブ配列では機能しません。

プリミティブ配列を降順で並べ替える唯一の方法は、最初に配列を昇順で並べ替え、次に配列を元の位置に逆にすることです。これは、2次元のプリミティブ配列にも当てはまります。

リスト用

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

どこ大きさは、データ型を持つ属性である二重の私のプログラムインチ これは、定義されたクラス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)、ソートされた配列を返すwhichを呼び出すだけです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);

通常の昇順（またはComparator.comparingInt（））では「o1-o2」であることに注意してください。

これは、他の種類のオブジェクトでも機能します。いう：

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型の配列を降順でソートします。これを使用して、「戻り値の型」、「引数の型」、および変数「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));

または、降順（逆順）で出力するには、コンパレータを使用して順序を逆にするソートされたメソッドを使用できます。

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

コンパレータの別の方法

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