๐ Comparable & Comparator
- Comparable๊ณผ Comparator๋ ๋ชจ๋ ์ธํฐํ์ด์ค์ด๋ค.
- ์ฆ, ์ฌ์ฉํ๊ณ ์ ํ๋ค๋ฉด ์ธํฐํ์ด์ค ๋ด์ ์ ์ธ๋ ๋ฉ์๋๋ฅผ ๋ฐ๋์ ๊ตฌํ ํด์ผํ๋ค.
๋ณดํต Comparable ์ธํฐํ์ด์ค์๋ compareTo(T o) ๋ฉ์๋ ํ๋๊ฐ ์ ์ธ๋์ด์๋ค. ์ด๊ฒ์ compareTo ๋ฉ์๋๋ฅผ ์ฌ์ ์(Override)ํด์ผ ํ๋ค๋ ๊ฒ์ด๋ค.
Comparator์ธํฐํ์ด์ค๋ฅผ ์ฌ์ฉํ๋ ค๋ฉด compare ๋ฉ์๋๋ฅผ ๊ตฌํํด์ผ ํ๊ณ , Comparable ์ธํฐํ์ด์ค๋ฅผ ์ฌ์ฉํ๋ ค๋ฉด compareTo ๋ฉ์๋๋ฅผ ๊ตฌํํด์ผํ๋ค.
โ Comparable & Comparator
" ๊ฐ์ฒด๋ฅผ ๋น๊ตํ ์ ์๋๋ก ๋ง๋ ๋ค "
Why ? ์๋๋ byte, int, double ๋ฑ ๋ถ๋ฑํธ๋ฅผ ํตํด ์ฝ๊ฒ ๋ ๋ณ์๋ฅผ ๋น๊ตํ ์ ์๋ค.
ํ์ง๋ง ์๋ก์ด ํด๋์ค ๊ฐ์ฒด๋ฅผ ๋น๊ตํ๋ค๋ฉด ? ์๋ฅผ ๋ค์ด, ํ์์ ๋์ด์ ํ๊ธ ์ ๋ณด๋ฅผ ๊ฐ๊ณ ์๋ ํด๋์ค์์ ๋ ๊ฐ์ฒด (a,b)๋ฅผ ๋น๊ตํ๋ ค๋ฉด ์ด๋ป๊ฒ ํ ๊ฒ์ธ๊ฐ? ๋์ด๋ฅผ ๊ธฐ์ค์ผ๋ก ํ ์๋์๊ณ , ํ๊ธ์ ๊ธฐ์ค์ผ๋ก ํ ์๋์๋ค.
์ฆ, Comparable๊ณผ Comparator๋ฅผ ์ฌ์ฉํ๋ ์ด์ ๋ '๊ธฐ์ค'์ ์ ํด ์ ๋ ฌ์ ํ ์ ์๊ธฐ ๋๋ฌธ์ด๋ค.
public interface Comparable<T> {
public int compareTo(T o)
}
public interface Comparator<T> {
int compare(T o1, T o2)
}
Comparable์ ์๊ธฐ ์์ ๊ณผ ๋งค๊ฐ๋ณ์ ๊ฐ์ฒด๋ฅผ ๋น๊ตํ๊ณ // compareTo(T o)
Comparator๋ ๋ ๋งค๊ฐ๋ณ์ ๊ฐ์ฒด๋ฅผ ๋น๊ตํ๋ค. // Compare(T o1, T o2)
CompareTo()์ ๋ฐํ ๊ฐ์ Int์ง๋ง ๋ ๊ฐ์ฒด๊ฐ ๊ฐ์ผ๋ฉด 0, ๋น๊ตํ๋ ๊ฐ๋ณด๋ค ํฌ๋ฉด ์์, ์์ผ๋ฉด ์์๋ฅผ ๋ฐํํ๋๋ก ๊ตฌํํด์ผํ๊ณ ,
Compare()๋ ๊ฐ์ฒด๋ฅผ ๋น๊ตํด์ ์์, 0, ์์ ์ค ํ๋๋ฅผ ๋ฐํํ๋๋ก ๊ตฌํํด์ผ ํ๋ค.( ์ค๋ฅธ์ชฝ์ด ํฌ๋ฉด ์์, ์์ผ๋ฉด ์์ )
> Comparable์ lang ํจํค์ง์ ์๊ธฐ ๋๋ฌธ์ import๋ฅผ ํด์ค ํ์๊ฐ ์์ง๋ง, Comparator๋ util ํจํค์ง์ ์๋ค.
Comparable
์๊ธฐ ์์ ๊ณผ ๋งค๊ฐ๋ณ์ ๊ฐ์ฒด๋ฅผ ๋น๊ตํ๋ค.
public class ClassName implements Comparable<Type> {
// ํ์ ๊ตฌํ
public int compareTo(Type o) {
/*
๋น๊ต๊ตฌํ
*/
}
}
> ์์
class Student implements Comparable<Student> {
int age;
int class;
Student(int age, int classNumber) {
this.age = age;
this.classNumber = classNumber;
}
@Override
public int compareTo(Student o) {
// ์๊ธฐ์์ ์ age๊ฐ o์ age๋ณด๋ค ํฌ๋ค๋ฉด ์์
if(this.age > o.age) {
return 1;
}
// ์๊ธฐ ์์ ์ age์ o์ age๊ฐ ๊ฐ๋ค๋ฉด 0
else if(this.age == o.age) {
return 0;
}
// ์๊ธฐ ์์ ์ age๊ฐ o์ age๋ณด๋ค ์๋ค๋ฉด ์์
else {
return -1;
}
}
}
compareTo๋ int๊ฐ์ ๋ฐํํด์ผ ํ๋๋ฐ, "์๊ธฐ ์์ ์ ๊ธฐ์ค์ผ๋ก ์๋๋ฐฉ๊ณผ ์ผ๋ง๋ ์ฐจ์ด๊ฐ ๋๋๋"๋ฅผ ๊ธฐ์ค์ผ๋ก ๋ฐํํ๋ค.
๊ผญ 1, -1๋ก ๋ฐํํ์ง ์๊ณ ์์, ์์๋ก ๋ฐํํด๋ ๋๊ธดํ์ง๋ง ์ถ์ฒ๋๋ ๋ฐฉ๋ฒ์ ์๋๋ค.
๋ ์์ ์ฐจ๋ฅผ ๋ฐํํ๋ ๋ฐฉ๋ฒ๋ ์๋ค. ํ์ง๋ง ์ด ๋ฐฉ๋ฒ์ ์๋ชป ์ฌ์ฉํ๋ฉด UnderFlow ๋๋ OverFlow๊ฐ ๋ฐ์ํ ์ ์์ด ์ ์ฝ๋์ฒ๋ผ <, >, = ๋ก ๋์ ๋น๊ต๋ฅผ ํ๋๊ฒ ์ผ๋ฐ์ ์ด๋ค.
Comparator
๋ ๋งค๊ฐ๋ณ์ ๊ฐ์ฒด๋ฅผ ๋น๊ตํ๋ค.
import java.util.Comparator; // import ํ์
public class ClassName implements Comparator<Type> {
// ํ์ ๊ตฌํ ๋ถ๋ถ
@Override
public int compare(Type o1, Type o2) {
/*
๋น๊ต ๊ตฌํ
*/
}
}
> ์์
import java.util.Comparator; // import ํ์
class Student implements Comparator<Student> {
int age;
int class;
Student(int age, int classNumber) {
this.age = age;
this.classNumber = classNumber;
}
@Override
public int compare(Student o1, Student o2) {
// o1์ ํ๊ธ์ด o2์ ํ๊ธ๋ณด๋ค ํฌ๋ค๋ฉด ์์
if(o1.classNumber > o2.classNumber) {
return 1;
}
// o1์ ํ๊ธ์ด o2์ ํ๊ธ๊ณผ ๊ฐ๋ค๋ฉด 0
else if(o1.classNumber == o2.classNumber) {
return 0;
}
// o1์ ํ๊ธ์ด o2์ ํ๊ธ๋ณด๋ค ์๋ค๋ฉด ์์
else {
return -1;
}
}
}
๋งค๊ฐ๋ณ์๋ก ๋ค์ด์ค๋ ๋ ๊ฐ์ฒด o1, o2๋ฅผ ๋น๊ตํ๋ค.
a.compare ๋ฉ์๋์์ a์ ๋น๊ตํ๊ณ ์ถ๋ค๋ฉด
a.compare(a,b); ๋ก ํ๋ฉด๋๋ค.
https://st-lab.tistory.com/243?category=830901
์๋ฐ [JAVA] - Comparable ๊ณผ Comparator์ ์ดํด
์๋ง ์ด ๊ธ์ ์ฐพ์ ์ค์ ๋ถ๋ค ๋๊ฐ๋ Comparable๊ณผ Comparator์ ์ฐจ์ด๊ฐ ๋ฌด์์ธ์ง ๋ชจ๋ฅด๊ฑฐ๋ ๊ถ๊ธํด์ ์ฐพ์์ค์ จ์ ๊ฒ์ด๋ค. ์ฌ์ค ์๊ณ ๋ณด๋ฉด ๋ ๊ฐ๋ ๊ทธ๋ ๊ฒ ์ด๋ ต์ง ์์ผ๋ ์๋ฌด๋๋ ์๋ฐ๋ฅผ ํ์ตํ๋ฉด์ ๊ฐ
st-lab.tistory.com
ํด๋น ์ฃผ์์์ ์ฐธ๊ณ ํ์์ผ๋ฉฐ, ๋ ์์ธํ ๋ด์ฉ์ ํด๋น ๋งํฌ์์ ํ์ธํ์๊ธธ๋ฐ๋ผ๊ฒ ์ต๋๋ค.
'๐ ์ฝ๋ฉํ ์คํธ > JAVA' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[JAVA] DFS & BFS ์ ๋ฆฌ (2) | 2024.01.11 |
---|---|
[JAVA] ์คํํ๋ ์ & ์ฌ๊ทํจ์ (1) | 2024.01.11 |
[JAVA][์๋ฃ๊ตฌ์กฐ] ํธ๋ฆฌ์ ( TreeSet ) (0) | 2023.12.12 |
[JAVA] HashSet (0) | 2023.04.05 |
[JAVA][์๊ณ ๋ฆฌ์ฆ] ๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ ( Greedy Algorithm ) (0) | 2023.02.09 |