[Java/Short] Array, ArrayList 정렬(Sort) 방법

해당 페이지에서는 자주 사용하는 개발 패턴으로 “Array, ArrayList의 정렬”하는 방법에 대해서 공유합니다.

 

1) Array의 정렬 방법

---

1. 배열의 숫자 정렬 방법

---

/*
 * 숫자 배열의 정렬
 */
Integer[] sortNumArr1 = {0, 1, 2, 3, 4};
Integer[] sortNumArr2 = {10, 11, 1, 2, 4};

// [CASE1] 숫자 오름차순 정렬 -1 : 오름차순으로 정렬이 됩니다.
Arrays.sort(sortNumArr1);   // [0, 1, 2, 3, 4]
Arrays.sort(sortNumArr2);   // [1, 2, 4, 10, 11]

// [CASE2] 숫자 오름차순 정렬 -2 : 오름차순으로 정렬이 됩니다.
Arrays.sort(sortNumArr1, Comparator.naturalOrder()); // [0, 1, 2, 3, 4]
Arrays.sort(sortNumArr2, Comparator.naturalOrder()); // [1, 2, 4, 10, 11]

// [CASE3] 숫자 내림차순 정렬 -1 : 내림차순으로 정렬이 됩니다.(* 해당 주의 사항은 Wrapper Class 를 이용하여야 합니다.)
Arrays.sort(sortNumArr1, Collections.reverseOrder());   // [4, 3, 2, 1, 0]
Arrays.sort(sortNumArr2, Collections.reverseOrder());   // [11, 10, 4, 2, 1]

// [CASE4] 숫자 내림차순 정렬 -2 : 내림차순으로 정렬이 됩니다.(* 해당 주의 사항은 Wrapper Class 를 이용하여야 합니다.)
Arrays.sort(sortNumArr1, Comparator.reverseOrder());   // [4, 3, 2, 1, 0]
Arrays.sort(sortNumArr2, Comparator.reverseOrder());   // [11, 10, 4, 2, 1]

// [CASE5] 숫자 인덱스 범위 정렬 : 시작 인덱스와 종료 인덱스를 선택하여서 정렬이 됩니다.
Arrays.sort(sortNumArr1, 0, 3);         // [1, 10, 11, 2, 4]

Integer[] sortNumArr3 = {10, 11, 1, 2, 4};

// [CASE5] 숫자 오름차순 정렬 : Lambda를 이용한 오름 차순으로 정렬
Arrays.sort(sortNumArr3, (s1, s2) -> s1 - s2);          // [1, 2, 4, 10, 11]

// [CASE6] 숫자 내림차순 정렬 : Lambda를 이용한 내림 차순으로 정렬
Arrays.sort(sortNumArr3, (s1, s2) -> s2 - s1);          // [11, 10, 4, 2, 1]

 

 

1.1. 숫자 배열의 응용 : 배열을 역순으로 재 구성 방법

💡 [참고] 배열에서 .sort(Array, Collection.reverseOrder())를 이용하는 방법보다 for문으로 역순을 구현하는게 속도가 빠르다고 합니다.

int[] sortNumArr4 = {0, 1, 2, 3, 4};
int[] remakeNumArr = new int[sortNumArr4.length];

Arrays.sort(sortNumArr4);
for (int i = 0; i < sortNumArr4.length; i++) {
    remakeNumArr[i] = sortNumArr4[sortNumArr4.length - 1 - i];
}
// [4, 3, 2, 1, 0]

 

 

1.2. 숫자 배열의 변환 에러 :  Arrays.sort(array, Comparator.reverseOrder())를 사용하는 경우 에러 발생하는 경우 

💡 아래와 같이  기본 자료형인 경우 'Boxing'을 수행하여 래퍼 클래스 형태의 배열로 구성해야 합니다.
- 이를 위해 Stream API의 boxed() 함수를 이용합니다.

 

 

[참고] 이전에 작성한 기본 자료형과 래퍼 클래스에 대한 이해 글입니다.

[Java/Short] 기본 자료형과 래퍼 클래스의 박싱(Boxing)과 언박싱(Unboxing) 방법

[Java/Short] 기본 자료형과 래퍼 클래스의 박싱(Boxing)과 언박싱(Unboxing) 방법

 

 

💡 Stream을 이용하여서 'boxing'을 하고 정렬을 수행합니다.

import java.util.*;

int[] A = new int[]{1, 4, 2};

// 1. int[] -> Integer[] Boxing
Integer[] integerArr = Arrays.stream(A).boxed().toArray(Integer[]::new);

// 2. Integer[] reverse Order
Arrays.sort(integerArr, Comparator.reverseOrder()); // [4, 2, 1]

 

💡 위의 코드에서는 정상적으로 '정렬'이 잘 수행됨을 확인하였으나 아래의 방법에서는 수행되지 않으니 참고하시면 도움이 될 것 같습니다.

💡 해당 방법은 실제로 Boxing을 통해서 Integer로 구성하였으나 스트림만을 반환할 뿐 배열의 정렬은 수행되지 않습니다.

