Comparable, Compartor 인터페이스

[목차]

🟢 기본형변수, Wrapper클래스 배열 정렬

       Arrays.sort(배열명) : 배열 오름차순 정렬

       Arrays.sort(배열명, Collections.reverseOrder()) : 배열 내림차순 정렬

🟢 객체 정렬 : Comparable과 Comparator 인터페이스를 알아보자

       Comparable 인터페이스 - compareTo( ) 메서드

       Comparator 인터페이스 - compare( ) 메서드

🟢 정리!

---

🟢 기본형변수, Wrapper클래스 배열 정렬

참고 : Arrays.toString(배열명) 으로 모두 출력할 수 있다.

 

Arrays.sort(배열명) : 배열 오름차순 정렬

int[] docs = {5, 3, 1, 2, 4};
Arrays.sort(docs);
System.out.println(Arrays.toString(docs)); //[1, 2, 3, 4, 5]

String[] strs = {"C", "A", "D", "F", "G"};
Arrays.sort(strs);
System.out.println(Arrays.toString(strs)); //[A, C, D, F, G]

 

Arrays.sort(배열명, Collections.reverseOrder()) : 배열 내림차순 정렬

Collecitons를 사용하게되면 기본형은 사용불가하고,

Wrapper클래스로 변경해주어야 한다.

//int[] docs = {5, 3, 1, 2, 4};
Integer[] docs = {5, 3, 1, 2, 4};
Arrays.sort(docs, Collections.reverseOrder());
System.out.println(Arrays.toString(docs)); //[5, 4, 3, 2, 1]

String[] strs = {"C", "A", "D", "F", "G"};
Arrays.sort(strs, Collections.reverseOrder());
System.out.println(Arrays.toString(strs)); //[G, F, D, C, A]

 

🟢 객체 정렬 : Comparable과 Comparator 인터페이스를 알아보자

학생 객체인 경우엔 국어성적, 영어성적, 수학성적... 등의 여러 속성값이 존재한다.

A학생과 B학생을 비교할때, 여러 속성값 중에 어떤 것을 기준으로 비교할지 '기준점'이 필요하다!

 

이처럼 Comparable과 Comparator 인터페이스는 둘다 정렬의 기준을 정하는인터페이스이다. 

보통 Comparable은 프로그램에서 계속 사용 될 기본정렬을 정의하는데에 쓰이고

Comparator는 그때그때마다 정렬기준이 달라지는, 추가정렬을 정의하는데에 쓰인다.

 

Comparable 인터페이스 - compareTo( ) 메서드

정렬하고 싶은 클래스에 compareTo( ) 메서드를 재정의 한다.

 = 클래스 내부에 정렬 기준을 정의해주는 것과 같다.

 

정렬기준 정의를 완료하면 Arrays.sort(객체명) 또는 Collections.sort(객체명)을 호출하여 실제 정렬처리를 수행한다.

 

return값이 양수인 경우, 두 값의 자리가 변경되면서 정렬이 이루어진다.

 

if문으로도 표현할 수 있지만, return문만으로도 표현 가능하다.

구분	오름차순	내림차순
if문으로 표현	if ( 자기자신 > 비교대상 ) { return 1; }	if ( 자기자신 < 비교대상 ) { return 1; }
return문으로만 표현	return 자기자신 - 비교대상;	return 비교대상 - 자기자신;
예시	[5, 3, 1, 2, 4]  if ( 5 > 3 ) { return 1; ) 또는 return 5 - 3;  ▶ 5와 3 위치 변경 [3, 5]	[5, 3, 1, 2, 4] if ( 2 < 4 ) { return 1; ) 또는 return 4 - 2;  ▶  2와 4 위치 변경 [4, 2]

import java.util.Arrays;

class Grade implements Comparable<Grade>{
    int kor;
    int eng;
    public Grade(int kor, int eng){ this.kor = kor; this.eng = eng; }
    @Override public String toString() { return "Grade{" +"kor=" + kor +", eng=" + eng +"}"; }

    //singlesort
    @Override
    public int compareTo(Grade other) {
        return this.kor - other.kor;   //오름차순
        //return other.kor - this.kor; //내림차순
    }
}

public class study {
    public static void main(String[] args) {
        Grade[] ks = new Grade[5];
        ks[0] = new Grade(10, 40);
        ks[1] = new Grade(30, 10);
        ks[2] = new Grade(20, 50);
        ks[3] = new Grade(20, 30);
        ks[4] = new Grade(40, 20);

        //singlesort
        Arrays.sort(ks);
        for (Grade k : ks) { System.out.println(k); }
        //Grade{kor=10, eng=40}
        //Grade{kor=20, eng=50}
        //Grade{kor=20, eng=30}
        //Grade{kor=30, eng=10}
        //Grade{kor=40, eng=20}
        System.out.println();
    }
}

import java.util.Arrays;

class Grade implements Comparable<Grade>{
    int kor;
    int eng;
    public Grade(int kor, int eng){ this.kor = kor; this.eng = eng; }
    @Override public String toString() { return "Grade{" +"kor=" + kor +", eng=" + eng +"}"; }

    //multisort
    @Override
    public int compareTo(Grade other) {
        int result = 0;
        if(this.kor < other.kor){        result = 1;   }  //국어점수 내림차순
        else if(this.kor == other.kor){                   //국어점수 동점이라면
            if(this.eng > other.eng){    result = 1;   }  //영어점수 오름차순
            else{                   result = -1;  }
        }
        else{                      result = -1;   }  //o1.kor > o2.kor
        return result;
    }
}

