Array Java Sortir menurun?

Apakah ada cara MUDAH untuk mengurutkan array dalam urutan menurun seperti bagaimana mereka memiliki semacam dalam urutan naik di kelas Array ?

Atau apakah saya harus berhenti menjadi malas dan melakukan ini sendiri: [

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.

untuk daftar

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

untuk sebuah array

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

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).

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)

tanpa pembanding eksplisit:

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

dengan pembanding eksplisit:

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

Java 8:

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

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

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

Pertama, Anda perlu mengurutkan array menggunakan:

Collections.sort(Myarray);

Maka Anda perlu membalik urutan dari naik ke turun menggunakan:

Collections.reverse(Myarray);

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 .

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]

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.

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

atau

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

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

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

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.

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.).

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.

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

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

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

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