import java.util.*;

int[] A = new int[]{1, 4, 2};

// 해당 부분은 박싱을 하였으나 실제적으로 sorting을 수행되지 않습니다.!
Arrays.stream(A).boxed().sorted(Comparator.reverseOrder()); // [1, 4, 2]

 

 

 

2. 배열의 문자열 정렬 방법

---

/*
 * 문자열의 정렬-1 : 대소문자를 구분하여 정렬하는 방식
 */
String[] sortStrArr1 = {"strawberry", "Strawberry", "mango", "Mango", "cherry", "Cherry", "banana", "Banana", "apple", "Apple"};

// [CASE1] 문자 정렬 : 오름차순으로 정렬합니다.
Arrays.sort(sortStrArr1);                                           // [Apple, Banana, Cherry, Mango, Strawberry, apple, banana, cherry, mango, strawberry]

// [CASE2] 문자 정렬 : 내림차순으로 정렬이 됩니다. (* 해당 주의 사항은 Wrapper Class 를 이용하여야 합니다.)
Arrays.sort(sortStrArr1, Collections.reverseOrder());               // [strawberry, mango, cherry, banana, apple, Strawberry, Mango, Cherry, Banana, Apple]

 

 

2.1. 숫자 형태인 문자열 배열을 정렬하는 방법

💡 strArr의 경우는 문자열 배열이지만 사실상 데이터는 숫자입니다.
💡 만약 strArr 자체를 Arrays.sort(strArr) 메서드로 정렬을 수행하더라도 정렬이 되지 않습니다. 그렇기에 정수 배열에 재구성하여 추가하여 정렬을 수행합니다.

String[] strArr = {"5", "2", "10", "8"};
int[] intArr = new int[strArr.length];

// 문자열을 배열로 파싱하여 int[] 배열로 재구성합니다.
for (int i = 0; i < strArr.length; i++) {
    intArr[i] = Integer.parseInt(strArr[i]);
}

 

 

3. 알파벳 정렬 : 대소문자 구분없이 정렬

---

/*
 * 문자열의 정렬-2 : 대소문자 구분없이 정렬하는 방식
 */
String[] sortStrArr2 = {"strawberry", "Strawberry", "mango", "Mango", "cherry", "Cherry", "banana", "Banana", "apple", "Apple"};

// [CASE1] 문자 정렬 : 오름차순으로 정렬합니다. : 대소문자 구분 O
Arrays.sort(sortStrArr2, String.CASE_INSENSITIVE_ORDER);                                // [apple, Apple, banana, Banana, cherry, Cherry, mango, Mango, strawberry, Strawberry]

// [CASE2] 문자 정렬 : 내림차순으로 정렬합니다. : 대소문자 구분 O
Arrays.sort(sortStrArr2, Collections.reverseOrder(String.CASE_INSENSITIVE_ORDER));      // [strawberry, Strawberry, mango, Mango, cherry, Cherry, banana, Banana, apple, Apple]

 

 

 

2) ArrayList 정렬 방법

---

1. 문자열 정렬

---

List<String> sortedStrList = new ArrayList<>(Arrays.asList("apple", "banana", "cherry"));

// [CASE1] 문자열 오름차순 정렬 -1 : Collections.sort() 이용
Collections.sort(sortedStrList);                                    // [apple, banana, cherry]

// [CASE2] 문자열 오름차순 정렬 -2 : List.sort() 이용
sortedStrList.sort(Comparator.naturalOrder());                      // [apple, banana, cherry]


        
// [CASE1] 문자열 내림차순 정렬 : Collections.reverse() 이용
Collections.reverse(sortedStrList);                                 // [cherry, banana, apple]

// [CASE2] 문자열 내림차순 정렬 : Collections.sort() 이용
Collections.sort(sortedStrList, Collections.reverseOrder());        // [cherry, banana, apple]

// [CASE3] 문자열 내림차순 정렬 : List.sort() 이용
sortedStrList.sort(Comparator.reverseOrder());                      // [cherry, banana, apple]

// [CASE4] 문자열 내림차순 정렬 : List.sort() 이용
Comparator<Object> reverseOrder = Collections.reverseOrder();       // [cherry, banana, apple]

 

 

2. 객체 정렬

---

List<UserDto> sortedUserDtoList = Arrays.asList(
        UserDto.userBuilder().userId("adjh54").userNm("lee").userPw("1234").userSt("S").build(),
        UserDto.userBuilder().userId("ckask123").userNm("kim").userPw("4321").userSt("S").build(),
        UserDto.userBuilder().userId("fjdsl3").userNm("park").userPw("5678").userSt("S").build()
);

// [CASE1] 객체 오름차순 정렬 -1 : Collections.sort() 이용
Collections.sort(sortedUserDtoList, Comparator.comparing(UserDto::getUserNm));                  // [lee, kim, park]

// [CASE2] 객체 오름차순 정렬 -2 : List.sort() 이용
sortedUserDtoList.sort(Comparator.comparing(UserDto::getUserNm));                               // [lee, kim, park]