public class study {
    public static void main(String[] args) {
        Grade[] ks = new Grade[5];
        ks[0] = new Grade(10, 40);
        ks[1] = new Grade(30, 10);
        ks[2] = new Grade(20, 50);
        ks[3] = new Grade(20, 30);
        ks[4] = new Grade(40, 20);

        //multisort
        Arrays.sort(ks);
        for (Grade k : ks) { System.out.println(k); }
        //Grade{kor=40, eng=20}
        //Grade{kor=30, eng=10}
        //Grade{kor=20, eng=30}
        //Grade{kor=20, eng=50}
        //Grade{kor=10, eng=40}
    }
}

 

 

Comparator 인터페이스 - compare( ) 메서드

만약 Comparable로 기준을 정해놨는데 다른 기준으로 정렬하고싶을땐 어떻게할까?

compareTo( ) 메서드를 수정할 수 없을 때, 특수한 기준을 더해주는 것이 compare( ) 메서드이다.

=> 그때그때 다른 정렬기준으로 보고싶을 때 사용한다. 대부분 익명클래스를 만들어서 사용하게된다.

 

 

정렬하고 싶은 클래스 외부에 Comparator를 선언하여 compare( ) 메서드를 재정의 한다.

 = 클래스 내부 정렬기준은 그대로놔두고, 추가 정렬 기준을 정의해주는 것과 같다.

 

정렬기준 정의를 완료하면 Arrays.sort(객체명, Comparator) 또는

Collections.sort(객체명, Comparator)를 호출하여 실제 정렬처리를 수행한다.

 

Comparable과 마찬가지로 return값이 양수인 경우, 두 값의 자리가 변경되면서 정렬이 이루어진다.

 

if문으로도 표현할 수 있지만, return문만으로도 표현 가능하다.

구분	오름차순	내림차순
if문으로 표현	if ( 자기자신 > 비교대상 ) { return 1; }	if ( 자기자신 < 비교대상 ) { return 1; }
return문으로만 표현	return 자기자신 - 비교대상;	return 비교대상 - 자기자신;
예시	[5, 3, 1, 2, 4]  if ( 5 > 3 ) { return 1; ) 또는 return 5 - 3;  ▶ 5와 3 위치 변경 [3, 5]	[5, 3, 1, 2, 4] if ( 2 < 4 ) { return 1; ) 또는 return 4 - 2;  ▶  2와 4 위치 변경 [4, 2]

import java.util.Arrays;
import java.util.Comparator;

class Grade {
    int kor;
    int eng;
    public Grade(int kor, int eng){ this.kor = kor; this.eng = eng; }
    @Override public String toString() { return "Grade{" +"kor=" + kor +", eng=" + eng +"}"; }
}

public class study {
    public static void main(String[] args) {
        Grade[] ks = new Grade[5];
        ks[0] = new Grade(10, 40);
        ks[1] = new Grade(30, 10);
        ks[2] = new Grade(20, 50);
        ks[3] = new Grade(20, 30);
        ks[4] = new Grade(40, 20);


        Comparator<Grade> singlesort = new Comparator<Grade>() {
            int result = 0;
            @Override
            public int compare(Grade o1, Grade o2) {
                if(o1.kor > o2.kor){        result = 1;   }  //국어점수 오름차순
                else if(o1.kor == o2.kor){  result = 0;   }  //국어점수 동점이라면
                else{                      result = -1;   }  //o1.kor < o2.kor
                return result;
            }
        };

        Arrays.sort(ks, singlesort);
        for (Grade k : ks) { System.out.println(k); }
        //Grade{kor=10, eng=40}
        //Grade{kor=20, eng=50}
        //Grade{kor=20, eng=30}
        //Grade{kor=30, eng=10}
        //Grade{kor=40, eng=20}
        System.out.println();





        Comparator<Grade> multisort = new Comparator<Grade>() {
            int result = 0;
            @Override
            public int compare(Grade o1, Grade o2) {
                if(o1.kor < o2.kor){        result = 1;   }  //국어점수 내림차순
                else if(o1.kor == o2.kor){                   //국어점수 동점이라면
                    if(o1.eng > o2.eng){    result = 1;   }  //영어점수 오름차순
                    else{                   result = -1;  }
                }
                else{                      result = -1;   }  //o1.kor > o2.kor
                return result;
            }
        };

        Arrays.sort(ks, multisort);
        for (Grade k : ks) { System.out.println(k); }
        //Grade{kor=40, eng=20}
        //Grade{kor=30, eng=10}
        //Grade{kor=20, eng=30}
        //Grade{kor=20, eng=50}
        //Grade{kor=10, eng=40}
    }
}

 

🟢 정리!

구분	Comparable 인터페이스	Comparator 인터페이스
역할	정렬의 기준을 정의하는 인터페이스
	프로그램에서 계속 사용될 정렬기준을 정의하는데 쓰임	그때그때 달라지는 정렬기준을 정의하는데 쓰임
인터페이스 구현	정렬하고 싶은 클래스. implements Comparable<클래스명>	정렬하고 싶은 클래스 외부. Comparator 익명클래스 선언
재정의 메서드	int compareTo(Object other)	int compare(Object o1, Object o2)
실제 정렬처리 수행메서드	Arrays.sort(객체명) Collections.sort(객체명)	Arrays.sort(객체명, Comparator)  Collections.sort(객체명, Comparator)
값 자리변경	return값이 양수인 경우, 두 값의 자리가 변경된다.
오름차순	if ( 자기자신 > 비교대상 ) { return 1; }
	return 자기자신 - 비교대상;
내림차순	if ( 자기자신 < 비교대상 ) { return 1; }
	return 비교대상 - 자기자신;