[Java] sort() 메소드 정렬하기 (Arrays, Collections, Comparable, Comparator)

C에서의 정렬이라고 하면

C Code 카테고리에 있듯이 Bobble Sort, Merge Sort, Quick Sort 등을 메소드로 구현하여 사용할 수 있다

 

그렇다면 Java에서는 정렬을 어떻게 할까?

 

---

 

우선 가장 많이 사용하는 정렬방법은 java.util.Arrays 클래스의 sort() 메소드가 있다

(이는 dual pivot quicksort 알고리즘이 내장되어 있다고 한다)

 

import java.util.Arrays;

public class MyClass {
    public static void main(String args[]) {
        int[] arr1 = new int[] {4, 3, 5, 2, 1};
        Arrays.sort(arr1);
        for(int num : arr1)
            System.out.print(num + " ");
        // 1 2 3 4 5
        
        System.out.println("");
        
        String[] arr2 = new String[] {"dd", "cc", "ee", "bb", "aa"};
        Arrays.sort(arr2);
        for(String word : arr2)
            System.out.print(word + " ");
        // aa bb cc dd ee
    }
}

 

---

 

다음으로 Collection, 컬렉션 프레임워크를 이용한다면, 

java.util.Collections 클래스의 sort() 메소드가 있다

(이는 merge sort의 알고리즘이 내장되어 있다고 한다 // Arrays.sort() 메소드의 속도가 좀 더 빠름)

 

import java.util.*;

public class MyClass {
    public static void main(String args[]) {
        List<String> words = new ArrayList<>();
        
        words.add("bb");
        words.add("cc");
        words.add("aa");
        
        Collections.sort(words); //오름차순
        
        System.out.println(words);
        
        Collections.sort(words, Collections.reverseOrder()); //내림차순
        //Collections.sort(words, Comparator.reverseOrder());
        
        System.out.println(words);
    }
}

 

위와 같이 내림차순으로도 정렬할 수 있다

 

---

그렇다면 기본 타입이 아닌, 사용자 정의 객체 배열인 경우에는 어떠할까?

 

객체 배열인 경우에는 정렬의 기준이 명확하지 않으므로,

객체 클래스가 Comparable<> 인터페이스의 CompareTo() 메소드를 오버라이딩하여 사용할 수 있다

 

import java.util.*;

public class MyClass {
    public static class Man implements Comparable<Man> {
        public String name;
        public int age;
        public Man(String name, int age) {
            this.name = name;
            this.age = age;
        }
        
        @Override
        public int compareTo(Man other) {
            return name.compareTo(other.name);
        }
    }
    
    public static void main(String args[]) {
        Man[] men = new Man[4];
        men[0] = new Man("Park", 21);
        men[1] = new Man("Lee", 23);
        men[2] = new Man("Kim", 21);
        men[3] = new Man("Ann", 22);
        
        Arrays.sort(men);
        
        for(int i=0 ; i<4 ; i++)
            System.out.print(men[i].name + " ");
        // Ann Kim Lee Park
    }
}

 

오름차순으로 정렬하기 위해서는 compareTo() 메소드를 어떻게 오버라이딩 해야할까?

 

compareTo() 메소드에서 return 값은

매개변수가 크면 -1,

매개변수와 같으면 0,

매개변수가 작으면 +1

이 된다

ex) "a".compareTo("b") == -1

 

따라서 위 코드에서 other.name이 클 때

name.compareTo(other.name) 이 -1을 만족시켜 오름차순으로 정렬된다

 

만약 14 Line을 other.name.compareTo(name) 으로 바꾼다면, 내림차순으로 정렬된다

 

---

 

만약 2개 이상의 기준을 적용하고 싶을 때에는 Comparator<> 인터페이스가 있다

이는 compare() 메소드를 오버라이딩하여

sort() 메소드의 정렬자로 제공하여 사용한다

 

위의 Comparable 구현 클래스를 다음과 같이 변형할 수 있다

 

import java.util.*;

public class MyClass {
    public static class Man {
        public String name;
        public int age;
        public Man(String name, int age) {
            this.name = name;
            this.age = age;
        }
    }
    
    public static void main(String args[]) {
        Man[] men = new Man[4];
        men[0] = new Man("Park", 21);
        men[1] = new Man("Lee", 23);
        men[2] = new Man("Kim", 21);
        men[3] = new Man("Ann", 22);
        
        Comparator<Man> nameComparator = new Comparator<Man>() {
            @Override
            public int compare(Man o1, Man o2) {
                if(o1.name > o2.name) return 1;
                else if(o1.name == o2.name) return 0;
                else return -1;
            }
        };
        Arrays.sort(men, nameComparator);
        
        for(int i=0 ; i<4 ; i++)
            System.out.print(men[i].name + " ");
        // Ann Kim Lee Park
    }
}

 

Comparator<> 인터페이스는 주로 익명 구현 객체로 많이 이용한다 (일회성)

물론,

public class nameComparator implements Comparator<Man> {
    @Override
    ...
}

이처럼 따로 클래스로 빼내어도 된다

 

---

 

Comparable / Comparator 에 관하여 : snupi.tistory.com/60