// [CASE3] 객체 내림차순 정렬 -1 : Collections.sort() 이용
Collections.sort(sortedUserDtoList, Comparator.comparing(UserDto::getUserNm).reversed());       // [park, kim, lee]

// [CASE4] 객체 내림차순 정렬 -2 : List.sort() 이용
sortedUserDtoList.sort(Comparator.comparing(UserDto::getUserNm).reversed());                    // [park, kim, lee]

 

 

 

3) Stream API를 이용한 정렬 방법

---

1. Array to Stream 

---

/*
 * [CASE1] Array 이용한 방법
 */
// 1. Array Initialize
int[] sortNumArr1 = {10, 11, 1, 2, 4};
int[] sortNumArr2 = {0, 1, 2, 3, 4};

// 2.1. Array to IntStream : 배열을 오름차순으로 정렬합니다.
IntStream sortAscIntStreamType1 = Arrays.stream(sortNumArr1).sorted();

// 2.2. Array to Stream<Integer> : 배열을 내림차순으로 정렬합니다.
Stream<Integer> sortDescIntStreamType1 = Arrays.stream(sortNumArr1).boxed().sorted(Comparator.reverseOrder());
Stream<Integer> sortDescIntStreamType2 = Arrays.stream(sortNumArr2).boxed().sorted((a, b) -> b - a);

// 3.1. IntStream to int[]
int[] resultSortedNumArr1 = sortAscIntStreamType1.toArray();    // 결과값 반환(오름차순) : [1, 2, 4, 10, 11]

// 3.2. Stream<Integer> to int[]
int[] resultSortedNumArr2 = sortDescIntStreamType1.mapToInt(i -> i).toArray();      // 결과값 반환(내림차순) : [11, 10, 4, 2, 1]
int[] resultSortedNumArr3 = sortDescIntStreamType2.mapToInt(i -> i).toArray();      // 결과값 반환(내림차순) : [4, 3, 2, 1, 0]

 

 

 

2. ArrayList to Stream

---

/*
 * [CASE2] ArrayList 이용한 방법
 */
// 1. ArrayList Initialize
List<String> sortedStrList1 = new ArrayList<>(Arrays.asList("aaa", "bbb", "ccc", "ddd", "AAA"));
List<String> sortedStrList2 = new ArrayList<>(Arrays.asList("apple", "banana", "cherry"));
List<String> sortedStrList3 = new ArrayList<>(Arrays.asList("f", "b", "z"));

// 2.1. ArrayList to Stream<String> : 리스트를 오름 차순으로 정렬합니다.
Stream<String> sortedStrStream1 = sortedStrList1.stream().sorted(Comparator.naturalOrder());

// 2.2. ArrayList to Stream<String> : 리스트를 오름 차순으로 정렬합니다.
Stream<String> sortedStrStream2 = sortedStrList2.stream().sorted(Comparator.reverseOrder());
Stream<String> sortedStrStream3 = sortedStrList3.stream().sorted((a, b) -> b.compareTo(a));

// 3.1. Stream<String> to List<String>
sortedStrList1 = sortedStrStream1.collect(Collectors.toList());     // 결과값 반환(오름차순) : ["AAA", "aaa", "bbb", "ccc", "ddd"]
sortedStrList2 = sortedStrStream2.collect(Collectors.toList());     // 결과값 반환(오름차순) : ["cherry", "banana", "apple"]
sortedStrList3 = sortedStrStream3.collect(Collectors.toList());     // 결과값 반환(오름차순) : ["z", "f", "d"]

 

 

3. Object to Stream

---

/*
 * [CASE3] Object 이용한 방법
 */
// 1. Object ArrayList Initialize
List<UserDto> sortedUserDtoList = Arrays.asList(
        UserDto.userBuilder().userId("adjh54").userNm("lee").userPw("1234").userSt("S").build(),
        UserDto.userBuilder().userId("ckask123").userNm("kim").userPw("4321").userSt("S").build(),
        UserDto.userBuilder().userId("fjdsl3").userNm("park").userPw("5678").userSt("S").build()
);

// 2.1. Object to Stream<Object> : 리스트 내에서 userNm을 기준으로 오름차순으로 정렬합니다.
Stream<UserDto> sortedAscUserDtoStream = sortedUserDtoList.stream().sorted(Comparator.comparing(UserDto::getUserNm));

// 2.2. Object to Stream<Object> : 리스트 내에서 userNm을 기준으로 내림차순으로 정렬합니다.
Stream<UserDto> sortedDescUserDtoStream = sortedUserDtoList.stream().sorted(Comparator.comparing(UserDto::getUserNm).reversed());

// 3. Stream<Object> to ArrayList
List<UserDto> sortedAscUserDtoList = sortedAscUserDtoStream.collect(Collectors.toList());           // 결과값 반환: List<UserDto>
List<UserDto> sortedDescUserDtoList = sortedDescUserDtoStream.collect(Collectors.toList());         // 결과값 반환: List<UserDto>

 

 

 

 

 

오늘도 감사합니다. 😀