Array Java Sortir menurun?


Jawaban:


330

Anda dapat menggunakan ini untuk mengurutkan semua jenis Objek

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

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

Arrays.sort()tidak dapat digunakan secara langsung untuk mengurutkan array primitif dalam urutan menurun. Jika Anda mencoba memanggil Arrays.sort()metode dengan melewati pembanding terbalik yang ditentukan oleh Collections.reverseOrder(), itu akan membuang kesalahan

tidak ditemukan metode yang cocok untuk sort (int [], pembanding)

Itu akan bekerja dengan baik dengan 'Array Objek' seperti array Integer tetapi tidak akan bekerja dengan array primitif seperti array int.

Satu-satunya cara untuk mengurutkan array primitif dalam urutan menurun adalah, pertama-tama mengurutkan array dalam urutan naik dan kemudian membalikkan array di tempat. Ini juga berlaku untuk array primitif dua dimensi.


115
Itu tidak dapat mengurutkan array primitif
Masood_mj

14
Ubah primitif Anda menjadi objek masing-masing. Integer untuk int, Double untuk double, Boolean untuk boolean, dll.
Ismael

12
jika Anda masih ingin menggunakan komparator khusus :Collections.reverseOrder(this)
Sebastian Hojas

Collections.reverseOrder () tidak mengambil parameter (kecuali saya melewatkan sesuatu?), Sebagai gantinya saya menggunakan myComparator.reversed ().
jsaven

1
Array.sort () tidak dapat digunakan secara langsung untuk mengurutkan array primitif dalam urutan menurun. Jika Anda mencoba memanggil metode Arrays.sort () dengan melewati pembanding terbalik yang didefinisikan oleh Collection.reverseOrder (), ia akan melempar kesalahan - "tidak ada metode yang cocok untuk sortir (int [], komparator <object>)" Itu akan berfungsi dengan baik dengan integer array tetapi tidak akan bekerja dengan array int. Satu-satunya cara untuk mengurutkan array primitif dalam urutan menurun adalah, pertama-tama mengurutkan array dalam urutan naik dan kemudian membalikkan array di tempat. Ini juga berlaku untuk array primitif dua dimensi.
akuriako

96

untuk daftar

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

untuk sebuah array

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

26
int [] array = {2,4,3,6,8,7}; Arrays.sort (array, Collections.reverseOrder ()); memberi saya kesalahan! Kesalahan adalah: "Metode sort (int []) pada tipe Array tidak berlaku untuk argumen (int [], Comparator <Object>)"
Dixit Singla

8
int bukan Obyek. Coba gunakan Integer [] sebagai gantinya.
Ornithopter

6
int adalah tipe utama sedangkan Integer tidak. Itu sebabnya Integer memiliki metode seperti parse, toString, dll.
Ornithopter

91

Anda bisa menggunakan ini:

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

Collections.reverseOrder()mengembalikan Comparatormenggunakan urutan alami terbalik. Anda bisa mendapatkan versi pembanding dari komparator Anda sendiri menggunakan Collections.reverseOrder(myComparator).


8
OP ingin mengurutkan array. Collections.sort()mengambil Listparameter input sebagai, bukan array.
Pascal Thivent

61

sebuah alternatif bisa jadi (untuk angka !!!)

  1. kalikan Array dengan -1
  2. menyortir
  3. kalikan sekali lagi dengan -1

Diucapkan secara harfiah:

array = -Arrays.sort(-array)

7
Metode ini sebenarnya kreatif jika kita mengurutkan angka, meskipun tidak generik dan dapat menyebabkan masalah untuk meluap ...
hackjutsu

3
Ini jawaban yang sangat bagus untuk tipe primitif. Kamu jenius.
Halil İbrahim Oymacı

2
Kecuali itu akan gagal untuk Integer.MIN_VALUE(atau mana primitif digunakan). Akan lebih baik untuk sort(), maka reverse(), tetapi Anda harus melakukan membalikkan sendiri, karena mereka tidak menambahkan Arrays.reverse()implementasi.
Andreas

1
@Halil İbrahim Oymacı: -array syntax tidak bekerja untuk saya: "bad operan type int [] untuk operator unary '-'"
Line

8
@ line Anda harus mengalikan -1 ke array. Kode di atas adalah kode semu. Anda dapat mengalikan -1 ke array dalam for loop lalu memanggil metode Array.sort (), terakhir Anda mengalikan -1 ke array lagi.
Halil İbrahim Oymacı

47

tanpa pembanding eksplisit:

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

dengan pembanding eksplisit:

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

10

Java 8:

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

Pembaruan: reversed()membalikkan pembanding yang ditentukan. Biasanya, pembanding memesan naik, jadi ini mengubah urutan ke turun.


1
Ini berfungsi sempurna dengan Objects tetapi tidak dengan primitif. Untuk mengurutkan primitif int, Anda harus mengurutkan dalam urutan ASC dan kemudian membalikkan jawabannya.
Russell Sk.

5

Untuk array yang mengandung elemen primitif jika ada, org.apache.commons.lang(3)cara mudah untuk membalikkan array (setelah mengurutkannya) adalah dengan menggunakan:

ArrayUtils.reverse(array);

1
Mengapa mengurutkannya terlebih dahulu dalam urutan naik dan kemudian menggunakan perpustakaan eksternal untuk mengembalikan urutan ini, ketika itu dapat dilakukan dalam satu langkah?
Betlista

Dan satu langkah itu?
Josip Maslac

