[문법/자바/JAVA] 정렬

🔰1차원 배열 정렬

Arrays.sort([배열])

int[] list1 = {1, 2, 3, 4};
Integer[] list2 = {1, 2, 3, 4};

// 오름차순
Arrays.sort(list1);
// 내림차순
// int[]는 객체가 아닌 primitive type이기 때문에 에러난다. => Integer[]로 변경!
Arrays.sort(list2, Collections.reverseOrder());

int 와 Integer의 차이

int(primitive type)

• 산술 연산 가능
• null로 초기화 불가능(0으로 초기화 가능)

Integer(Wrapper 클래스-객체)

• Wrapper 클래스
• Unboxing 하지 않으면 산술 연산 불가능, null 값은 처리 가능
• null값 처리가 용이해서 SQL 과 연동할 경우 처리가 용이. 직접적인 산술연산은 불가능
• Collection처럼 Object 타입을 인자로 받는 메소드 등을 사용할 때 필요

Collections.sort()

String[] list = {"A", "B", "C", "D"}; (X)
// 일반 배열은 안됨
static ArrayList<String> list = new ArrayList<>(Arrays.asList("C", "A", "B", "a"));

// 오름차순
Collections.sort(list);
// 내림차순
Collections.sort(list, Collections.reverseOrder());
// 대소문자 구별없이 오름차순
Collections.sort(list, String.CASE_INSENSITIVE_ORDER);
// 대소문자 구별없이 내림차순
Collections.sort(list, Collections.reverseOrder(String.CASE_INSENSITIVE_ORDER));

[java 8][배열].sort()

String[] list = {"A", "B", "C", "D"}; (X)
// 일반 배열은 안됨
static ArrayList<String> list = new ArrayList<>(Arrays.asList("C", "A", "B", "a"));

// 오름차순
list.sort(Comparator.naturalOrder());
// 내림차순
list.sort(Comparator.reverseOrder());
// 대소문자 구별없이 오름차순
list.sort(String.CASE_INSENSITIVE_ORDER);
// 대소문자 구별없이 내림차순
list.sort(Collections.reverseOrder(String.CASE_INSENSITIVE_ORDER));

---

🔰2차원 배열 정렬

Comparator

• 인터페이스
• 두 매개변수 객체를 비교
• 객체 자체와는 상관없이 매개변수로 넘겨진 두 객체를 비교

Compatator 인터페이스

package java.util;

public interface Comparator<T> {
	int compare(T o1, T o2);
    boolean equals(Object obj);
}

public int compare(T o1, T o2) {
	if(o1 > o2) return 양수;
    if(o1 < o2) return 음수;
    if(o1 == o2) return 0;
}

import java.util.Comparator;

class X {
	// 필드, 메서드 등
    public static final Comparator<T> COMPARATOR = new Comp();
    
    private static class Comp implements Comparator<T> {
    	public 	int compare(T o1, T o2) {
        	// o1이 o2보다 크면 양의 값 반환
            // o1이 o2보다 작으면 음의 값 반환
            // o1이 o2와 같으면 0반환
    	}	
    }
}

• comparator를 클래스 내부에서 정의하고 있지만 클래스 외부에서 정의해도 된다.
• 사용방법은 X의 클래스 변수인 X.COMPARATOR를 전달하면 된다.

---

int[][] arr = {{7,15}, {0,2}, {5,10}};

Arrays.sort(arr, new Comparator<int[]>() {
    @Override
    public int compare(int[] o1, int[] o2) {
    	return o1[0] - o2[0];
    }
})


Arrays.sort(arr, (o1, o2) -> {
    @Override
    public int compare(int[] o1, int[] o2) {
    	return o1[0] - o2[0];
    }
})


Arrays.sort(arr, new Comparator<int[]>() {
    @Override
    public int compare(int[] o1, int[] o2) {
    	// 0번째 element가 같으면 1번째 element로 정렬
    	if(o1[0] == o2[0]) {
        	return o1[1] - o2[1]; // 오름차순(반대는 내림차순)
        }
        else {
        	return o1[0] - o2[0];
        }
    }
})

Arrays.sort(arr, (o1, o2) -> {
    if(o1[0] == o2[0]) {
    	return o1[1] - o2[1]; // 오름차순(반대는 내림차순)
    }
    else {
    	return o1[0] - o2[0];
    }
});

ArrayList<int[]> pointsList = new ArrayList<int[]>(points);
// 다음 열로 정렬할 때
Collections.sort(pointsList, (o1, o2) -> (o1[1]-o2[1]));

---

🔰Map 정렬

• Collections.sort()를 사용하기 위해 List형태로 Map을 가져온다.
• Map.entrySet()을 이용하여 Map의 Entry Set을 List형태로 저장

Map<String, Integer> map = new HashMap<>();

map.put("a", 3);
map.put("b", 2);
map.put("c", 1);

List<Map.Entry<String, Integer>> entryList = new LinkedList<>(map.entrySet());

Entry 내장 함수 사용

• Map.Entry에 있는 comparingByValue()함수를 사용하여 아래와 같이 정렬

Map<String, Integer> map = new HashMap<>();
map.put("a", 3);
map.put("b", 2);
map.put("c", 1);
List<Map.Entry<String, Integer>> entryList = new LinkedList<>(map.entrySet());
entryList.sort(Map.Entry.comparingByValue());
for(Map.Entry<String, Integer> entry : entryList){
    System.out.println("key : " + entry.getKey() + ", value : " + entry.getValue());
}

//key : c, value : 1
//key : b, value : 2
//key : a, value : 3

comparator 인터페이스 사용

• Collections.sort()를 사용하기 위해 List형태로 Map을 가져온다.
• Map.entrySet()을 이용하여 Map의 Entry Set을 List형태로 저장

Map<String, Integer> map = new HashMap<>();
map.put("a", 3);
map.put("b", 2);
map.put("c", 1);
List<Map.Entry<String, Integer>> entryList = new LinkedList<>(map.entrySet());
entryList.sort(new Comparator<Map.Entry<String, Integer>>() {
    @Override
    public int compare(Map.Entry<String, Integer> o1, Map.Entry<String, Integer> o2) {
	return o1.getValue() - o2.getValue();
    }
});
for(Map.Entry<String, Integer> entry : entryList){
    System.out.println("key : " + entry.getKey() + ", value : " + entry.getValue());
}

//key : c, value : 1
//key : b, value : 2
//key : a, value : 3

👀 이 블로그를 참고하여 정리했습니다 :)