Java์์ comparable๋ก ์ ๋ ฌ ๊ธฐ์ค ๋ฐ๊พธ๊ธฐ
์๋ฐ๋ก ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ํ์ด๋ฅผ ํ๋ค ๋ณด๋ฉด ํน์ ์กฐ๊ฑด์ ์ํ ์ ๋ ฌ์ ์ํํ ๋๊ฐ ์๋ค.
๊ธฐ๋ณธ์ ์ผ๋ก ์๋ฐ์์๋ ์ ๋ ฌ์ ์ํด์ Arrays.sort()
์ static ๋ฉ์๋๋ ,Collections.sort()
์ static ๋ฉ์๋๋ฅผ ์ ๊ณตํ์ง๋ง, ์ด๋ ๊ธฐ๋ณธ ์ ๋ ฌ์ธ ์ค๋ฆ์ฐจ์ ์ ๋ ฌ์ ์ ๊ณตํ๊ธฐ ๋๋ฌธ์ ํน์ ์กฐ๊ฑด์ ์ํ ์ ๋ ฌ(๋ค์ฐจ์ ๋ฐฐ์ด์ ์ ๋ ฌ, ๊ฐ์ฒด ์ ๋ ฌ, ์กฐ๊ฑด ์ ๋ ฌ)์ ์ํํ๊ธฐ๋ ๋ถ๊ฐ๋ฅํ๋ค.
์ด ๋ถํธํจ์ ํด์ํด๊ธฐ ์ํด ๋ ๊ฐ์ง์ ์กฐ๊ฑด ์ ๋ ฌ ๋ฐฉ์์ด ์กด์ฌํ๋๋ฐ ๋ฐ๋ก Comparator, Comparable ์ธํฐํ์ด์ค๋ฅผ ์ด์ฉํ ์ ๋ ฌ ๋ฉ์๋ ์ฌ์ ์์ด๋ค.
ํ์ง๋ง ๋ ์ธํฐํ์ด์ค ๊ฐ์ ์ฌ์ฉ ๋ชฉ์ ์ ๋ฐ๋ฅธ ์ฐจ์ด๊ฐ ์กด์ฌํ๊ธฐ ๋๋ฌธ์ ๊ทธ ์ฐจ์ด๋ถํฐ ๋ช ํํ๊ฒ ์ง๊ณ ๋์ด๊ฐ์.
Comparator vs Comparable
Comparable
comparable
์ธํฐํ์ด์ค๋ฅผ ์ด์ฉํ ์ ๋ ฌ์ ๋ค์๊ณผ ๊ฐ์ ๋ชฉ์ ์ด ์์ ๋ ์ฌ์ฉํ๋ค.
- ๊ฐ์ฒด์ ํน์ field๋ฅผ ์ด์ฉํ ์ค๋ฆ์ฐจ์, ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ์ ์ํ ๊ฒฝ์ฐ
- ๊ธฐ๋ณธ ์ ๋ ฌ ๊ธฐ์ค ์ค์ ์ ๋ณ๊ฒฝ์ ์ํ ๊ฒฝ์ฐ
Comparator
comparator
์ธํฐํ์ด์ค๋ฅผ ์ด์ฉํ ์ ๋ ฌ์ ๋ค์๊ณผ ๊ฐ์ ๋ชฉ์ ์ด ์์ ๋ ์ฌ์ฉํ๋ค.
- ๊ฐ์ฒด์ ํน์ field๋ฅผ ์ด์ฉํ์ฌ ํน์ ๊ธฐ์ค์ผ๋ก ์ ๋ ฌ์ ์ํ ๊ฒฝ์ฐ
- ๊ธฐ๋ณธ ์ ๋ ฌ ๊ธฐ์ค(์ค๋ฆ์ฐจ์, ๋ด๋ฆผ์ฐจ์)์ ๊ธฐ์ค์ด ์๋ ๋ค๋ฅธ ๊ธฐ์ค์ผ๋ก ์ ๋ ฌ์ ์ํ ๊ฒฝ์ฐ
Comparator
comparator
๋ํ comparable
๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ์ ๋ ฌ ๊ธฐ์ค์ ๋ค๋ฅด๊ฒ ํ๊ณ ์ถ์ ๋ ์ฌ์ฉํ๋ค.
ํ์ง๋ง ์ฐจ์ด์ ์ด๋ผ๊ณ ํ๋ฉด comparabl์ ์ ๋ ฌ ๊ธฐ์ค์ด ์ผ๋ฐ์ ์ผ ๊ฒฝ์ฐ(๋ด๋ฆผ์ฐจ์) ์ผ๋ ์ฌ์ฉํ์ง๋ง comparator์ ์ ๋ ฌ ๊ธฐ์ค์ด ์ผ๋ฐ์ ์ด์ง ์์ ๋(๋ฌธ์์ด์ ๊ธธ์ด๋ฅผ ๋น๊ตํ์ฌ ์ค๋ฆ์ฐจ์, ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ์ํ ๋) ์ฌ์ฉํ๋ ๊ฒฝ์ฐ๊ฐ ๋ง๋ค.
์ ๋ ฌ ๊ธฐ์ค
์ฒซ ๋ฒ์จฐ ํ๋ผ๋ฏธํฐ์ ๊ฐ๊ณผ ๋ ๋ฒ์งธ ํ๋ผ๋ฏธํฐ์ ๊ฐ์ ๋น๊ตํ์ฌ -1, 0, 1์ return ํ์ฌ ์ ๋ ฌํ๋ค
๋ฅผ ํ์ด์ ๋ณด์๋ฉด,
- o1 < o2 ์ธ ๊ฒฝ์ฐ๋ ์์๋ฅผ return
- o1 = o2 ์ธ ๊ฒฝ์ฐ๋ 0 ์ return
- o1 > o2 ์ธ ๊ฒฝ์ฐ๋ ์์๋ฅผ return
๋ฐํ ๊ฐ์ด ์์, 0 ์ด๋ฉด ๊ฐ์ฒด์ ์๋ฆฌ๋ฅผ ๋ณ๊ฒฝํ์ง ์๊ณ ์์์ด๋ฉด ๊ฐ์ฒด์ ์๋ฆฌ๋ฅผ ๋ณ๊ฒฝํ๋ค.
ํด๋์ค์์ comparator
์ธํฐํ์ด์ค๋ฅผ implements ํ๋ ๋ฐฉ๋ฒ๋ ์กด์ฌํ์ง๋ง comparetor
์ ์ต๋ช
ํจ์๋ก ์ ์๋ฅผ ์์ฃผ ํ๋ค.
์ด ์์ ๋ ๋ฐ๋ก ๋ฌธ์ ๋ฅผ ํตํด์ ์์๋ณด์
compare()
์์ ์ ๋ ฌ ๊ธฐ์ค์ ๋ณด๋ฉด o1 < o2 ์ธ ๊ฒฝ์ฐ ์์๋ฅผ return ํ๋ค๊ณ ๋์ด์๋๋ฐ, ์ด๋ฅผ ๋ฐ๊ฟ์ ์ฌ์ฉํ๋ฉด o1 - o2 > 0
๊ณผ ๊ฐ๋ค.
ํ์ง๋ง ์ด์ ๋ฐ๋๋ก ๋ด๋ฆผ ์ฐจ์์ผ๋ก ์ ๋ ฌ์ ์ํ๋ฉด ๋น์ฐํ๊ฒ return ๊ฐ์ ๋ฐ๋๋ก ๋ฃ์ด์ฃผ๋ฉด ๋๋ค.
๋๋ค๋ฅผ ์ด์ฉํ์ฌ ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ํ์ด์์ ์ฐ์ํ๊ฒ ์ฌ์ฉํ๊ธฐ
์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ํ์ด์์๋ ์ฌ๋ฌ ๋ก์ง์ด ํจ๊ป ๋ฑ์ฅํ๊ธฐ ๋๋ฌธ์ ๊ฐ๋ ์ฑ์ด ์๊ตฌ๋๋ค.
๊ทธ๋์ ์์ Comparator๊ณผ Comparable ์ sort()
๋ฉ์๋๊ฐ ํธ์ถ๋ ๋ ํ๋ผ๋ฏธํฐ๋ก ์ต๋ช
ํจ์๋ฅผ ๋๊ธฐ๋ ์ฝ๋๋ฅผ ๋ด๋ณด์.
์๋ฅผ ๋ค์ด 2์ฐจ์ ๋ฐฐ์ด์ ์ ๋ ฌํ๋ค๊ณ ํด๋ณด์.
int[][] arr = {
{8, 14},
{3, 5},
{5, 20},
{1, 16},
};
์ด๋ผ๋ ๋ฐฐ์ด์ด ์๋ค๊ณ ๊ฐ์ ํ์ ๋, ๋ฐฐ์ด์ 2๋ฒ ์งธ ์์๋ฅผ ๊ธฐ์ค์ผ๋ก ์ ๋ ฌ์ ํ๋ค๊ณ ํ๋ฉด, ๋ค์๊ณผ ๊ฐ์ ์ฝ๋๊ฐ ๋์ฌ ์ ์๋ค
int[][] arr = {
{8, 14},
{3, 5},
{5, 20},
{1, 16},
};
Arrays.sort(arr, (a1, a2) -> a1[1] - a2[1]);
System.out.println(Arrays.deepToString(arr));
// [[3, 5], [8, 14], [1, 16], [5, 20]]
์ด ํ ์ค์๋ ๋๋ค๋ก ์ฐ์ฌ์ ธ ์์ง๋ง ์ต๋ช ํจ์๋ฅผ ํ์ด์ฐ์๋ฉด ๋ค์๊ณผ ๊ฐ๋ค.
int[][] arr = {
{8, 14},
{3, 5},
{5, 20},
{1, 16},
};
Arrays.sort(arr, new Comparator<int[]>() {
@Override
public int compare(int[] a1, int[] a2) {
return a1[1] - a2[1];
}
});
System.out.println(Arrays.deepToString(arr));
// [[3, 5], [8, 14], [1, 16], [5, 20]]
๊ณผ ๊ฐ์๋ฐ, ์ต๋ช ํจ์ ๋ฅผ ๋ ์์ ๋ฐฐ์ด ํํ๋ก ํ์ด์ฐ์๋ฉด ๋ค์๊ณผ ๊ฐ๋ค.
int[][] arr = {
{8, 14},
{3, 5},
{5, 20},
{1, 16},
};
Comparator<int[]> comparator = new Comparator<int[]>() {
@Override
public int compare(int[] a1, int[] a2) {
return a1[1] - a2[1];
}
};
Arrays.sort(arr, comparator);
System.out.println(Arrays.deepToString(arr));
// [[3, 5], [8, 14], [1, 16], [5, 20]]
์ด๋ ๊ฒ ๋ณธ๋ค๋ฉด ๋ฌธ์ ํ์ด์์ ํ ์ค๋ก ์ฐ๋ ๋๋ค์์ด ์ผ๋ง๋ ํจ์จ์ ์ธ์ง ์ ์ ์์ ๊ฒ์ด๋ค.
์ด์ ๊ด๋ จํ ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ๋ก๋
- ๋ฐฑ์ค 1263 ์๊ฐ ๊ด๋ฆฌ ๋ฌธ์ ํ์ด
- ๋ฐฑ์ค 11651 ์ขํ ์ ๋ ฌํ๊ธฐ 2 ๋ฌธ์ ํ์ด
- ๋ฐฑ์ค 10814 ๋์ด์ ์ ๋ ฌ ๋ฌธ์ ํ์ด
- ๋ฐฑ์ค 10825 ๊ตญ์์ ๋ฌธ์ ํ์ด
๊ฐ ์์ผ๋ ์ฐ์ต ์ผ์ ํ์ด๋ณด๋ ๊ฒ๋ ์ข์ ์ ํ์ด๋ค.
๋๊ธ