5
Ya tapi (sebagaimana dinyatakan dalam komentar untuk jawaban itu) yang tidak berfungsi untuk primitif yang saya jawab menjawab. Tentu jawaban saya tentu bukan yang optimal tetapi saya menemukan itu untuk memenuhi kriteria "mudah" yang ditekankan oleh penulis asli - yaitu. Arrays.sort(primitives); ArrayUtils.reverse(primitives);
Josip Maslac

5

Pertama, Anda perlu mengurutkan array menggunakan:

Collections.sort(Myarray);

Maka Anda perlu membalik urutan dari naik ke turun menggunakan:

Collections.reverse(Myarray);

4

Saya tidak tahu apa itu use case Anda, namun selain jawaban lain di sini, pilihan lain (malas) adalah masih mengurutkan dalam urutan naik seperti yang Anda tunjukkan tetapi kemudian beralih dalam urutan terbalik .


4

Tidak mungkin secara langsung membalik urutan array primitif (yaitu, int[] arr = {1, 2, 3};) menggunakan Arrays.sort()dan Collections.reverseOrder()karena metode tersebut memerlukan tipe referensi ( Integer) alih-alih tipe primitif ( int).

Namun, kita bisa menggunakan Java 8 Stream untuk pertama-tama mengotak array untuk mengurutkan dalam urutan terbalik:

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

3

Solusi lain adalah bahwa jika Anda menggunakan antarmuka Sebanding Anda dapat mengganti nilai-nilai output yang telah Anda tentukan dalam compareTo Anda (Obyek bCompared).

Sebagai contoh :

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

Di mana magnitude adalah atribut dengan datatype double dalam program saya. Ini sedang mengurutkan freq kelas yang saya tentukan dalam urutan terbalik dengan besarnya. Jadi untuk memperbaikinya, Anda mengganti nilai yang dikembalikan oleh <dan >. Ini memberi Anda hal berikut:

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

Untuk memanfaatkan perbandingan ini, kami cukup memanggil Arrays.sort(mFreq)yang akan memberi Anda array yang diurutkan freq [] mFreq.

Keindahan (menurut saya) dari solusi ini adalah dapat digunakan untuk mengurutkan kelas yang ditentukan pengguna, dan bahkan lebih dari itu mengurutkan mereka berdasarkan atribut tertentu. Jika implementasi antarmuka Sebanding terdengar menakutkan bagi Anda, saya mendorong Anda untuk tidak berpikir seperti itu, sebenarnya tidak. Tautan ini tentang cara menerapkan hal yang sebanding membuat saya lebih mudah. Orang yang berharap dapat memanfaatkan solusi ini, dan bahwa kegembiraan Anda bahkan akan sebanding dengan milik saya.


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

atau

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

5
Bagaimana itu relevan dengan pertanyaan Java?
Dmitry Ginzburg

0

Saya tahu bahwa ini adalah utas yang cukup lama, tetapi ini adalah versi terbaru untuk Integer dan Java 8:

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

Perhatikan bahwa itu adalah "o1 - o2" untuk urutan naik normal (atau Comparator.comparingInt ()).

Ini juga berfungsi untuk Objek lain. Mengatakan:

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

1
Ini hanya berfungsi untuk array tipe referensi, bukan array tipe primitif.
kimbaudi

0

Ini bekerja untuk saya:

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

Keluaran:

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

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

cukup gunakan metode ini untuk mengurutkan array tipe ganda dalam urutan menurun, Anda dapat menggunakannya untuk mengurutkan array tipe lain (seperti int, float, dan lain-lain) hanya dengan mengubah "tipe pengembalian", "tipe argumen" dan tipe variabel "x" ke tipe yang sesuai. Anda juga dapat mengubah "> =" menjadi "<=" dalam kondisi if untuk membuat pesanan naik.


0

Anda bisa menggunakan operasi streaming ( Collections.stream () ) dengan Comparator.reverseOrder () .

Misalnya, Anda memiliki koleksi ini:

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

Untuk mencetak item dalam urutan "alami" Anda, Anda dapat menggunakan metode diurutkan () (atau tinggalkan dan dapatkan hasil yang sama):

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

Atau untuk mencetaknya dalam urutan menurun (mundur), Anda bisa menggunakan metode yang diurutkan yang mengambil pembanding dan membalikkan urutan:

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

Catatan ini membutuhkan koleksi untuk mengimplementasikan Sebanding (seperti halnya Integer, String, dll.).


0

Ada banyak kekacauan yang terjadi di sini - orang menyarankan solusi untuk nilai-nilai non-primitif, mencoba menerapkan beberapa pengurutan algo dari tanah, memberikan solusi yang melibatkan perpustakaan tambahan, memamerkan beberapa yang hacky dll. Jawaban untuk pertanyaan asli adalah 50 / 50. Bagi mereka yang hanya ingin menyalin / menempel:

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

arrOfObjectsadalah {6,5,4,3,2,1}sekarang. Jika Anda memiliki array sesuatu selain int - gunakan objek yang sesuai, bukan Integer.


0

Untuk diskusi di atas, berikut adalah contoh mudah untuk mengurutkan array primitif dalam urutan menurun.

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

Keluaran:

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

0

Metode sederhana untuk mengurutkan array int turun:

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

0

Cara lain dengan 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()  );

0

Ada baiknya kadang-kadang kita berlatih melalui contoh, ini contoh lengkapnya:

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

mengkompilasinya ...

javac sortdec.java

menyebutnya ...

java sortdesc

KELUARAN

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

Jika Anda ingin mencoba larik alfanumerik ...

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

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

Anda akan mendapatkan OUTPUT sebagai berikut:

50AA
20AA
10FF

sumber

Dengan menggunakan situs kami, Anda mengakui telah membaca dan memahami Kebijakan Cookie dan Kebijakan Privasi kami.
Licensed under cc by-sa 3.0 with attribution required.