public class Main {
public static void main(String[] args) {
char[] chArr = {'E', 'D', 'C', 'B', 'A'};
System.out.println("์ ๋ ฌ ์ : " + Arrays.toString(chArr));
Arrays.sort(chArr);
System.out.println("์ ๋ ฌ ํ : " + Arrays.toString(chArr));
}
}
// ์ ๋ ฌ ์ : [E, D, C, B, A]
// ์ ๋ ฌ ํ : [A, B, C, D, E]
Arrays.sort๋ฅผ ์ด์ฉํ๋ฉด ์์ ๊ฐ์ด ์ ๋ ฌ์ ํ ์ ์๋ค. ์ ๋ ฌ์ด ๊ฐ๋ฅํ ์ด์ ๋ Comparable์ ๊ตฌํํ๊ธฐ ๋๋ฌธ์ด๋ค. ์ด๋ฒ ๊ธ์์๋ 'Comparable๊ณผ Comparator์ ๊ฐ๋ ', '๊ฐ๊ฐ์ ์ฌ์ฉ๋ฒ', '์ต๋ช ํด๋์ค๋ฅผ ํ์ฉํ ํธ๋ฆฌํ Comparator ์ฌ์ฉ๋ฒ'์ ์์๋ณด๋๋ก ํ์.
1. Comparable๊ณผ Comparator ๐
Comparable๊ณผ Comparator๋ ์ปฌ๋ ์ ์ ์ ๋ ฌํ๋๋ฐ ํ์ํ ๋ฉ์๋๋ฅผ ์ ์ํ๊ณ ์๋ ์ธํฐํ์ด์ค๋ค. Comparable์ ๊ธฐ๋ณธ ์ ๋ ฌ๊ธฐ์ค์ ๊ตฌํํ๋ ๋ฐ ์ฌ์ฉํ๋ค. ์๋ฅผ ๋ค์ด, Integer์ ๊ฐ์ wrapperํด๋์ค์ String, Date, File๊ณผ ๊ฐ์ ํ์ ์ ์ธ์คํด์ค๋ผ๋ฆฌ ์๋ก ๋น๊ตํ ์ ์๋ ํด๋์ค๋ค์ด Comparable์ ๊ตฌํํ๊ณ ์๋ค. (์๋๋ String๊ณผ Integer์ declaration ์ค ์ผ๋ถ๋ถ์ด๋ค.)
public final class String implements Comparable<String> {
}
public final class Integer implements Comparable<Integer> {
}
Comparator๋ ๊ธฐ๋ณธ ์ ๋ ฌ๊ธฐ์ค ์ธ์ ๋ค๋ฅธ ๊ธฐ์ค์ผ๋ก ์ ๋ ฌํ๊ณ ์ ํ ๋ ์ฌ์ฉํ๋ค. Comparable์ ๊ตฌํํ ํด๋์ค๋ค์ด ๊ธฐ๋ณธ์ ์ธ ์ ๋ ฌ ๊ธฐ์ค์ด ์๋, ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ค๋๊ฐ ๋ค๋ฅธ ๊ธฐ์ค์ผ๋ก ์ ๋ ฌํ๊ณ ์ถ์ ๋ Comparator๋ฅผ ๊ตฌํํด์ ์ฌ์ฉํ๋ค.
2. Comparable ์ฌ์ฉ๋ฒ ๐ญ
Comparable์ ์ฌ์ฉํ๊ธฐ ์ํด์๋ ์๋์ Comparable ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํด์ผ ํ๋ค.
public interface Comparable {
public int comparetTo(T o);
}
compareTo()์ ๋ฐํ๊ฐ์ด int๋ผ๊ณ ํ์๋์ด ์์ง๋ง ์ค์ ๋ก๋ 0, ์์, ์์๋ฅผ ๋ฐํํ๋๋ก ๊ตฌํํ๋ฉด ๋๋ค.
- ์์ = ๋น๊ตํ๋ ๊ฐ๋ณด๋ค ์์ ๊ฒฝ์ฐ
- 0 = ๋ ๊ฐ์ฒด๊ฐ ๊ฐ์ ๊ฒฝ์ฐ
- ์์ = ๋น๊ตํ๋ ๊ฐ๋ณด๋ค ํฐ ๊ฒฝ์ฐ
๋ฐฉ๋ฌธ๊ฐ(Visitor)๋ค์ ๋์ด๋ณ๋ก ์ ๋ ฌ์ ํ๋ค๊ณ ์๊ฐํด ๋ณด์. ๊ทธ๋ฌ๋ฉด Visitor ํด๋์ค์์ compareTo๋ฅผ ์ค๋ฒ๋ผ์ด๋ฉํ์ฌ Comparable์ ๊ตฌํํด ์ฃผ๋ฉด ๋๋ค.
public class Visitor implements Comparable {
int age;
public Visitor(int age) {
this.age = age;
}
@Override
public int compareTo(Object o) {
return this.age - ((Visitor)o).age;
}
@Override
public String toString() {
return "Visitor [age=" + age + "]";
}
}
public class Main {
public static void main(String[] args) {
List<Visitor> visitors = Arrays.asList(new Visitor(40), new Visitor(20), new Visitor(32));
System.out.println("์ ๋ ฌ ์ : " + visitors.toString());
Collections.sort(visitors);
System.out.println("์ ๋ ฌ ํ : " + visitors.toString());
}
}
// ์ ๋ ฌ ์ : [Visitor [age=40], Visitor [age=20], Visitor [age=32]]
// ์ ๋ ฌ ํ : [Visitor [age=20], Visitor [age=32], Visitor [age=40]]
๋ง์ฝ์ ์ด๋ฆ์์ผ๋ก ์ ๋ ฌ์ ํ๋ค๊ณ ํ๋ฉด ์๋์ ๊ฐ์ด ํด์ฃผ๋ฉด ๋๋ค.
public class Visitor implements Comparable {
int age;
String name;
public Visitor(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public int compareTo(Object o) {
return this.name.compareTo(((Visitor)o).name);
}
@Override
public String toString() {
return "Visitor [age=" + age + ", name=" + name + "]";
}
}
name์ ํ์ ์ด String์ด๊ณ , String์์๋ Comparable์ ๊ตฌํํ๊ณ ์๊ธฐ ๋๋ฌธ์ ์์ ๊ฐ์ด ์ฌ์ฉํ ์ ์๋ค.
3. Comparator ์ฌ์ฉ๋ฒ ๐ฎ
Collections.sort(visitors); // 1
Collecitons.sort(visitors, nameLengthComparator()); // 2
Comparable์ ์ฌ์ฉํ ๋๋ 2๋ฒ์ฒ๋ผ Comparator๋ฅผ ์ง์ ํด์ฃผ์ง ์๊ณ 1๋ฒ๊ณผ ๊ฐ์ด ์ฌ์ฉํ์๋ค. ๋ง์ฝ Comparator๋ฅผ ์ง์ ํด์ฃผ์ง ์์ผ๋ฉด ์ ๋ ฌํ๋ ๊ฐ์ฒด์์ Comparable์ ๊ตฌํํ ๋ฐฉ๋ฒ์ผ๋ก ์ ๋ ฌ์ด ๋๋ค. ํ์ง๋ง Comparator์ ์ง์ ํด ์ฃผ๋ฉด ์ง์ ๋ ๋ฐฉ์์ผ๋ก ์ ๋ ฌ์ด ๋๋ค.
public interface Comparator {
int compare(T o1, T o2);
}
Comparator์ ์ธํฐํ์ด์ค๋ ์์ ๊ฐ๊ณ Comparable์์ compareTo()๋ฅผ ์ค๋ฒ๋ผ์ด๋ฉํ ๊ฒ์ฒ๋ผ compare()๋ฅผ ์ค๋ฒ๋ผ์ด๋ฉ ํ๋ฉด ๋๋ค.
- ์์ = ๋น๊ตํ๋ ๊ฐ๋ณด๋ค ์์ ๊ฒฝ์ฐ
- 0 = ๋ ๊ฐ์ฒด๊ฐ ๊ฐ์ ๊ฒฝ์ฐ
- ์์ = ๋น๊ตํ๋ ๊ฐ๋ณด๋ค ํฐ ๊ฒฝ์ฐ
์ด๋ฒ์๋ ๋ฐฉ๋ฌธ๊ฐ๋ค์ ์ด๋ฆ์ ๊ธธ์ด๋ก ์ ๋ ฌํด ๋ณด์. Comparator๋ฅผ ๊ตฌํํ NameLengthComparator ํด๋์ค๋ฅผ ๋ง๋ค์ด์ฃผ๊ณ , gํด๋น ํด๋์ค์์ compare๋ฅผ ์ค๋ฒ๋ผ์ด๋ฉํ์ฌ ๊ตฌํํ๋ฉด ๋๋ค.
public class NameLengthComparator implements Comparator<String> {
@Override
public int compare(String o1, String o2) {
return o1.length() - o2.length();
}
}
public class Main {
public static void main(String[] args) {
List<String> visitors = Arrays.asList("emma", "tom", "andrea");
System.out.println("์ ๋ ฌ ์ : " + visitors.toString());
Collections.sort(visitors);
System.out.println("Comparable์ ํ์ฉํ ์ ๋ ฌ ํ : " + visitors.toString());
Collections.sort(visitors, new NameLengthComparator());
System.out.println("Comparator์ ํ์ฉํ ์ ๋ ฌ ํ : " + visitors.toString());
}
}
// ์ ๋ ฌ ์ : [emma, tom, andrea]
// Comparable์ ํ์ฉํ ์ ๋ ฌ ํ : [andrea, emma, tom]
// Comparator์ ํ์ฉํ ์ ๋ ฌ ํ : [tom, emma, andrea]
4. ์ต๋ช ํด๋์ค๋ฅผ ํ์ฉํ Comparator ๊ตฌํ ๐ฅช
๋ฐฉ๋ฌธ๊ฐ๋ค์ ์ด๋ฆ์ ๊ธธ์ด๋ฟ๋ง ์๋๋ผ ๋์ด, ์ฑ๋ณ, ๊ตญ๊ฐ, ๋์ฐฉํ ์๊ฐ ๋ฑ์ผ๋ก ์ ๋ ฌ์ ํ๋ ค๋ฉด ๊ณ์ํด์ XXXcomparator ํด๋์ค๋ฅผ ์์ฑํด์ผ ํ ๊น? ๋ฌผ๋ก ๊ทธ๋ด ์๋ ์์ง๋ง ์ ๋ ฌ์ ํ ๋ ํ๋ฒ ์ฌ์ฉํ๋ ๊ฒ์ด๋ฏ๋ก ํจ์จ์ ์ด์ง ๋ชปํ๋ค. ๋ง์ฝ ์ต๋ช ํด๋์ค๋ฅผ ํ์ฉํ ์ ์๋ค๋ฉด ํด๋น ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์๋ค.
์ต๋ช ํด๋์ค๋ ๋ด๋ถ ํด๋์ค(Inner class)(ํด๋์ค ๋ด์ ์ ์ธ๋ ํด๋์ค)์ ์ผ์ข ์ผ๋ก ์ด๋ฆ์ด ์๋ ํด๋์ค๋ค. ์ด๋ฆ์ด ์๋ค๋ ๊ฒ์ ๋ณ๋ก ๊ธฐ์ต๋์ง ์์๋ ๋๋ค๋ ๊ฒ์ด๋ฉฐ, ๋์ค์ ๋ค์ ๋ถ๋ฌ์ง ์ด์ ๊ฐ ์๋ค๋ ๋ป์ด๋ค. ๊ทธ๋์ ์ผ์์ ์ผ๋ก ํ ๋ฒ๋ง ์ฌ์ฉ๋๋ ๊ฐ์ฒด๋ผ๊ณ ์๊ฐํ๋ฉด ๋๊ฒ ๋ค.
์ฌ์ฉ ๋ฐฉ๋ฒ์ ์๋์ ๊ฐ์ด ๋ถ๋ชจํด๋์ค์ธ Comparator์ compare()๋ฅผ ์ค๋ฒ๋ผ์ด๋ฉํด์ ์ฌ์ฉํ๋ฉด ๋๋ค.
public class Main {
public static void main(String[] args) {
List<String> visitors = Arrays.asList("emma", "tom", "andrea");
System.out.println("์ ๋ ฌ ์ : " + visitors.toString());
Collections.sort(visitors, new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o1.length() - o2.length();
}
});
System.out.println("Comparator์ ํ์ฉํ ์ ๋ ฌ ํ (์ต๋ช
ํด๋์ค ์ฌ์ฉO) : " + visitors.toString());
}
}
// ์ ๋ ฌ ์ : [emma, tom, andrea]
// Comparator์ ํ์ฉํ ์ ๋ ฌ ํ (์ต๋ช
ํด๋์ค ์ฌ์ฉO) : [tom, emma, andrea]
์ด์์ผ๋ก Comparable๊ณผ Comparator์ ๋ํด์ ์์๋ณด์๋ค. ์ต๋ช ํด๋์ค๋ก Comparator๋ฅผ ๊ฐ๋จํ๊ฒ ๊ตฌํํ๋ ๋ฐฉ๋ฒ์ ์์๋ณด์๋๋ฐ, ๋๋ค(Lambda)๋ฅผ ์ฌ์ฉํ๋ฉด ๋ ๊ฐ๋จํ๊ฒ ์์ฑํ ์ ์๋ค. ๋ค์ ๊ธ์์ ๋๋ค์ ๋ํด์ ์์๋ณด๊ณ ์ด๋ป๊ฒ ๋ ๊ฐ๋จํด ์์ฑํ๋์ง ์์๋ณด๋๋ก ํ์.
ํด๋น ๊ธ์ ๋จ๊ถ ์ฑ๋์ Java์ ์ ์์ ์ฝ๊ณ ์์ฑํ ๊ฒ์ ๋๋ค.
'๐ JAVA > ์ฃผ์ ๊ฐ๋ ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
์ ์ถ๋ ฅ(I/O)(1) - ๋ ธ๋ ์คํธ๋ฆผ, ๋ณด์กฐ ์คํธ๋ฆผ (0) | 2023.01.29 |
---|---|
๋๋ค์(Lambda Expression) - (2) (0) | 2023.01.29 |
๋๋ค์(Lambda Expression) - (1) (0) | 2023.01.29 |
์์ธ์ฒ๋ฆฌ(Exception Handling) - (2) (0) | 2023.01.28 |
์์ธ์ฒ๋ฆฌ(Exception Handling) - (1) (0) | 2023.01.28 |