์๋ก
๊ฐ์ฒด ๊ฐ์ sort๋ฅผ ์ํํ๋ ์ค Comparable์ด๋ผ๊ณ ํ๋ ๊ฒ๊ณผ Comparator๋ผ๊ณ ํ๋ ๊ฒ์ด ์กด์ฌํด ๋ ์ค ์ด๋ค ๊ฑธ ์ด๋ ์ํฉ์ ์จ์ผ ํ๋..๋ผ๋ ์๊ฐ์ผ๋ก ์์ฑํ๋ค.
๊ณตํต์
- ๋ชจ๋ ์ธํฐํ์ด์ค๋ค.
- ์ํ๋ ๊ฐ์ฒด์ ์ถ๊ฐํ๊ณ , ๊ฐ๊ฐ ์๊ตฌ๋ก ํ๋ ๋ฉ์๋(๋น๊ต ๋ฉ์๋)๋ฅผ ๊ตฌํํด์ฃผ๋ฉด ๋๋ค.
Comparable
- compareTo(T o) return: int
- ์๊ธฐ ์์ ๊ณผ ๋งค๊ฐ๋ณ์ ๊ฐ์ฒด๋ฅผ ๋น๊ตํ๋ค.
- ์๊ธฐ ์์ ์ ๊ธฐ์ค์ผ๋ก ๋ด๊ฐ ๋ ํฌ๋ฉด ์์, ์๋๊ฐ ๋ ํฌ๋ฉด ์์๋ฅผ ๋ฐํํ์ฌ ์ฌ์ฉํ๋ค.
- ๋ฌธ์์ด์ ๊ฒฝ์ฐ ์ข ๋ค๋ฅธ๋ฐ, ๊ธฐ์ค๊ฐ์ ๋น๊ต๋์์ด ํฌํจ๋์ด ์๋ค๋ฉด, ์๋ก์ ๋ฌธ์์ด ๊ธธ์ด์ ์ฐจ์ด๊ฐ์ ๋ฆฌํดํ๋ค.
- ๋ญ์๋ฆฌ๋ํ๋ฉด ์์๋ฅผ ๋ณด์
String str = "abcd";
System.out.println(str.compareTo("abcd")); // ๊ฐ๊ธฐ ๋๋ฌธ์ 0์ด ๋์จ๋ค.
System.out.println(str.compareTo("ab")); // abcd์์ ab๊ฐ ํฌํจ๋์ด ์๊ธฐ ๋๋ฌธ์ ๋ ๋ฌธ์์ด์ ์ฐจ์ด์ธ 2
System.out.println(str.compareTo("a")); // ๊ฐ์ ์ด์ ๋ก 1
System.out.println(str.compareTo("c")); //์ด ์น๊ตฌ๋ -2๊ฐ ๋์จ๋ค.
// ๊ฐ์ ์์น์ ๋ฌธ์๋ง ๋น๊ตํ๊ธฐ ๋๋ฌธ์, ์ฒซ๋ฒ์งธ ๋ฌธ์๋ฅผ ๋น๊ตํด ๋ค๋ฅด๋ฉด ์์คํค๊ฐ์ ๊ธฐ์ค์ผ๋ก ๋น๊ตํ๋ค.
Comparator
- compare(T o1, T o2)
- ๋ ๋งค๊ฐ๋ณ์ ๊ฐ์ฒด๋ฅผ ๋น๊ตํ๋ค
- compare๋ฅผ ์ค๋ฒ๋ผ์ด๋ฉํ ๊ฐ์ฒด๊ฐ ๋ณ๋๋ก ์กด์ฌํด์ผ ํ๋ค.
ํ์ง๋ง Comparator๋ฅผ ์ ๋ง ๋น๊ต์ฉ์ผ๋ก๋ง ์ฌ์ฉํ๊ธฐ ์ํด ๊ตณ์ด ๊ฐ์ฒด๋ฅผ ์ ์ธํ๊ธฐ์ ์๊น์ด ์ฌ๋๋ค์ ์ํด
์ต๋ช ๊ฐ์ฒด๋ฅผ ์์ฑํ์ฌ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์ด ์๊ฒผ๋ค.
์ต๋ช ๊ฐ์ฒด
- ๋ง ๊ทธ๋๋ก ์ด๋ฆ์ด ์ ์๋์ง ์์ ๊ฐ์ฒด๋ค.
- ์ฃผ๋ก ํน์ ๊ตฌํ ๋ถ๋ถ๋ง ์ฌ์ฉํ๊ฑฐ๋, ์ค๊ฐ์ ์์ ๋ ์ฝ๋๋ฅผ ์ ๊น ์ด์ฉํ ๋ ์ฌ์ฉ๋๋ค.
public static void main(String[] args) {
Person a = new Person();
// ์ต๋ช
๊ฐ์ฒด ์ ์ธ!!
Person b = new Person() {
int age;
@Override
int get() {
return age;
}
};
System.out.println(a.get());
System.out.println(b.get());
}
//////
class Person{
String name;
int height;
int get(){
return height;
}
}
ํด๋น ์ฝ๋๋ฅผ ์ดํด๋ณด๋ฉด b์๋ Person์ ๊ฐ์ฒด๋ฅผ ์ด์ด๋ฐ์ get()์ ์ค๋ฒ๋ผ์ด๋ฉ ํ์ง๋ง, ํด๋น ๊ฐ์ฒด์ ์ด๋ฆ์ ๋ฐ๋ก ์ง์ ๋์ด์์ง ์์๋ฐ, ์ด๋ฌํ ๊ฐ์ฒด๊ฐ ์ต๋ช ๊ฐ์ฒด๋ค.
์ฌ๊ธฐ์ ์ดํด๋ณผ ์ ์ ์ b์ ์ ์ฅ๋ ์ต๋ช ๊ฐ์ฒด๋ ๊ธฐ์กด์ Person์ด ๊ฐ์ง๊ณ ์๋ name๊ณผ height ์ธ์ age๋ผ๋ ๋ณ์๊ฐ ์ถ๊ฐ๋์๋ค. ์ด๋์ ๋ง์ด ๋ณธ ๋ฐฉ์์ธ๋ฐ.. ํ๊ณ ์๊ฐํด ๋ณด๋ฉด ์์๋ ํด๋์ค์ ๊ฐ์ ํํ๋ผ๊ณ ๋ณผ ์ ์๋ค.
์์ฑ๋๋ ์ต๋ช ๊ฐ์ฒด๋ ๊ธฐ์กด ํด๋์ค์ ์์ ๊ด๊ณ์ด๋ผ๋ ๋ง์ด ๋๋ค.
์ต๋ช ๊ฐ์ฒด๋ก Comparator ๊ตฌํํ๊ธฐ
์ต๋ช ๊ฐ์ฒด๊ฐ ๋ญ ํ๋ ๊ฐ์ฒด์ธ์ง๋ ์์๊ณ , Comparator๊ฐ ์ด๋ค ๋ฐฉ์์ผ๋ก ๋์๊ฐ๋์ง๋ ์์๋ณด์๋ค. ์ด์ ์ด ๋์ ์ ์ฎ์ด์ Comparator๋ผ๋ ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ ์ต๋ช ๊ฐ์ฒด๋ฅผ ๋ง๋ค์ด ๋ ๊ฐ์ฒด๋ฅผ ๋น๊ตํด ์ฃผ๋ compare ๋ฉ์๋๋ฅผ ๊ตฌํํ๊ฒ ๋๋ฉด compare๋ฅผ ์์ ๋กญ๊ฒ ์ฌ์ฉํ ์ ์๊ฒ ๋๋ ๊ฒ์ด๋ค.
public static void main(String[] args) {
Person a = new Person("ํธ๋ ๋", 186);
Person b = new Person("๋ฉ์", 170);
Comparator<Person> comp = new Comparator<Person>() {
@Override
public int compare(Person p1, Person p2){
return p1.height - p2.height;
}
};
System.out.println(comp.compare(a, b));
}
//////
class Person{
String name;
int height;
Person(String name, int height){
this.name = name;
this.height = height;
}
}
์ด๋ฐ ๋ฐฉ์์ ์ฅ์ ์ ๋ฐ๋ก ๊ฐ์ฒด๋ฅผ ๋ง๋๋ ๊ฒ์ด๊ธฐ ๋๋ฌธ์ ์ฌ๋ฌ ๋ณ์์ ๋ํด ๋น๊ต ๋ฉ์๋๋ฅผ ๊ตฌํํ ์ ์๋ค๋ ์ ์ด ์๋ค.
์๋งคํ์ผ๋ก ์ ๋ ฌ์ ์ด์ฉํ ๋, Arrays.sort(arr, comp)์ ๊ฐ์ด ์ต๋ช ๊ฐ์ฒด๋ฅผ ํ๋ผ๋ฏธํฐ๋ก ์ฌ์ฉํ์ฌ ์ ๋ ฌ์ ์ํํ๋ ๋ฐฉ๋ฒ๋ ์๋ค.
์ ๋ ฌ ๊ฟํ(?)
- ์ ๋ ฌ์ ๊ธฐ๋ณธ์ ์ผ๋ก ๋ ์๋ฅผ ๋น๊ตํด์ ์์ ๋๋ ์์์ ๋ฐ๋ผ ๊ตํ์ด ์ด๋ฃจ์ด์ง๋ค.
- ์๋ฐ๋ ๊ธฐ๋ณธ์ ์ผ๋ก ์ค๋ฆ์ฐจ์์ ์งํฅํ๊ณ ์๋ค.
- a - b๊ฐ ์์๋ผ๋ฉด a๊ฐ ๋ ์๊ธฐ ๋๋ฌธ์ ๊ตํ์ ํ์ง ์๋๋ค.
- a - b๊ฐ ์์๋ผ๋ฉด a๊ฐ ๋ ํฌ๊ธฐ ๋๋ฌธ์ ๊ตํ์ด ์ด๋ฃจ์ด์ง๋ค.
a - b์ ๊ฒฐ๊ณผ ๋ถํธ๋ฅผ ๋ฐ๊ฟ์ค๋ค๋ฉด? => ๋ด๋ฆผ์ฐจ์์ด ๋๋ ๊ฒ์ด๋ค.
'Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[JAVA] Stream API (0) | 2024.07.25 |
---|---|
[JAVA] Lambda (0) | 2024.07.24 |
[JAVA] Generic (3) | 2024.07.22 |
[JAVA] ์ถ์ (1) | 2024.07.20 |
[JAVA] ๋คํ์ฑ (2) | 2024.07.18 |