자바 어레이 정렬 내림차순?
어레이 클래스에서 어레이를 오름차순으로 정렬하는 것처럼 어레이를 내림차순으로 정렬하는 쉬운 방법이 있습니까?
아니면 게으름을 그만 피우고 직접 해야 하나요?
이를 사용하여 모든 종류의 개체를 정렬할 수 있습니다.
sort(T[] a, Comparator<? super T> c)
Arrays.sort(a, Collections.reverseOrder());
Arrays.sort()원시 배열을 내림차순으로 정렬하는 데 직접 사용할 수 없습니다.를 Arrays.sort()역방향 비교기를 전달하여 방법을 정의합니다.Collections.reverseOrder()하게 됩니다.
정렬에 적합한 메서드를 찾을 수 없습니다(int[ , ).
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을 다시 곱하다
문자 그대로:
array = -Arrays.sort(-array)
명시적 비교기 없음:
Collections.sort(list, Collections.reverseOrder());
명시적 비교기 사용:
Collections.sort(list, Collections.reverseOrder(new Comparator()));
원형을 으로 정렬할 수 원형을 할 수 없습니다).int[] arr = {1, 2, 3};를 사용하여 를 참조해 주세요.Arrays.sort() ★★★★★★★★★★★★★★★★★」Collections.reverseOrder() 타입이 입니다(참조 타입Integer type )이 아닌 ( )입니다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]
먼저 다음을 사용하여 어레이를 정렬해야 합니다.
Collections.sort(myArray);
그런 다음 다음 다음 명령을 사용하여 순서를 오름차순에서 내림차순으로 변경해야 합니다.
Collections.reverse(myArray);
Java 8:
Arrays.sort(list, comparator.reversed());
데트트 update:reversed()는 지정된 대조군을 반전시킵니다.보통 대조군은 오름차순을 지정하므로 순서가 내림차순으로 변경됩니다.
다음과 같은 경우 기본 요소를 포함하는 배열의 경우org.apache.commons.lang(3)정렬 후)는 쉽게 할 수 있습니다 (정렬 후)
ArrayUtils.reverse(array);
어떤 사용 사례를 사용했는지 모르지만, 여기의 다른 답변과 더불어, 다른 (느긋한) 옵션은 사용자가 지정한 대로 오름차순으로 정렬한 다음 역순으로 반복하는 것입니다.
위에서 설명한 바와 같이 원시 배열을 내림차순으로 정렬하는 간단한 예를 다음에 제시하겠습니다.
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
배열이 Integer 클래스의 유형인 경우 다음을 사용할 수 있습니다.
Integer[] arr = {7, 10, 4, 3, 20, 15};
Arrays.sort(arr, Collections.reverseOrder());
배열이 int 데이터 유형의 경우 다음을 사용할 수 있습니다.
int[] arr = {7, 10, 4, 3, 20, 15};
int[] reverseArr = IntStream.rangeClosed(1, arr.length).map(i -> arr[arr.length-i]).toArray();
또 다른 해결책은 Comparable 인터페이스를 사용하는 경우 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;
}
여기서 magnitude는 프로그램에서 데이터 유형이 이중인 속성입니다.이것은 내가 정의한 등급의 크기를 기준으로 역순으로 정렬하는 것이었다.이를 수정하기 위해 에 의해 반환된 값을 바꿉니다.< ★★★★★★★★★★★★★★★★★」> 다음과 같은
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.
이 솔루션의 장점은 사용자 정의 클래스를 정렬하는 데 사용할 수 있고, 그 이상의 속성을 기준으로 정렬할 수 있다는 것입니다.Comparable Interface의 구현이 부담스럽게 느껴진다면 그렇게 생각하지 마십시오.실제로 그렇지 않습니다.비교 가능한 구현 방법에 대한 링크를 통해 저는 훨씬 더 쉽게 작업을 수행할 수 있었습니다.사람들이 이 해결책을 활용하길 바라며, 당신의 기쁨이 나와 비슷해지길 바랍니다.
2D 어레이를 내림차순으로 정렬하려면 파라미터의 위치를 뒤집기만 하면 됩니다.
int[][] array= {
{1, 5},
{13, 1},
{12, 100},
{12, 85}
};
Arrays.sort(array, (a, b) -> Integer.compare(a[1], b[1])); // for ascending order
Arrays.sort(array, (b, a) -> Integer.compare(a[1], b[1])); // for descending order
내림차순 출력
12, 100
12, 85
1, 5
13, 1
꽤 오래된 스레드인 것은 알지만, 다음은 Integress와 Java 8의 최신 버전입니다.
Arrays.sort(array, (o1, o2) -> o2 - o1);
일반 오름차순(또는 Comparator.comparingInt())의 경우 "o1 - o2"입니다.
이것은 다른 모든 종류의 오브젝트에도 유효합니다.설명:
Arrays.sort(array, (o1, o2) -> o2.getValue() - o1.getValue());
여기에는 많은 혼란이 있다 - 사람들은 비원시적 가치에 대한 해결책을 제안하고, 땅에서 알고를 분류하려고 하고, 추가적인 도서관과 관련된 해결책을 제공하고, 몇몇 진부한 것들을 과시하려고 한다.원래 질문에 대한 답은 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}ints 이외의 배열이 있는 경우 - 대신 해당 개체를 사용합니다.Integer.
내부 배열을 내림차순으로 정렬하는 간단한 방법:
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;
}
이 방법은 효과가 있었습니다.
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;
}
이 방법을 사용하면 더블 타입의 배열을 내림차순으로 정렬할 수 있습니다.또, 「return type」, 「return type」, 「return type」, 및 변수 「x」의 배열을 대응하는 타입으로 변경하는 것만으로, 다른 타입(int, float 등)의 배열을 정렬할 수 있습니다.또한 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");
항목을 "자연스러운" 순서로 인쇄하려면 sorted() 메서드를 사용합니다(또는 생략하고 동일한 결과를 얻을 수 있습니다).
items.stream()
.sorted()
.forEach(item -> System.out.println(item));
또는 내림차순(역방향)으로 인쇄하려면 비교기를 사용하여 순서를 반대로 하는 정렬 방법을 사용할 수 있습니다.
items.stream()
.sorted(Comparator.reverseOrder())
.forEach(item -> System.out.println(item));
이를 위해서는 컬렉션이 Comparible을 구현해야 합니다(Integer, String 등).
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() );
예를 들어 연습하는 것이 좋은 경우도 있습니다.다음은 예를 제시하겠습니다.
sortdesc.displays
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
조금 더 길어질 수 있는 방법이 있지만, 잘 작동합니다.이것은 int 배열을 내림차순으로 정렬하는 방법입니다.
이것이 언젠가 누군가에게 도움이 되기를 바랍니다.
public static int[] sortArray (int[] array) {
int [] sortedArray = new int[array.length];
for (int i = 0; i < sortedArray.length; i++) {
sortedArray[i] = array[i];
}
boolean flag = true;
int temp;
while (flag) {
flag = false;
for (int i = 0; i < sortedArray.length - 1; i++) {
if(sortedArray[i] < sortedArray[i+1]) {
temp = sortedArray[i];
sortedArray[i] = sortedArray[i+1];
sortedArray[i+1] = temp;
flag = true;
}
}
}
return sortedArray;
}
나는 다음과 같은 솔루션을 가지고 있었다.
public static int[] sortArrayDesc(int[] intArray){
Arrays.sort(intArray); //sort intArray in Asc order
int[] sortedArray = new int[intArray.length]; //this array will hold the sorted values
int indexSortedArray = 0;
for(int i=intArray.length-1 ; i >= 0 ; i--){ //insert to sortedArray in reverse order
sortedArray[indexSortedArray ++] = intArray [i];
}
return sortedArray;
}
여기에 많은 답이 있다는 것을 알지만, 여전히 그들 중 누구도 핵심 자바 사용을 시도하지 않았다고 생각한다.그리고 collection api를 사용하면 메모리와 자원을 낭비하게 됩니다.
여기 순수한 핵심 개념에 대한 시도가 있습니다. 네, 만약 당신이 기억의 발자국에 대해 더 관심이 있다면 이것은 더 나은 방법일 수 있습니다.
int[] elements = new int [] {10,999,999,-58,548,145,255,889,1,1,4,5555,0,-1,-52};
//int[] elements = null;
if(elements != null && elements.length >1)
{
int max = 0, index = 0;
for(int i =0;i<elements.length;i++)//find out what is Max
{
if(elements[i] > max)
{
max = elements[i];
index = i;
}
}
elements[index] = elements[0];//Swap the places
elements[0] = max;
for(int i =0;i < elements.length;i++)//loop over element
{
for(int j = i+1;j < elements.length;j++)//loop to compare the elements
{
if(elements[j] > elements[i])
{
max = elements[j];
elements[j] = elements[i];
elements[i] = max;
}
}
}
}//i ended up using three loops and 2 extra variables
System.out.println(Arrays.toString(elements));//if null it will print null
// still love to learn more, please advise if we can do it better.
나도 너에게 배우는 것을 좋아해!
언급URL : https://stackoverflow.com/questions/1694751/java-array-sort-descending
'IT이야기' 카테고리의 다른 글
| VueJ에 JSON Imports (0) | 2022.05.30 |
|---|---|
| Java에서 "transient"라는 키워드는 무엇을 의미합니까? (0) | 2022.05.30 |
| Vue.js의 커스텀 디렉티브에서 클릭 이벤트를 캡처하려면 어떻게 해야 합니까? (0) | 2022.05.30 |
| vue 구성 요소가 이벤트를 전달하지 않습니다. (0) | 2022.05.30 |
| java.sql 크기를 얻으려면 어떻게 해야 하나요?결과 세트? (0) | 2022.05.30 |