[TIL] 자바 정렬

파이썬은 정렬이 참 간단한데 자바도 물론 메소드로 지원해주긴 하지만 타입에 따라 달라서..,. 정리해두겠다!!!!

백준 20006번 문제를 푸다가 nickname을 기준으로 정렬을 해야하는 상황이 있었다.

static class Player {
        int level;
        String nickname;

        public Player() {
        }

        public Player(int level, String nickname) {
            this.level = level;
            this.nickname = nickname;
        }

        @Override
        public String toString() {
            return level + " " + nickname;
        }
    }

    static class Room {
        int baseLevel;
        List<Player> players = new ArrayList<>();

        public Room() {
        }

        // 추가 가능 여부
        boolean canJoin(Player p, int m) {
            return players.size() < m &&
                    p.level >= baseLevel - 10 &&
                    p.level <= baseLevel + 10;
        }
    }
    
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());

        List<Player> playerList = new ArrayList<>();

        int p = Integer.parseInt(st.nextToken());
        int m = Integer.parseInt(st.nextToken());

        // 플레이어 레벨, 닉네임
        for (int i = 0; i < p; i++) {
            st = new StringTokenizer(br.readLine());
            int l = Integer.parseInt(st.nextToken());
            String n = st.nextToken();
            Player player = new Player(l, n);
            playerList.add(player);
        }

        List<Room> roomList = new ArrayList<>();

        for (Player player : playerList) {
            boolean conJoin = false;
            // 방 리스트 돌면서 들어갈 수 있는 방 찾기
            for (Room room : roomList) {
                if (room.canJoin(player, m)) {
                    room.players.add(player);
                    conJoin = true;
                    break;
                }
            }

            // 들어갈 수 있는 방 없으면
            if (!conJoin) {
                Room room = new Room();
                room.baseLevel = player.level;
                room.players.add(player);
                roomList.add(room);
            }
        }

        // 출력
        // 닉네임은 사전 순
        for (Room room : roomList) {
            if (room.players.size() == m) {
                System.out.println("Started!");
            } else {
                System.out.println("Waiting!");
            }

            // 닉네임 순으로 정렬해서 출력
            room.players.sort((o1, o2) -> o1.nickname.compareTo(o2.nickname));

            for (Player player : room.players) {
                System.out.println(player);
            }

        }
    }

바로 이 부분!!! 이였다

room.players.sort((o1, o2) -> o1.nickname.compareTo(o2.nickname));

자바는 타입별로 정렬하는 방식이 다르다.

💭 기본 타입 배열 정렬

int, double 등 기본 타입의 배열을 정렬하기 위한 방법은 다음과 같다

🌀 오름차순

int[] arr = {3, 1, 2};
Arrays.sort(arr);  

🌀 내림차순
내림차순은 오름차순보다 복잡하다. int를 Integer로 변경해야한다. 그리고 Collections.reverseOrder()를 사용해서 정렬해준다.

int[] arr = {3, 1, 2};
Integer[] intergerArr = new Integer[arr.length];
for (int i=0; i < arr.length; i++){
     intergerArr[i] = arr[i];
}
Arrays.sort(intergerArr, Collections.reverseOrder());

Collections.reverseOrder()은 Integer[], Double[] 과 같은 객체 타입 배열에만 사용 가능

💭 객체 타입 배열 정렬

🌀 오름차순

Integer[] nums = {3, 1, 2};
Arrays.sort(nums);  // 오름차순 정렬

🌀 내림차순

Integer[] nums = {3, 1, 2};
Arrays.sort(nums, Collections.reverseOrder());  // 내림차순 정렬

💭 List< T > 정렬

List<Integer>, List<String>과 같은 기본 타입 객체 리스트는 객체 타입 배열과 같지만 Collections.sort()를 사용하면 된다

🌀 오름차순

List<String> list = new ArrayList<>();
list.add("d");
list.add("c");
list.add("a");
Collcetions.sort(list);

🌀 내림차순

List<String> list = new ArrayList<>();
list.add("d");
list.add("c");
list.add("a");
Collcetions.sort(list, Collcetions.reverseOrder());

💭 객체 리스트 정렬

이게 바로 오는 알고리즘을 푸면서 마주친 형태!!! List<Room>, List<Player>와 같은 클래스가 타입일때는 다음과 같이 하면 된다.

예를 들어

static class Player {
        int level;
        String nickname;

        public Player() {
        }

        public Player(int level, String nickname) {
            this.level = level;
            this.nickname = nickname;
        }

        @Override
        public String toString() {
            return level + " " + nickname;
        }
    }

    static class Room {
        int baseLevel;
        List<Player> players = new ArrayList<>();

        public Room() {
        }

        // 추가 가능 여부
        boolean canJoin(Player p, int m) {
            return players.size() < m &&
                    p.level >= baseLevel - 10 &&
                    p.level <= baseLevel + 10;
        }
    }

이렇게 Player, Room 클래스가 있다고 하자.

여기서 player의 nickname을 오름차순 정렬하고 싶다면

room.players.sort((o1, o2) -> o1.nickname.compareTo(o2.nickname));

이런식으로 람다식을 사용해주면 된다. 또 만약 내림차순 정렬을 원하면

room.players.sort((o1, o2) -> o2.nickname.compareTo(o1.nickname));

해주면 된다.

근데 만약 level을 기준으로 즉 정수를 기준으로 오름차순 정렬하고 싶다면

room.players.sort((o1, o2) -> Integer.level.compare(o1.level, o2.level));

내림차순 정렬하고 싶다면

room.players.sort((o1, o2) -> Integer.level.compare(o2.level, o1.level));

이런식으로 해주면된다!!