์ด๋ฒ ๊ธ์ ํตํด Comparable์ ์ด๋ป๊ฒ ๊ตฌํํ๋ฉด ์ข์์ง ์์๋ณด๊ณ ์ ํ๋ค. ์ฐ์ ์ 'compareTo ๊ท์ฝ'์ ๋ํด์ ์์๋ณด๊ณ 'compareTo๋ฅผ ๊ตฌํํ๋ 2๊ฐ์ง ๋ฐฉ๋ฒ'์ ๋ํด์ ์์๋ณผ ๊ฒ์ด๋ค. (๋ง์ฝ Comparable์ ๋ํ ๊ธฐ๋ณธ์ง์์ด ํ์ํ๋ค๋ฉด ์ด์ ๊ธ์ ์ฐธ๊ณ ํ๊ธฐ ๋ฐ๋๋ค.)
๋ค์ด๊ฐ๊ธฐ์ ์์ Comparable ์ธํฐํ์ด์ค์ ์ ์ผ๋ฌด์ดํ ๋ฉ์๋์ธ compareTo์ ํน์ง์ ๋ํด์ ํ๋ฒ ์ดํด๋ณด์. ์ด๋ ์๋์ 2๊ฐ์ง๋ง ๋นผ๋ฉด Object.equals์ ๊ฐ๋ค.
- ๋จ์ ๋์น์ฑ ๋น๊ต์ ๋ํด์ ์์๊น์ง ๋น๊ตํ ์ ์๋ค.
- Generic์ ์ง์ํ๋ค.
1. compareTo ๊ท์ฝ ๐ช
sgn(ํํ์) ํ๊ธฐ๋ ์ํ์์ ๋งํ๋ ๋ถํธ ํจ์๋ฅผ ๋ปํ๋ฉฐ, ํํ์์ ๊ฐ์ด ์์, 0, ์์ ์ผ ๋ -1, 0, 1์ ๋ฐํํ๋๋ก ์ ์ํ๋ค.
- ๋ฐ์ฌ์ฑ
x.compareTo(y) == 0 ์ด๋ฉด sgn(x.compareTo(z)) == sgn(y.compareTo(z)) - ๋์นญ์ฑ
sgn(x.compareTo(y)) == -sgn(y.compareTo(x)) - ์ถ์ด์ฑ
(x.compareTo(y) > 0 && y.compareTo(z) > 0)์ด๋ฉด x.compareTo(z) > 0์ด๋ค. - equals๋ ํ์๋ ์๋์ง๋ง ๊ผญ ์งํค๋ ๊ฒ ์ข๋ค.
(x.compareTo(y) == 0) == (x.equals(y))
Comparable์ ๊ตฌํํ๊ณ ์ด ๊ถ๊ณ ๋ฅผ ์งํค์ง ์๋ ๋ชจ๋ ํด๋์ค๋ ๊ทธ ์ฌ์ค์ ๋ช ์ํด์ผ ํ๋ค.
compareTo์ equals๊ฐ ์ผ๊ด๋์ง ์๋ ์์๋ก๋ BigDecimal ํด๋์ค๊ฐ ์๋ค.
public static void main(String[] args) {
BigDecimal oneZero = new BigDecimal("1.0");
BigDecimal oneZeroZero = new BigDecimal("1.00");
System.out.println(oneZero.compareTo(oneZeroZero)); // 0
System.out.println(oneZero.equals(oneZeroZero)); // false
}
2. ์ ์ compare ๋ฉ์๋ ๐ก
compareTo๋ฅผ ๊ตฌํํ๋ ์ฒซ ๋ฒ์งธ ๋ฐฉ์์ '์ ์ compare ๋ฉ์๋'๋ฅผ ์ด์ฉํ๋ ๊ฒ์ด๋ค.
public int compareTo(PhoneNumber pn) {
int result = Short.compare(areaCode, pn.areaCode); // ๊ฐ์ฅ ์ค์ํ ํ๋
if (result == 0) {
result = Short.compare(prefix, pn.prefix); // ๋ ๋ฒ์งธ๋ก ์ค์ํ ํ๋
if (result == 0)
result = Short.compare(lineNum, pn.lineNum); // ์ธ ๋ฒ์งธ๋ก ์ค์ํ ํ๋
}
return result;
}
์ฐธ๊ณ ํ ์ ์ ์๋์ ๊ฐ๋ค.
- ๋ฐ์ฑ๋ ๊ธฐ๋ณธ ํ์ ํด๋์ค๋ค์ ์๋ก ์ถ๊ฐ๋ ์ ์ ๋ฉ์๋์ธ compare๋ฅผ ์ด์ฉํด์ ๋น๊ตํ๋ฉด ๋๋ค.
- compareTo ๋ฉ์๋์์ ๊ด๊ณ ์ฐ์ฌ์์ธ '<'์ '>'๋ฅผ ์ฌ์ฉํ๋ ์ด์ ๋ฐฉ์์ ๊ฑฐ์ถ์ฅ์ค๋ฝ๊ณ ์ค๋ฅ๋ฅผ ์ ๋ฐํ๋, ์ด์ ๋ ์ถ์ฒํ์ง ์๋๋ค.
- ํด๋์ค์ ํต์ฌ ํ๋๊ฐ ์ฌ๋ฌ ๊ฐ๋ผ๋ฉด ํต์ฌ์ ์ธ ํ๋๋ถํฐ ๋น๊ตํด ๋๊ฐ๋ฉด ๋๋ค.
๊ธฐ์กด ํด๋์ค๋ฅผ ํ์ฅํ๊ณ ํ๋๋ฅผ ์ถ๊ฐํ๋ ๊ฒฝ์ฐ compareTo ๊ท์ฝ์ ์งํฌ ์ ์๋ค. (ํ์ํ์ ์์ ๋ค์ Comparable์ ๊ตฌํํ ์ ์๋ค.)
์ด๋ฐ ๊ฒฝ์ฐ Composition์ ํ์ฉํ๋ฉด ๋๋ค. (equals ๊ท์ฝ์ ์งํค๋ฉด์ ํ์ฉํ ๋ ์์์ด ์๋ Composition์ ๊ถ๊ณ ํ๋ ๊ฒ๊ณผ ๊ฐ์ ๋งฅ๋ฝ์ด๋ค.)
public class Point implements Comparable<Point> {
final int x, y;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
@Override
public int compareTo(Point point) {
int result = Integer.compare(this.x, point.x);
if(result == 0) {
result = Integer.compare(this.y, point.y);
}
return result;
}
}
----------
public class NamedPoint implements Comparable<NamedPoint> {
private final Point point;
private final String name;
public NamedPoint(Point point, String name) {
this.point = point;
this.name = name;
}
// ๋ด๋ถ ์ธ์คํด์ค๋ฅผ ๋ฐํํ๋ '๋ทฐ'๋ฉ์๋
public Point getPoint() {
return this.point;
}
@Override
public int compareTo(NamedPoint namedPoint) {
int result = this.point.compareTo(namedPoint.point);
if(result == 0) {
result = this.name.compareTo(namedPoint.name);
}
return result;
}
}
3. ๋น๊ต์ ์์ฑ ๋ฉ์๋ ๐ฆ
compareTo๋ฅผ ๊ตฌํํ๋ ๋ ๋ฒ์งธ ๋ฐฉ์์ '๋น๊ต์ ์์ฑ ๋ฉ์๋'๋ฅผ ์ด์ฉํ๋ ๊ฒ์ด๋ค. ์๋ฐ 8๋ถํฐ๋ 'ํจ์ํ ์ธํฐํ์ด์ค, ๋๋ค, ๋ฉ์๋ ๋ ํผ๋ฐ์ค'์ 'Comparator๊ฐ ์ ๊ณตํ๋ ๊ธฐ๋ณธ ๋ฉ์๋์ static ๋ฉ์๋'๋ฅผ ์ฌ์ฉํด์ Comparator๋ฅผ ๊ตฌํํ ์ ์๋ค.
Comparator๊ฐ ์ ๊ณตํ๋ ๋ฉ์๋ ์ฌ์ฉ๋ฐฉ๋ฒ์ ์๋์ ๊ฐ๋ค
- Comparator์ static ๋ฉ์๋๋ฅผ ์ฌ์ฉํด์ Comparator ์ธ์คํด์ค ๋ง๋ค๊ธฐ
- default ๋ฉ์๋๋ฅผ ์ฌ์ฉํด์ ๋ฉ์๋ ํธ์ถ ์ด์ด๋๊ฐ๊ธฐ (์ฒด์ด๋)
์ด๋, static ๋ฉ์๋์ default ๋ฉ์๋์ ๋งค๊ฐ๋ณ์๋ก๋ ๋๋ค ํํ์ ๋๋ ๋ฉ์๋ ๋ ํผ๋ฐ์ค๋ฅผ ์ฌ์ฉํ ์ ์๋ค.
// ๋๋ค ํํ์ ํ์ฉ
private static final Comparator<PhoneNumber> COMPARATOR =
comparingInt((PhoneNumber pn) -> pn.areaCode)
.thenComparingInt(pn -> pn.prefix)
.thenComparingInt(pn -> pn.lineNum);
public int comareTo(PhoneNumber pn) {
return COMPARATOR.compare(this, pn);
}
// ๋ฉ์๋ ๋ ํผ๋ฐ์ค ํ์ฉ
private static final Comparator<PhoneNumber> COMPARATOR =
comparingInt((PhoneNumber pn) -> pn.areaCode)
.thenComparingInt(PhoneNumber::getPrefix)
.thenComparingInt(PhoneNumber::getLineNum);
public int comareTo(PhoneNumber pn) {
return COMPARATOR.compare(this, pn);
}
Comparator์๋ ์๋ง์ ๋ณด์กฐ ์์ฑ ๋ฉ์๋๊ฐ ์๋ค. ๊ทธ๋ฆฌ๊ณ ๊ฐ์ฒด ์ฐธ์กฐ์ฉ ๋น๊ต์ ์์ฑ ๋ฉ์๋๋ ์์ผ๋ ์ฐธ๊ณ ํ๊ธฐ ๋ฐ๋๋ค.
4. ์ ๋ฆฌ ๐ฎ
- ์์๋ฅผ ๊ณ ๋ คํด์ผ ํ๋ ๊ฐ ํด๋์ค๋ฅผ ์์ฑํ๋ค๋ฉด ๊ผญ Comparable ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ์ฌ, ๊ทธ ์ธ์คํด์ค๋ค์ ์ฝ๊ฒ ์ ๋ ฌํ๊ณ , ๊ฒ์ํ๊ณ , ๋น๊ต ๊ธฐ๋ฅ์ ์ ๊ณตํ๋ ์ปฌ๋ ์ ๊ณผ ์ด์ฐ๋ฌ์ง๋๋ก ํด์ผ ํ๋ค.
- compareTo ๋ฉ์๋์์ ํ๋์ ๊ฐ์ ๋น๊ตํ ๋ '<'์ '>' ์ฐ์ฐ์๋ ์ฐ์ง ๋ง์์ผ ํ๋ค.
- ๊ทธ ๋์ ๋ฐ์ฑ๋ ๊ธฐ๋ณธ ํ์ ํด๋์ค๊ฐ ์ ๊ณตํ๋ '์ ์ compare ๋ฉ์๋'๋ Comparator ์ธํฐํ์ด์ค๊ฐ ์ ๊ณตํ๋ '๋น๊ต์ ์์ฑ ๋ฉ์๋'๋ฅผ ์ฌ์ฉํด์ผ ํ๋ค.
ํด๋น ๊ธ์ ๋ฐฑ๊ธฐ์ ๋์ '์ดํํฐ๋ธ ์๋ฐ ์๋ฒฝ ๊ณต๋ต'์ ์๊ฐํ๊ณ ์์ฑํ ๊ฒ์ ๋๋ค.