[JAVA] Comparable๊ณผ Comparator
Categories: JAVA-Learn
๐ ๊ฐ์ธ์ ์ธ ๊ณต๊ฐ์ผ๋ก ๊ณต๋ถ๋ฅผ ๊ธฐ๋กํ๊ณ ๋ณต์ตํ๊ธฐ ์ํด ์ฌ์ฉํ๋ ๋ธ๋ก๊ทธ์
๋๋ค.
์ ํํ์ง ์์ ์ ๋ณด๊ฐ ์์ ์ ์์ผ๋ ์ฐธ๊ณ ๋ฐ๋๋๋ค :๐ธ
[ํ๋ฆฐ ๋ด์ฉ์ ๋๊ธ๋ก ๋จ๊ฒจ์ฃผ์๋ฉด ๋ณต๋ฐ์ผ์ค๊ฑฐ์์]
Java์ Comparable๊ณผ Comparator
์ด๋ฒ์ ์ฝ๋ํธ๋ฆฌ๋ก DP(๋์ ๊ณํ๋ฒ)๋ฅผ ๊ณต๋ถํ๋ ค๊ณ ๊ฒฐ์ ํ๋๋ฐ, ๊ฐ์ฒด ์ ๋ ฌ์ ์ฌ์ฉํ๋ ๋ฌธ์ ๊ฐ ๋์๋ค. ํ์ ๊น๊ฒ ์๊ฐํ์ง ์์๋ Comparable
๊ณผ Comparator
์ ๋ํด ๋ค๋ค์ผ ํ๊ณ , ์ด์ฐธ์ ์๋ฐ์ ์ ์์ ๋ค์ ๋ณด๋ฉฐ ์ ๋ฆฌํด ๋ณด์๋ค. ๋ ์ธํฐํ์ด์ค๋ ์๋ฐ์์ ๊ฐ์ฒด ์ ๋ ฌ์ ์ง์ํ๋ ์ค์ํ ๊ตฌ์ฑ์์๋ก, ์ ๋ ฌ ๊ธฐ์ค์ ์ค์ ํ๋ ๋ฐฉ์์ด ์กฐ๊ธ ๋ค๋ฅด๋ค.
Java์ Arrays.sort()
๋ ๋ด๋ถ์ ์ผ๋ก Comparable
๋๋ Comparator
์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ ๊ฐ์ฒด๋ฅผ ํ์ฉํ์ฌ ์ ๋ ฌํ๋ค.
์ด ๋ ์ธํฐํ์ด์ค๋ ์ ๋ ฌ ๊ธฐ์ค์ ์ ์ํ๊ธฐ ์ํด ์ค๊ณ๋ ์ธํฐํ์ด์ค๋ก, ์ปฌ๋ ์ ์ด๋ ๋ฐฐ์ด๊ณผ ๊ฐ์ ๋ฐ์ดํฐ ๊ตฌ์กฐ๋ฅผ ์ ๋ฆฌํ๋ ๋ฐ ์ฌ์ฉ๋๋ค.
Comparable
1
2
3
public interface Comparable<T> {
public int compareTo(T o);
}
Comparable
์ธํฐํ์ด์ค๋ ํด๋์ค ๋ด๋ถ์ โ๊ธฐ๋ณธ ์ ๋ ฌ ๊ธฐ์คโ์ ์ ์ํ ๋ ์ฌ์ฉํ๋ค.- ๊ฐ์ ํ์ ์ ์ธ์คํด์ค๋ผ๋ฆฌ ๋น๊ตํ ์ ์๋๋ก ๋ง๋ค์ด ์ค๋ค.
- ๊ธฐ๋ณธ์ ์ผ๋ก ์ค๋ฆ์ฐจ์(์์ ๊ฐ โ ํฐ ๊ฐ)์ผ๋ก ์ ๋ ฌ๋๋๋ก ๊ตฌํ๋์ด ์๋ค.
- Java์
Integer
,String
,Date
์ ๊ฐ์ ํด๋์ค๋ ๋ชจ๋Comparable
์ ๊ตฌํํ๊ณ ์๋ค. compareTo()
๋ฉ์๋ ๋ฐํ๊ฐ- ์์: ํ์ฌ ๊ฐ์ฒด(this)๊ฐ ๋น๊ต ๋์๋ณด๋ค ์์ ๊ฒฝ์ฐ.
- 0: ํ์ฌ ๊ฐ์ฒด์ ๋น๊ต ๋์์ด ๊ฐ์ ๊ฒฝ์ฐ.
- ์์: ํ์ฌ ๊ฐ์ฒด๊ฐ ๋น๊ต ๋์๋ณด๋ค ํด ๊ฒฝ์ฐ.
์์ : ๊ธฐ๋ณธ ์ ๋ ฌ ๊ธฐ์ค ์ ์
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Student implements Comparable<Student> {
String name;
int score;
public Student(String name, int score) {
this.name = name;
this.score = score;
}
@Override
public int compareTo(Student other) {
return this.score - other.score; // ์ ์๋ฅผ ๊ธฐ์ค์ผ๋ก ์ค๋ฆ์ฐจ์ ์ ๋ ฌ
}
}
// ์ฌ์ฉ
Student[] students = {
new Student("Alice", 85),
new Student("Bob", 90),
new Student("Charlie", 80)
};
Arrays.sort(students);
Comparator
1
2
3
4
public interface Comparator<T> {
int compare(T o1, T o2);
boolean equals(Object obj);
}
Comparator
์ธํฐํ์ด์ค๋ ํด๋์ค ์ธ๋ถ์์ โ์ ๋ ฌ ๊ธฐ์คโ์ ์ ์ํ ๋ ์ฌ์ฉํ๋ค.Comparable
๊ณผ ๋ฌ๋ฆฌ, ํ ํด๋์ค์ ๋ํด ์ฌ๋ฌ ์ ๋ ฌ ๊ธฐ์ค์ ์ ์ฐํ๊ฒ ์ค์ ๊ฐ๋ฅํ๋ค.- ์๋ฅผ ๋ค์ด, ํ์์ ์ด๋ฆ, ์ ์, ๋์ด ๋ฑ ๋ค์ํ ๊ธฐ์ค์ผ๋ก ์ ๋ ฌํ๊ณ ์ถ์ ๋ ์ ํฉํ๋ค.\
compare()
๋ฉ์๋ ๋ฐํ๊ฐ- ์์: ์ฒซ ๋ฒ์งธ ๊ฐ์ฒด(o1)๊ฐ ๋ ๋ฒ์งธ ๊ฐ์ฒด(o2)๋ณด๋ค ์์ ๊ฒฝ์ฐ.
- 0: ๋ ๊ฐ์ฒด๊ฐ ๊ฐ์ ๊ฒฝ์ฐ.
- ์์: ์ฒซ ๋ฒ์งธ ๊ฐ์ฒด(o1)๊ฐ ๋ ๋ฒ์งธ ๊ฐ์ฒด(o2)๋ณด๋ค ํด ๊ฒฝ์ฐ.
์์ : ์ฌ๋ฌ ๊ธฐ์ค์ผ๋ก ์ ๋ ฌ
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class NameComparator implements Comparator<Student> {
@Override
public int compare(Student s1, Student s2) {
return s1.name.compareTo(s2.name); // ์ด๋ฆ ๊ธฐ์ค ์ค๋ฆ์ฐจ์ ์ ๋ ฌ
}
}
class ScoreComparator implements Comparator<Student> {
@Override
public int compare(Student s1, Student s2) {
return s2.score - s1.score; // ์ ์ ๊ธฐ์ค ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ
}
}
// ์ฌ์ฉ
Arrays.sort(students, new NameComparator()); // ์ด๋ฆ ๊ธฐ์ค ์ ๋ ฌ
Arrays.sort(students, new ScoreComparator()); // ์ ์ ๊ธฐ์ค ์ ๋ ฌ
Comparable vs Comparator ๋น๊ต
ํน์ง | Comparable | Comparator |
---|---|---|
์ญํ | ํด๋์ค ๋ด๋ถ์ โ๊ธฐ๋ณธ ์ ๋ ฌ ๊ธฐ์คโ ์ ์ | ์ธ๋ถ์์ ๋ค์ํ ์ ๋ ฌ ๊ธฐ์ค ์ ์ |
๋ฉ์๋ | compareTo(T o) |
compare(T o1, T o2) |
์ฌ์ฉ ์์น | ์ ๋ ฌ ๋์ ํด๋์ค ๋ด๋ถ์์ ๊ตฌํ | ํด๋์ค ์ธ๋ถ์์ ๋ณ๋๋ก ์ ์ |
์ ๋ ฌ ๊ธฐ์ค ์ | ํ ๊ฐ์ง ์ ๋ ฌ ๊ธฐ์ค | ์ฌ๋ฌ ์ ๋ ฌ ๊ธฐ์ค |
์ฌ์ฉ ์ | Arrays.sort(arr) |
Arrays.sort(arr, comparator) |
๊ธฐ์กด ํด๋์ค ์์ ํ์ ์ฌ๋ถ | ํ์ (์ ๋ ฌ ๊ธฐ์ค ๋ณ๊ฒฝ ์ ํด๋์ค ์์ ) | ๋ถํ์ (ํด๋์ค๋ฅผ ์์ ํ์ง ์์๋ ์ ๋ ฌ ๊ธฐ์ค ์ถ๊ฐ ๊ฐ๋ฅ) |
๋ฌธ์์ด ์ ๋ ฌ ์์
์๋ฐ์ ์ ์ ์์ 11-19
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import java.util.*;
class ComparatorEx {
public static void main(String[] args) {
String[] strArr = {"cat", "Dog", "lion", "tiger"};
// ๊ธฐ๋ณธ ์ ๋ ฌ (Comparable ์ฌ์ฉ)
Arrays.sort(strArr);
System.out.println("Default Sort: " + Arrays.toString(strArr));
// ๋์๋ฌธ์ ๊ตฌ๋ถ ์๋ ์ ๋ ฌ
Arrays.sort(strArr, String.CASE_INSENSITIVE_ORDER);
System.out.println("Case-Insensitive Sort: " + Arrays.toString(strArr));
// ์ญ์ ์ ๋ ฌ (Comparator ์ฌ์ฉ)
Arrays.sort(strArr, new DescendingOrder());
System.out.println("Descending Sort: " + Arrays.toString(strArr));
}
}
class DescendingOrder implements Comparator<String> {
@Override
public int compare(String s1, String s2) {
return s2.compareTo(s1); // ์ญ์ ์ ๋ ฌ
}
}
๋ฌธ์ ํ๋ฉด์ ํท๊ฐ๋ ธ๋ ๋ถ๋ถ
Q. Arrays.sort(arr, fromIndex, toIndex)
fromIndex
: ์ ๋ ฌ์ ์์ํ ์ธ๋ฑ์ค.toIndex
: ์ ๋ ฌ์ ๋ฉ์ถ ์ธ๋ฑ์ค ๋ฐ๋ก ๋ค์ ์์น.- ์๋ฅผ ๋ค์ด,
Arrays.sort(arr, 0, 5)
๋ ๋ฐฐ์ด์ ์ธ๋ฑ์ค0
๋ถํฐ4
๊น์ง๋ฅผ ์ ๋ ฌํ๋ค.
์ฝ๋ฉํ ์คํธ ์ค๋นํ๋ฉด์ ํ๋์ ํ๋ซํผ์๋ง ์ต์ํ๋ค๋ณด๋, ๋น์ทํ ์ ํ์ ๋ฌธ์ ๋ฅผ ๋ง์ด ํ์๋ ๊ฒ ๊ฐ์๋ฐ ์ด๋ฒ์ ์ฝ๋ํธ๋ฆฌ๋ก ๋์ด์ค๋ฉด์ ์๋ฐ์ ๋ํด ๋ถ์กฑํ๋ ๋ถ๋ถ์ ์ฑ์ธ ์ ์์ด์ ์ข์ ๊ฒ ๊ฐ๋ค. ํ์ ์ด ๋ง๊ตฌ ๋๋ฌ๋๋๋ฏโฆ ๊ทธ๋๋ ์ฑ์๋๊ฐ์ผ์ง~ Comparable์ด๋ Comparator ์ค๋ฒ๋ผ์ด๋ฉํด์ ๊ตฌํ๋ ํ๊ฒ ๋์๋ค ์ด์ !
Leave a comment