เรียง Java Array เรียงจากมากไปน้อย?

มีวิธีง่าย ๆ ในการเรียงลำดับอาร์เรย์เรียงจากมากไปน้อยเช่นวิธีที่พวกเขามีการเรียงลำดับจากน้อยไปมากในชั้นเรียนอาร์เรย์ ?

หรือฉันต้องหยุดขี้เกียจและทำสิ่งนี้ด้วยตัวเอง: [

คุณสามารถใช้สิ่งนี้เพื่อจัดเรียงวัตถุทุกชนิด

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

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

Arrays.sort()ไม่สามารถใช้โดยตรงเพื่อจัดเรียงอาร์เรย์แบบดั้งเดิมในลำดับจากมากไปน้อย ถ้าคุณพยายามเรียกใช้Arrays.sort()เมธอดด้วยการส่ง reverse Comparator ที่กำหนดโดยCollections.reverseOrder()มันจะทำให้เกิดข้อผิดพลาด

ไม่พบวิธีการที่เหมาะสมสำหรับการจัดเรียง (int [], ตัวเปรียบเทียบ)

ที่จะทำงานได้ดีกับ 'Array of Objects' เช่น Integer array แต่จะไม่ทำงานกับ array ดั้งเดิมเช่น int array

วิธีเดียวที่จะจัดเรียงอาร์เรย์แบบดั้งเดิมในลำดับจากมากไปน้อยคือก่อนอื่นให้เรียงลำดับตามลำดับจากน้อยไปหามาก นี่เป็นความจริงสำหรับอาร์เรย์สองมิติดั้งเดิม

สำหรับรายการ

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

สำหรับอาร์เรย์

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

คุณสามารถใช้สิ่งนี้:

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

Collections.reverseOrder()ส่งคืนการComparatorใช้คำสั่งตามธรรมชาติผกผัน Collections.reverseOrder(myComparator)คุณจะได้รับกลับของรุ่นเปรียบเทียบของคุณเองโดยใช้

ทางเลือกอาจเป็น (สำหรับตัวเลข !!!)

1. คูณ Array ด้วย -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());

Update: 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]

อีกวิธีคือถ้าคุณใช้อินเทอร์เฟซที่เปรียบเทียบได้คุณสามารถสลับค่าเอาต์พุตที่คุณได้ระบุไว้ใน comparTo ของคุณ (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;
}

ในการใช้การเปรียบเทียบนี้เราเพียงแค่เรียกArrays.sort(mFreq)สิ่งที่จะให้คุณเรียงลำดับfreq [] mFreqที่จะให้คุณแถวเรียง

ความงาม (ในความคิดของฉัน) ของการแก้ปัญหานี้คือมันสามารถใช้ในการเรียงลำดับชั้นเรียนที่ผู้ใช้กำหนดและยิ่งกว่านั้นเรียงลำดับตามคุณลักษณะเฉพาะ หากการใช้อินเทอร์เฟซที่เปรียบเทียบนั้นฟังดูเป็นอันตรายต่อคุณฉันขอแนะนำให้คุณไม่คิดอย่างนั้นจริง ๆ แล้วไม่ใช่ ลิงค์นี้เกี่ยวกับวิธีการใช้งานสิ่งที่เทียบเคียงได้ทำให้ฉันง่ายขึ้นมาก ผู้ที่หวังว่าจะสามารถใช้ประโยชน์จากโซลูชันนี้ได้และความสุขของคุณจะเทียบเท่ากับของฉัน

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

โปรดทราบว่ามันคือ "o1 - o2" สำหรับการเรียงลำดับปกติ (หรือ Comparator.comparingInt ())

นอกจากนี้ยังสามารถใช้ได้กับวัตถุประเภทอื่น ๆ พูด:

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 ตามลำดับจากมากไปหาน้อยคุณสามารถใช้มันเพื่อเรียงลำดับอาร์เรย์ของชนิดอื่น ๆ (เช่น int, float และอื่น ๆ ) เพียงแค่เปลี่ยน "return type", "อาร์กิวเมนต์ type" และ ตัวแปร "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");

หากต้องการพิมพ์รายการตามลำดับ "ธรรมชาติ" คุณสามารถใช้วิธีการเรียง () (หรือปล่อยให้มันออกมาและได้ผลลัพธ์เหมือนกัน):

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

หรือเพื่อพิมพ์ตามลำดับจากมากไปน้อย (ย้อนกลับ) คุณสามารถใช้วิธีการเรียงลำดับที่ใช้ตัวเปรียบเทียบและย้อนกลับลำดับ:

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

หมายเหตุสิ่งนี้ต้องการให้คอลเลกชันนั้นมีการใช้งาน Comparable (เช่น Integer, String, ฯลฯ )

มีระเบียบจำนวนมากเกิดขึ้นที่นี่ - ผู้คนแนะนำวิธีแก้ปัญหาสำหรับค่าที่ไม่ใช่แบบดั้งเดิมพยายามใช้ algos การเรียงลำดับบางอย่างจากพื้นดินให้วิธีแก้ไขปัญหาเกี่ยวกับห้องสมุดเพิ่มเติม / 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;
}

เป็นเรื่องที่ดีบางครั้งเราฝึกฝนตัวอย่างเช่นนี่คือแบบเต็ม:

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

รวบรวมมัน ...

javac sortdec.java

เรียกมันว่า ...

java sortdesc

เอาท์พุท

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

หากคุณต้องการลองอาร์เรย์ตัวอักษรและตัวเลข ...

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

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

คุณจะได้รับผลลัพธ์ดังนี้:

50AA
20AA
10FF

แหล่ง

วิธีอื่นด้วยเครื่องมือเปรียบเทียบ

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