Sắp xếp mảng Java giảm dần?

Có cách nào DỄ DÀNG để sắp xếp một mảng theo thứ tự giảm dần như cách chúng sắp xếp theo thứ tự tăng dần trong lớp Mảng không?

Hoặc tôi phải ngừng lười biếng và tự làm điều này: [

Bạn có thể sử dụng điều này để sắp xếp tất cả các loại Đối tượng

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

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

Arrays.sort()không thể được sử dụng trực tiếp để sắp xếp các mảng nguyên thủy theo thứ tự giảm dần. Nếu bạn cố gắng gọi Arrays.sort()phương thức bằng cách chuyển Trình so sánh ngược được xác định bởi Collections.reverseOrder(), nó sẽ đưa ra lỗi

không tìm thấy phương pháp phù hợp để sắp xếp (int [], bộ so sánh)

Điều đó sẽ hoạt động tốt với 'Mảng đối tượng', chẳng hạn như mảng Integer nhưng sẽ không hoạt động với mảng nguyên thủy như mảng int.

Cách duy nhất để sắp xếp một mảng nguyên thủy theo thứ tự giảm dần là, đầu tiên sắp xếp mảng theo thứ tự tăng dần và sau đó đảo ngược mảng tại chỗ. Điều này cũng đúng với mảng nguyên thủy hai chiều.

cho một danh sách

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

cho một mảng

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

Bạn có thể sử dụng điều này:

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

Collections.reverseOrder()trả về một Comparatorsử dụng thứ tự tự nhiên nghịch đảo. Bạn có thể lấy phiên bản đảo ngược của bộ so sánh của riêng bạn bằng cách sử dụng Collections.reverseOrder(myComparator).

một sự thay thế có thể là (đối với số !!!)

1. nhân Mảng với -1
2. sắp xếp
3. nhân một lần nữa với -1

Nói theo nghĩa đen:

array = -Arrays.sort(-array)

không có bộ so sánh rõ ràng:

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

với bộ so sánh rõ ràng:

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

Java 8:

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

Cập nhật: reversed()đảo ngược bộ so sánh được chỉ định. Thông thường, các bộ so sánh thứ tự tăng dần, vì vậy điều này thay đổi thứ tự thành giảm dần.

Đối với mảng có chứa các phần tử nguyên thủy nếu có org.apache.commons.lang(3)cách dễ dàng để đảo ngược mảng (sau khi sắp xếp nó) là sử dụng:

ArrayUtils.reverse(array);

Trước tiên, bạn cần sắp xếp mảng của bạn bằng cách sử dụng:

Collections.sort(Myarray);

Sau đó, bạn cần đảo ngược thứ tự từ tăng dần sang giảm dần bằng cách sử dụng:

Collections.reverse(Myarray);

Tôi không biết trường hợp sử dụng của bạn là gì, tuy nhiên, ngoài các câu trả lời khác ở đây, một tùy chọn khác (lười biếng) là vẫn sắp xếp theo thứ tự tăng dần như bạn chỉ ra nhưng sau đó lặp lại theo thứ tự ngược lại .

Không thể trực tiếp đảo ngược việc sắp xếp một mảng các nguyên thủy (nghĩa là int[] arr = {1, 2, 3};) bằng cách sử dụng Arrays.sort()và Collections.reverseOrder()bởi vì các phương thức đó yêu cầu các kiểu tham chiếu ( Integer) thay vì các kiểu nguyên thủy ( int).

Tuy nhiên, chúng ta có thể sử dụng Luồng Java 8 để hộp đầu tiên sắp xếp theo thứ tự ngược lại:

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

Một giải pháp khác là nếu bạn đang sử dụng giao diện So sánh, bạn có thể chuyển đổi các giá trị đầu ra mà bạn đã chỉ định trong so sánh (Đối tượng bCompared) của bạn.

Ví dụ :

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

Trong đó cường độ là một thuộc tính với kiểu dữ liệu nhân đôi trong chương trình của tôi. Điều này đã sắp xếp freq lớp được xác định của tôi theo thứ tự ngược lại theo độ lớn của nó. Vì vậy, để sửa lỗi đó, bạn chuyển các giá trị được trả về bởi <và >. Điều này cung cấp cho bạn như sau:

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

Để sử dụng phép so sánh này, chúng tôi chỉ cần gọi Arrays.sort(mFreq)nó sẽ cung cấp cho bạn mảng đã sắp xếp freq [] mFreq.

Cái hay (theo ý kiến ​​của tôi) của giải pháp này là nó có thể được sử dụng để sắp xếp các lớp do người dùng định nghĩa và thậm chí nhiều hơn là sắp xếp chúng theo một thuộc tính cụ thể. Nếu việc triển khai giao diện so sánh nghe có vẻ khó khăn với bạn, tôi khuyến khích bạn đừng nghĩ như vậy, thực tế thì không. Liên kết này về cách thực hiện so sánh làm cho mọi thứ dễ dàng hơn nhiều đối với tôi. Những người hy vọng có thể sử dụng giải pháp này, và niềm vui của bạn thậm chí sẽ tương đương với tôi.

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

hoặc là

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

Tôi biết rằng đây là một chủ đề khá cũ, nhưng đây là phiên bản cập nhật cho Integers và Java 8:

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

Lưu ý rằng đó là "o1 - o2" cho thứ tự tăng dần bình thường (hoặc so sánh.comparedInt ()).

Điều này cũng hoạt động cho bất kỳ loại đối tượng khác. Nói:

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

Điều này làm việc cho tôi:

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

Đầu ra:

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

chỉ cần sử dụng phương thức này để sắp xếp một mảng kiểu đôi theo thứ tự giảm dần, bạn có thể sử dụng nó để sắp xếp các mảng của bất kỳ loại nào khác (như int, float, v.v.) chỉ bằng cách thay đổi "kiểu trả về", "kiểu đối số" và loại "x" biến thành loại tương ứng. bạn cũng có thể thay đổi "> =" thành "<=" trong điều kiện if để thực hiện thứ tự tăng dần.

Bạn có thể sử dụng các hoạt động luồng ( Collections.stream () ) với so sánh.reverseOrder () .

Ví dụ: giả sử bạn có bộ sưu tập này:

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

Để in các mục theo thứ tự "tự nhiên" của chúng, bạn có thể sử dụng phương thức sort () (hoặc bỏ nó ra và nhận kết quả tương tự):

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

Hoặc để in chúng theo thứ tự giảm dần (đảo ngược), bạn có thể sử dụng phương thức được sắp xếp lấy Bộ so sánh và đảo ngược thứ tự:

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

Lưu ý điều này đòi hỏi bộ sưu tập phải thực hiện So sánh (cũng như Integer, String, v.v.).

Có rất nhiều mớ hỗn độn đang diễn ra ở đây - mọi người đề xuất giải pháp cho các giá trị không nguyên thủy, cố gắng thực hiện một số thuật toán sắp xếp từ mặt đất, đưa ra các giải pháp liên quan đến các thư viện bổ sung, hiển thị một số hacky, v.v. Câu trả lời cho câu hỏi ban đầu là 50 / 50. Đối với những người chỉ muốn sao chép / dán:

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

arrOfObjectslà {6,5,4,3,2,1}bây giờ. Nếu bạn có một mảng của một cái gì đó ngoài ints - sử dụng đối tượng tương ứng thay vì Integer.

Đối với các cuộc thảo luận ở trên, đây là một ví dụ dễ dàng để sắp xếp các mảng nguyên thủy theo thứ tự giảm dần.

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

Đầu ra:

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

Phương pháp đơn giản để sắp xếp một mảng int giảm dần:

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

Một cách khác với So sánh

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