자바 오름차순/내림차순 정렬하기 - Arrays.sort() 함수

코테 문제를 풀다보면 정렬을 하는 경우가 많은데
Java에서 배열을 정렬할 때는 자바에서 제공하는 Arrays.sort(배열) 함수를 사용하면
쉽게 원하는 결과를 반환할 수 있다.

숫자 배열 / 문자열 배열 오름차순으로 정렬하기

public class SortTest {
    public static void main(String[] args) {
        int[] ints = {13, 56, 32, 123, 61, 123, 1, 6};
        Arrays.sort(ints);
        System.out.println(Arrays.toString(ints)); // [1, 6, 13, 32, 56, 61, 123, 123]

        String[] strs = {"Banana", "banana", "bana", "Carrot", "car", "Car", "Apple", "apple"};
        Arrays.sort(strs);
        System.out.println(String.join(", ", strs)); 
		// Apple, Banana, Car, Carrot, apple, bana, banana, car
    }
}

 

숫자 배열 / 문자열 내림차순으로 정렬하기

- 스트림API 와 람다식을 이용해 구현 또는 Collections 메서드 사용
   - Arrays.sort(tmp, (a, b) -> b - a);
- 기본타입 배열이라면 Object를 상속하는 Wrapper 클래스로 박싱해주어야 역순정렬이 가능
   - Integer[] tmp = Arrays.stream(nums).boxed().toArray(Integer[]::new); 
- 음수 끝지점은 잘 정렬이 안됨(-2147483645정도까지만 정렬)

public class SortTest {
    public static void main(String[] args) {
        int[] ints = {13, 56, 32, 123, 61, 123, 1, 6};
        // 기본타입 배열이라면 Object를 상속하는 Wrapper 클래스로 박싱해주어야 역순정렬이 가능
        Integer[] tmpInts = Arrays.stream(ints).boxed().toArray(Integer[]::new);
        Arrays.sort(tmpInts, (a, b) -> b - a); // 람다식 사용
        // Arrays.sort(tmpInts, (a, b) -> b.compareTo(a));
        // Arrays.sort(tmpInts, Comparator.reverseOrder());
        System.out.println(Arrays.toString(tmpInts)); // [123, 123, 61, 56, 32, 13, 6, 1]

        String[] strs = {"Banana", "banana", "bana", "Carrot", "car", "Car", "Apple", "apple"};
        // String, Integer, Double 등과 같은 Object 타입으로 따로 변환안해주고 사용
        Arrays.sort(strs, (a, b) -> b.compareTo(a)); // 1. ompareTo 사용
        // Arrays.sort(strs, Comparator.reverseOrder()); // 2. Comparator.reverseOrder 사용
        System.out.println(String.join(", ", strs));
        // car, banana, bana, apple, Carrot, Car, Banana, Apple
    }
}

 

좌표 정렬하기

• 좌표 [x, y]에서 x값에 의한 오름차순 정렬
  - 람다식
  - Comparator 

import java.util.Arrays;
import java.util.Comparator;

public class SortTest2 {
    public static void main(String[] args) {
        // 람다식 이용하기
        int[][] ints = {{1, 3}, {10, 5}, {33, 1}, {23, 11}};
        Arrays.sort(ints, (a, b) -> a[0] - b[0]);
        System.out.println(Arrays.deepToString(ints));
        // [[1, 3], [10, 5], [23, 11], [33, 1]]
        
        // Comparator 이용하기
        Comparator<int[]> comparator = new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                return o1[0] - o2[0];
            }
        };
        int[][] ints2 = {{1, 3}, {10, 5}, {5, 1}, {6, 11}};
        Arrays.sort(ints2, comparator);
        System.out.println(Arrays.deepToString(ints2));
        // [[1, 3], [5, 1], [6, 11], [10, 5]]
    }
}

 

• [x, y]에서 y값에 의한 오름차순 정렬
  - 람다식
  - Comparator 

import java.util.Arrays;
import java.util.Comparator;

public class SortTest2 {
    public static void main(String[] args) {
        // 람다식 이용하기
        int[][] ints = {{1, 3}, {10, 5}, {33, 1}, {23, 11}};
        Arrays.sort(ints, (a, b) -> a[1] - b[1]);
        System.out.println(Arrays.deepToString(ints));
        // [[33, 1], [1, 3], [10, 5], [23, 11]]

        // Comparator 이용하기
        Comparator<int[]> comparator = new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                return o1[1] - o2[1];
            }
        };
        int[][] ints2 = {{1, 3}, {10, 5}, {5, 1}, {6, 11}};
        Arrays.sort(ints2, comparator);
        System.out.println(Arrays.deepToString(ints2));
        // [5, 1], [1, 3], [10, 5], [6, 11]]
    }
}

 

• [x, y]에서 x값에 의한 내림차순 정렬
  - 람다식
  - Comparable

public class SortTest2 {
    public static void main(String[] args) {
        // 람다식 이용하기
        int[][] ints = {{1, 3}, {10, 5}, {33, 1}, {23, 11}};
        Arrays.sort(ints, (a, b) -> b[0] - a[0]);
        System.out.println(Arrays.deepToString(ints));
        // [[33, 1], [23, 11], [10, 5], [1, 3]]

        // Comparator 이용하기
        Comparator<int[]> comparator = new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                return o2[0] - o1[0];
            }
        };
        int[][] ints2 = {{1, 3}, {10, 5}, {5, 1}, {6, 11}};
        Arrays.sort(ints2, comparator);
        System.out.println(Arrays.deepToString(ints2));
        // [[10, 5], [6, 11], [5, 1], [1, 3]]
    }
}

 

• [x, y]에서 x값에 의한 오름차순, x값이 같은 경우는 y값에 따라 내림차순

public class SortTest2 {
    public static void main(String[] args) {
        // 람다식 이용하기
        int[][] ints = {{10, 3}, {10, 5}, {10, 1}, {6, 11}};
        Arrays.sort(ints, (a, b) -> a[0] == b[0] ? b[1] - a[1] : a[0] - b[0]);
        System.out.println(Arrays.deepToString(ints));
        // [[6, 11], [10, 5], [10, 3], [10, 1]]

        // Comparator 이용하기
        Comparator<int[]> comparator = new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                return o2[0] == o1[0] ? o2[0] - o1[0] : o1[0] - o2[0];
            }
        };
        int[][] ints2 = {{10, 3}, {10, 5}, {10, 1}, {6, 11}};
        Arrays.sort(ints2, comparator);
        System.out.println(Arrays.deepToString(ints2));
        // [[6, 11], [10, 5], [10, 3], [10, 1]]
    }
}

 

• 문자열 좌표 [x, y] x값에 의한 오름차순 만들때 Comparator 익명클래스로 사용하기

String[][] strs = {{"cat", "apple"}, {"apple", "cat"}, {"dice", "bear"}, {"bear", "dice"}};
Arrays.sort(strs, new Comparator<String[]>() {
    @Override
    public int compare(String[] o1, String[] o2) {
        return o1[0].compareTo(o2[0]);
    }
});
System.out.println(Arrays.deepToString(strs));
// [[apple, cat], [bear, dice], [cat, apple], [dice, bear]]