자바 배열 정렬 내림차순?

Arrays 클래스 에서 오름차순으로 정렬하는 방법과 같이 내림차순으로 배열을 정렬하는 쉬운 방법이 있습니까? 있습니까?

아니면 게으르지 말고 스스로해야합니다. [

이것을 사용하여 모든 종류의 객체를 정렬 할 수 있습니다

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

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

Arrays.sort()기본 배열을 내림차순으로 정렬하는 데 직접 사용할 수 없습니다. 에 Arrays.sort()의해 정의 된 역 비교기를 전달 하여 메소드 를 호출하려고 Collections.reverseOrder()하면 오류가 발생합니다.

sort (int [], comparator)에 적합한 메소드가 없습니다.

Integer 배열과 같은 'Array of Objects'에서는 제대로 작동하지만 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()));

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

여기서 강도 는 내 프로그램에서 데이터 유형이 double 인 속성입니다 . 이것은 정의 된 클래스 freq 를 크기별로 역순 으로 정렬 했습니다. 이를 정정하기 위해 <and에서 리턴 한 값을 전환하십시오 >. 이것은 당신에게 다음을 제공합니다 :

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)정렬 된 배열을 제공하는 호출 합니다.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 유형의 배열을 내림차순으로 정렬하고, "return type", "argument type"및 변수 "x"유형을 해당 유형으로 if 조건에서 주문을 오름차순으로 만들기 위해 "> ="를 "<="로 변경할 수도 있습니다.

Comparator.reverseOrder () 와 함께 스트림 작업 ( Collections.stream () )을 사용할 수 있습니다 .

예를 들어이 컬렉션이 있다고 가정 해 봅시다.

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

또는 내림차순 (역순)으로 인쇄하려면 Comparator를 사용하여 순서를 반대로하는 정렬 된 방법을 사용할 수 있습니다 .

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

이를 위해서는 컬렉션에 Comparable을 구현해야합니다 (정수, 문자열 등).

여기에는 많은 혼란이 있습니다-사람들은 기본이 아닌 값에 대한 솔루션을 제안하고, 지상에서 정렬 알고리즘을 구현하려고 시도하고, 추가 라이브러리가 포함 된 솔루션을 제공하고, 해킹 된 것을 보여줍니다. 원래 질문에 대한 대답은 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}지금. int 이외의 배열이있는 경우 대신 해당 객체 를 사용하십시오 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()  );