[Java] 배열, 컬렉션 정렬 방법

▤ 목차

1. 정렬

1차원 배열

1. Arrays.sort() 정렬

int[] arr = {2, 3, 4, 5, 1};
Integer[] numbers = {2, 3, 4, 5, 1};


//정렬 (오름차순)
Arrays.sort(arr); /* [1,2,3,4,5] */

// 내림차순 정렬 - Integer 타입
Arrays.sort(numbers, Collections.reverseOrder());

// 내림차순 정렬 - Integer 타입
Arrays.sort(numbers, Comparator.reverseOrder()); /* [5,4,3,2,1] */

2. 사용자 정의 정렬

Comparator는 두 객체를 비교하여 정렬 순서를 결정하는 인터페이스이다.

이를 사용하려면 배열의 타입을 int [] 대신 Integer []와 같은 래퍼 클래스로 선언해야 한다.

• Arrays.sort(int[] a)를 사용하며, 이는 오직 오름차순만 가능
• Arrays.sort(T [] a, Comparator <? super T> c)를 사용하며, Comparator를 전달하여 사용자 정의 정렬이 가능

1차원 배열에 Comparator를 적용하려면 반드시 배열을 Integer [], String [], Character [] 등의 객체 타입으로 선언해야 한다.

Integer[] arr = {2, 3, 4, 5, 1};

//사용자정의 정렬
Arrays.sort(arr, new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o2 - o1; //내림차순 정렬 [5,4,3,2,1]
    }
});

// Lamda 사용
// 내림차순 정렬
Arrays.sort(numbers, (o1, o2) -> o2 - o1); /* [5,4,3,2,1] */

// 오름차순 정렬
Arrays.sort(numbers, (o1, o2) -> o1 - o2); /* [1,2,3,4,5] */

3. 특정 범위 정렬

int[] arr = { 3,2,0,1,4 };

// Arrays.sort(배열, fromIndex, toIndex);
Arrays.sort(arr, 0, 3); // 배열 요소 0, 1, 2 만 정렬 [0, 2, 3, 1, 4]

2차원 배열

1. 사용자 정의 정렬

int[][] arr = new int[][]{{5,40},{3,50},{1,30},{4,20},{2,10}};

// 1. Comparator 익명 클래스 구현
Arrays.sort(arr, new Comparator<int[]>() {
    @Override
    public int compare(int[] o1, int[] o2) {
        return o1[0]-o2[0]; // 첫번째 숫자 기준 오름차순 {1,30}{2,10}{3,50}{4,20}{5,40}
        //return o2[0]-o1[0]; // 첫번째 숫자 기준 내림차순 {5,40}{4,20}{3,50}{2,10}{1,30}
        //return o1[1]-o2[1]; // 두번째 숫자 기준 오름차순 {2,10}{4,20}{1,30}{5,40}{3,50}
        //return o2[1]-o1[1]; // 두번째 숫자 기준 내림차순 {3,50}{5,40}{1,30}{4,20}{2,10}
    }
});

// 2. Lambda 사용
Arrays.sort(arr, (o1, o2) -> { 
	return o1[0]-o2[0]; // 첫번째 숫자 기준 오름차순 {1,30}{2,10}{3,50}{4,20}{5,40}
});

// 3. 다중 조건 
int[][] arr2 = new int[][]{{5,40},{3,50},{1,30},{4,20},{2,10},{5,10}};

Arrays.sort(arr2, new Comparator<int[]>() { 
    @Override
    public int compare(int[] o1, int[] o2) {
        return o1[0]!=o2[0] ? o1[0]-o2[0] : o1[1]-o2[1]; // 첫번째 기준 오름차순 > 두번째 기준 오름차순 {1,30}{2,10}{3,50}{4,20}{5,10}{5,40}
       //return o1[0]!=o2[0] ? o1[0]-o2[0] : o2[1]-o1[1]; // 첫번째 기준 오름차순 > 두번째 기준 내림차순 {1,30}{2,10}{3,50}{4,20}{5,40}{5,10}
    }
});

