Comparable : 현재 객체와 다른 객체의 비교 기준을 정함 => Comparable - CompareTo (T o) 정의
Comparator : 두 객체의 비교 기준을 정함 => Comparator - Compare(T o1, T o2) 정의
<Comparable>
public class Node implements Comparable<Node> {
private int index = 0; // 노드의 번호
private int distance = 0; // 노드의 거리
private String name = ""; // 노드의 이름
public Node(int index, int distance, String name) {
this.index = index;
this.distance = distance;
this.name = name;
}
public int getIndex() {
return this.index;
}
public int getDistance() {
return this.distance;
}
public String getName() {
return this.name;
}
@Override
public int compareTo(Node otherNode) {
// TODO Auto-generated method stub
// private 변수이지만 클래스 내부에선 getDistance()로 가져올 필요 없이 직접 가져와도 됨
// return this.distance - otherNode.distance; // distance 기준 오름차순 정렬 // 1, 2, 3, ...
// return this.getDistance() - otherNode.getDistance(); // distance 기준 오름차순 정렬 // 1, 2, 3, ...
// return otherNode.distance - this.distance; // distance 기준 내림차순 정렬 // ..., 3, 2, 1
// return otherNode.getDistance() - this.getDistance(); // distance 기준 내림차순 정렬 // ..., 3, 2, 1
// distance, index, name 기준 오름차순 정렬(ORDER BY distance, index, name)
if (this.distance == otherNode.distance) { // distance가 같을 경우
if (this.index == otherNode.index) { // index가 같을 경우
return this.name.compareTo(otherNode.name); // name 기준 오름차순 정렬
// return otherNode.name.compareTo(this.name); // name 기준 내림차순 정렬
} else { // index가 같지 않을 경우
return this.index - otherNode.index; // index 기준 오름차순 정렬
// return otherNode.index - this.index; // index 기준 내림차순 정렬
}
} else { // distance가 같지 않을 경우
return this.distance - otherNode.distance; // distance 기준 오름차순 정렬
// return otherNode.distance - this.distance; // distance 기준 내림차순 정렬
}
// // int 값으로 비교 : return int - int;
// // String 값으로 비교 : return String.compareTo(String);
// ------------------------------------------------------------------------------------------------------
// // distance 값을 기준으로 오름차순 정렬을 시키는 다른 방법 1, 2, 3, ...
// if (this.distance < otherNode.distance) {
// return -1; // 해당 노드의 거리가 비교대상 노드의 거리보다 작다면 => 해당 노드가 더 작다 리턴
// }
//
// return 1; // 해당 노드의 거리가 비교대상 노드의 거리보다 크거나 같다면 => 해당 노드가 더 크다 리턴
//
// // distance 값을 기준으로 내림차순 정렬을 시키는 다른 방법 ..., 3, 2, 1
// if (this.distance < otherNode.distance) {
// return 1; // 해당 노드의 거리가 비교대상 노드의 거리보다 작다면 => 해당 노드가 더 크다 리턴
// }
//
// return -1; // 해당 노드의 거리가 비교대상 노드의 거리보다 크거나 같다면 => 해당 노드가 더 작다 리턴
//
// // int 값으로 비교 : 1(크다), 0(같다), -1(작다)
// // String 값으로 비교 : 0(같다), 다양한 양수/음수 값 : 대상 문자열의 제일 앞 부분부터 비교하여 비교대상 문자열을 포함한다면 문자열 길이 차만큼 리턴, 하지만 아예 포함하지 않거나, 중간에 포함한다면 각 문자열의 제일 앞 아스키 코드값의 차를 리턴(대상 문자열 첫 문자 아스키코드 값 - 비교대상 문자열 첫 문자 아스키코드 값)
// ------------------------------------------------------------------------------------------------------
}
}import java.util.*;
public class ComparableTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
// --------------------------------------일반 배열--------------------------------------
int[] arr1 = {2, 1, 6, 3, 7, 4, 5};
for (int num : arr1) {
System.out.print(num + " "); // 2 1 6 3 7 4 5
}
System.out.println();
// --------------------------------------배열 정렬--------------------------------------
Arrays.sort(arr1); // 기본 오름차순 정렬
for (int num : arr1) {
System.out.print(num + " "); // 1 2 3 4 5 6 7
}
System.out.println();
// ------------------------Comparable 인터페이스를 구현한 Node 클래스------------------------
ArrayList<Node> list = new ArrayList<>();
// index, distance, name
list.add(new Node(1, 2, "B"));
list.add(new Node(2, 1, "A"));
list.add(new Node(2, 2, "C"));
list.add(new Node(1, 3, "F"));
list.add(new Node(1, 3, "E"));
list.add(new Node(1, 3, "D"));
for (Node node : list) {
System.out.print(node.getName() + " "); // "B", "A", "C", "F", "E", "D"
}
System.out.println();
// -----------------------------------Node 클래스 정렬-----------------------------------
Collections.sort(list); // Node 클래스의 정렬 기준 : ORDER BY distance, index, name
for (Node node : list) {
System.out.print(node.getName() + " "); // "A", "B", "C", "D", "E", "F"
}
}
}<Comparator>
public class Node {
private int index = 0; // 노드의 번호
private int distance = 0; // 노드의 거리
public Node(int index, int distance) {
this.index = index;
this.distance = distance;
}
public int getIndex() {
return this.index;
}
public int getDistance() {
return this.distance;
}
}import java.util.*;
public class ComparatorTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
// -------------------------------------Node 클래스-------------------------------------
ArrayList<Node> list = new ArrayList<>();
list.add(new Node(2, 2));
list.add(new Node(1, 1));
list.add(new Node(3, 3));
for (Node node : list) {
System.out.print(node.getDistance() + " "); // 2, 1, 3
}
System.out.println();
// -----------------------------------Node 클래스 정렬-----------------------------------
Collections.sort(list, new Comparator<Node>() {
@Override
public int compare(Node node1, Node node2) {
// distance 기준 오름차순 정렬 // 1, 2, 3, ...
if(node1.getDistance() < node2.getDistance()) return -1;
else if(node1.getDistance() == node2.getDistance()) return 0;
else return 1;
// distance 기준 내림차순 정렬 // ..., 3, 2, 1
// if(node1.getDistance() < node2.getDistance()) return 1;
// else if(node1.getDistance() == node2.getDistance()) return 0;
// else return -1;
// distance는 Node 클래스의 private 변수이므로 node1.distance가 아닌 distance 값을 가져오도록 만든 node1.getDistance() 메소드 사용
}
});
for (Node node : list) {
System.out.print(node.getDistance() + " "); // 1, 2, 3
}
}
}<2차원 배열에서 다중 정렬>
int[][] arr = {{1, 3}, {1, 2}, {3, 4}, {1, 4}, {2, 4}};
Arrays.sort(arr, new Comparator<int[]>() {
@Override
public int compare(int[] o1, int[] o2) {
if(o1[0] == o2[0]) { // 앞 원소가 같을 경우
return o1[1] - o2[1]; // 뒤 원소 기준 오름차순
// return o2[1] - o1[1]; // 뒤 원소 기준 내림차순
}else { // 앞 원소가 같지 않을 경우
return o1[0] - o2[0]; // 앞 원소 기준 오름차순
// return o2[0] - o1[0]; // 앞 원소 기준 내림차순
}
}
});
<Comparable 인터페이스의 compareTo 메소드 구현 시 타입 비교>
'Java > 참고자료' 카테고리의 다른 글
| [Java] Equals & HashCode (0) | 2022.11.25 |
|---|---|
| [Java] Exception (0) | 2022.11.25 |
| [Java] 연산자 (0) | 2022.11.25 |
| [Java] Stack, Queue, Deque (0) | 2022.11.25 |
| [Java] 참고자료 (0) | 2022.11.25 |