Comparable vs Comparator
Comparable interface
์ ๋ ฌ ๊ธฐ์ค์ ์ ์ํ๋ 2๊ฐ์ง ๋ฐฉ๋ฒ ์ค ํ๋.
์ ๋ ฌ ๋์ ํด๋์ค๋ฅผ ์๋ฐ์์ ๊ธฐ๋ณธ์ ์ผ๋ก ์ ๊ณตํ๋
Comparable
์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ๋๋ก ๋ณ๊ฒฝ.Comparable
์ธํฐํ์ด์ค์compareTo()
๋ฉ์๋๋ฅผ ํตํด์, ์ธ์๋ก ๋์ด์จ ๊ฐ์ ํ์ ์ ๋ค๋ฅธ ๊ฐ์ฒด์ ๋์ ๋น๊ต๊ฐ ๊ฐ๋ฅ.return ๊ฐ์ผ๋ก
Integer.compare(a, b)
,Double.compare(a,b)
๋ฑ์ด ์ฌ์ฉ ๊ฐ๋ฅํ๋ฐ,Integer.compare
ํจ์์ํ์ ์๋์ ๊ฐ๋ค.public static int compare(int x, int y){ return (x>y) ? -1 : ((x==y)? 0 : 1); }
Integer.compare()
์ ๋จ์ํ ์ฒซ๋ฒ์งธ ๋งค๊ฐ๋ณ์์ ๋๋ฒ์งธ ๋งค๊ฐ๋ณ์๊ฐ ์ค๋ฆ์ฐจ๋ฅผ ์ ์งํ ์ ์๋๋ก ๋น๊ตํด์ฃผ๋ ๋ฉ์๋์ด๋ค.์ ๋ ฌ์ด ์งํ ๋ ๋, ์๋ฆฌ๋ฐ๊ฟ ์ฌ๋ถ๋ฅผ ๊ฒฐ์ ํ๊ณ , return ๊ฐ์ด ์์์ผ ๋ ์๋ฆฌ๋ฐ๊ฟ์ ์ํํ๋ค.
๋ด๋ฆผ์ฐจ๋ฅผ ์ฌ์ฉํ๊ณ ์ถ์ ๋๋
compare(int y , int x)
๋ก ๋งค๊ฐ๋ณ์์ ์์๋ง ๋ฐ๊ฟ์ฃผ๋ฉด๋๋ค.์์
//์ค๋ฆ์ฐจ class A implements Comparable <A> { int x; A(int x){ this.x = x; } public int compareTo(A other){ return Integer.compare(this.x, other.x); } }
Integer.compare()
๋์ ์ง์ ๊ตฌํํด๋ ๋๋ค.์์
//์ค๋ฆ์ฐจ class A implements Comparable<A>{ int x; public int compareTo(A other){ //์์์ผ ๊ฒฝ์ฐ์๋ง ์๋ฆฌ ๋ฐ๊ฟ return this.x - other.x; } } //๋ด๋ฆผ์ฐจ class A implements Comparable<A>{ int x; public int compareTo(A other){ return other.x - this.x; } }
Comparator
์ ๋ ฌ ๋์ ํด๋์ค์ ์ฝ๋๋ฅผ ์ง์ ์์ ํ ์ ์๋ ๊ฒฝ์ฐ์ ์ฌ์ฉ
ํน์ ์ ๋ ฌํ๊ณ ์ ํ๋ ๊ฐ์ฒด์ ์ด๋ฏธ ์กด์ฌํ๊ณ ์๋ ์ ๋ ฌ ๊ธฐ์ค๊ณผ ๋ค๋ฅธ ์ ๋ ฌ ๊ธฐ์ค์ ์ฌ์ฉํ๊ณ ์ถ์ ๋.
Arrays.sort()
,Collections.sort()
์ ๊ฐ์ ์ ๋ ฌ ๋ฉ์๋์ ์ถ๊ฐ ์ธ์๋ก ์ฌ์ฉํด์ ์ ๋ ฌ๊ธฐ์ค์ ๋๋ฝ๋ ํด๋์ค์ ๊ฐ์ฒด๋, ๊ธฐ์กด์ ์ ๋ ฌ ๊ธฐ์ค์ ๋ฌด์ํ๊ณ ์๋ก์ด ์ ๋ ฌ ๊ธฐ์ค์ผ๋ก ๊ฐ์ฒด ์ ๋ ฌ์ด ๊ฐ๋ฅ.์์(Programmers, ๊ฐ์ฅ ํฐ ์ ๋ฌธ์ ์์ ๊ฐ์ ธ์ด.)
Arrays.sort(numStr, new Comparator<String>() { @Override public int compare(String a, String b) { //์ฌ๊ธฐ์ compareTo๋ String์ด ๊ฐ์ง ๊ธฐ๋ณธ ๋ฉ์๋ return (a+b).compareTo(b+a); } });
๊ธฐ๋ณธ ์ ๋ ฌ ๊ธฐ์ค๊ณผ ๋ค๋ฅธ ์๋ก์ด ์ ๋ ฌ ๊ธฐ์ค์ ์ธ์ธ ๋ ์ฌ์ฉ. ์ฃผ๋ก ์ต๋ช ํด๋์ค.
์ถ๊ฐ
๋๋ค์์ผ๋ก ์ ๋ ฌํ๊ธฐ (js์์ ํจ์ํ์ ์ต์ํด์ ธ์, ์ฝ๊ธฐ ํธํ๋ค!!)
Arrays.sort(numStr, (a, b) -> (b+a).compareTo(a + b));
์ฐธ์กฐ ๋งํฌ
Last updated
Was this helpful?