2. Comparator.comparing() 정렬

int[][] arr = new int[][]{{5,40},{3,50},{1,30},{4,20},{2,10}};
// 3.  Comparator.comparing() 
Arrays.sort(arr, Comparator.comparingInt((int[] o) -> o[0]));            // 첫번째 숫자 기준 오름차순 : {1,30}{2,10}{3,50}{4,20}{5,40}
Arrays.sort(arr, Comparator.comparingInt((int[] o) -> o[0]).reversed()); // 첫번째 숫자 기준 내림차순 : {5,40}{4,20}{3,50}{2,10}{1,30}
Arrays.sort(arr, Comparator.comparingInt((int[] o) -> o[1]));            // 두번째 숫자 기준 오름차순 : {2,10}{4,20}{1,30}{5,40}{3,50}
Arrays.sort(arr, Comparator.comparingInt((int[] o) -> o[1]).reversed()); // 두번째 숫자 기준 내림차순 : {3,50}{5,40}{1,30}{4,20}{2,10}

2. 컬렉션

1. sort 정렬

List<String> list = new ArrayList<>(Arrays.asList("b", "a", "c"));

 //오름차순
 Collections.sort(list); // ["a", "b", "c"]
 list.sort(null); // Comparator를 null로 넘기면 자연 정렬 순서(Comparable)를 따름 ["a", "b", "c"] 

 //내림차순
 Collections.sort(list, Comparator.reverseOrder()); // ["c", "b", "a"]
 list.sort(Comparator.reverseOrder()); // ["c", "b", "a"]

2. 사용자 정의 정렬

    // 1. 단일 조건
    List<Integer> list = new ArrayList<>(Arrays.asList(3, 1, 2));
    // 내림차순 정렬
    Collections.sort(list, (a, b) -> b.compareTo(a)); // [3, 2, 1]

    // 2. 다중 조건
    List<Student> students = new ArrayList<>();
    students.add(new Student("Kim", 30));
    students.add(new Student("Lee", 20));
    students.add(new Student("Park", 30));

    // 2-1 람다식을 사용하지 않는 Comparator 익명 클래스 구현
     Comparator<Student> multiComparator = new Comparator<Student>() {
        @Override
        public int compare(Student o1, Student o2) {
         // 1차 정렬 기준: 나이(age) 오름차순
          int ageComparison = Integer.compare(o1.age, o2.age);
         // 만약 나이가 같지 않다면 (ageComparison이 0이 아니라면), 나이 비교 결과를 바로 반환
          if (ageComparison != 0) {
                return ageComparison;
           }
         // 2차 정렬 기준: 나이가 같다면 이름(name) 내림차순
         // String.compareTo()는 오름차순 기준. 내림차순을 원하므로 결과를 반전시킴
             return o2.name.compareTo(o1.name); // o2.compareTo(o1)
            }
          };
            // 컬렉션 정렬 메서드에 익명 클래스 인스턴스를 전달하여 정렬
            Collections.sort(students, multiComparator);


    // 2-2 람다식 사용
    // 나이(age) 기준 오름차순 정렬 (
    students.sort((o1, o2) -> o1.age - o2.age); 
    // 만약 나이가 같으면 이름(name) 기준으로 오름차순 정렬
    students.sort(Comparator.comparing(s -> s.age)  // 1. 나이로 1차 정렬
                            .thenComparing(s -> s.name)); // 2. 나이가 같으면 이름으로 2차 정렬

 

• Comparable: 객체 내부에 정렬 기준을 정의할 때 (compareTo() 메서드 구현). 단 하나의 정렬 기준만 가질 수 있다.
• Comparator: 객체 외부에 정렬 기준을 정의할 때 (compare() 메서드 구현). 여러 정렬 기준을 필요에 따라 적용할 수 있다.

https://ifuwanna.tistory.com/328

[Java] 2차원 배열 정렬 (오름차순, 내림차순, 다중 조건)

 

잘못된 내용이 있다면 지적부탁드립니다. 방문해주셔서 감사합니다.