보안공돌이

Spring 예외 처리 [Error, Checked/UnChecked Exception]

보안공돌이 — Mon, 14 Oct 2024 13:37:07 +0900

운영 환경에서 발생하는 예외를 부적절하게 처리하면 문제의 원인을 찾기 힘들어집니다. 모든 예외는 적절하게 복구되거나 작업을 중단하고 관리자나 개발자에게 통보되어야 합니다. 예를 들어, 네트워크가 끊기거나 서버가 종료된 상황에서 예외를 단순히 콘솔에 출력하는 것으로는 문제가 해결되지 않습니다. 콘솔 출력은 실제 문제 해결에 도움이 되지 않으므로, 차라리 서버를 종료시키는 것이 더 나은 선택일 수 있습니다.

무의미하고 무책임한 throws는 피하자

개발자가 복구할 수 있는 예외 상황에도 불구하고, 무책임하게 throws를 사용하여 예외를 상위로 던지는 것은 적절하지 않습니다. 이러한 예외 처리 방식은 실제로 예외를 다룰 수 있는 기회를 빼앗기 때문에, 예외 처리 전략을 신중하게 선택해야 합니다.

예외 처리의 기본 개념

자바에서 예외는 크게 세 가지로 나눌 수 있습니다.

Error: 시스템에서 비정상적인 상황이 발생했을 때 JVM에서 발생시키는 예외입니다. 이는 애플리케이션 코드에서 잡으려고 시도해서는 안 됩니다. OutOfMemoryError와 같은 에러는 애플리케이션 레벨에서 복구가 불가능합니다.
Exception (Checked Exception): 애플리케이션 코드에서 발생하는 예외로, 명시적인 처리가 필요합니다. Exception 클래스의 서브클래스이면서 RuntimeException을 상속하지 않은 예외를 체크 예외라고 합니다.
RuntimeException (Unchecked Exception): 명시적인 예외 처리를 강제하지 않는 언체크 예외입니다. 이는 프로그램 오류를 피할 수 있도록 설계된 것으로, 예를 들어 NullPointerException, IllegalArgumentException과 같은 예외가 여기에 속합니다.

예외를 어떻게 다룰 것인가?

체크 예외 vs 언체크 예외

체크 예외: 발생할 가능성이 있는 예외를 반드시 처리하도록 강제합니다. 예외가 발생할 수 있는 메서드를 호출할 때 throws 또는 try-catch 블록을 사용해 처리해야 합니다.
언체크 예외: 개발자의 실수로 인해 발생할 수 있는 예외로, 명시적으로 처리할 필요는 없습니다. 다만, 프로그램의 예측 가능한 오류를 방지하기 위해 사전에 설계를 통해 문제를 해결할 수 있습니다.

예외 처리 방법

예외 복구

예외가 발생하더라도 정상 상태로 복구하는 것이 가능하다면 이를 시도해야 합니다. 예를 들어, 파일을 읽는 중에 IOException이 발생했다면, 사용자가 다른 파일을 선택하도록 유도하는 방법이 있습니다. 예외 발생 시 무조건 프로그램을 종료하는 대신, 재시도를 통해 문제를 해결하거나, 상황에 맞게 처리하는 것이 중요합니다.

예외 회피

예외를 자신이 처리하지 않고 호출한 메서드로 던져버리는 방식입니다. throws 키워드를 사용하거나, catch 블록에서 예외를 잡은 후 다시 던질 수 있습니다. 단, 예외를 던질 때에는 반드시 다른 객체나 메서드가 이 예외를 처리할 수 있도록 해야 합니다.

예외 전환

예외를 회피하는 것과 비슷하지만, 단순히 던지는 것이 아니라 의미 있는 예외로 변환하여 던지는 것을 말합니다. 예를 들어, DB에서 중복된 사용자를 추가하려고 할 때 SQLException이 발생하면, 이를 DuplicateUserIdException으로 변환하여 더 명확한 의미를 부여할 수 있습니다. 이를 통해 서비스 계층에서 예외 상황을 더 쉽게 파악하고 적절하게 처리할 수 있습니다.

최근 예외 처리 방법

최근 서버 환경에서는 체크 예외를 빠르게 런타임 예외로 전환하여 처리하는 경향이 있습니다. 런타임 예외는 예상하지 못했던 상황에서 발생하므로, 시스템 레벨에서 자동으로 처리되도록 설계하는 것이 일반적입니다.

낙관적 예외 처리 기법

복구할 수 없는 예외가 없다는 가정 하에, 예외가 발생하면 시스템 레벨에서 알아서 처리해줄 것이라고 믿고 개발하는 방식도 존재합니다. 예를 들어, 은행 계좌에서 출금하는 기능을 설계할 때, 출금 가능 여부를 확인하고 부족한 경우 InsufficientBalanceException을 던지도록 설계할 수 있습니다. 이를 통해 정상적인 흐름과 예외 상황을 명확하게 구분하고, 발생 가능한 예외 상황에 대해 사전에 대응할 수 있습니다.

[프로그래머스] 표 편집 - JAVA

보안공돌이 — Thu, 3 Oct 2024 16:24:54 +0900

문제링크

https://school.programmers.co.kr/learn/courses/30/lessons/81303

프로그래머스

코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.

programmers.co.kr

문제 접근

시간 초과 코드 개선하는 과정이 들어있습니다.

초반 접근

- 모든 유저는 softdelete가 된다고 생각하였고 이를 배열로만 구현을 하겠다는 생각을 하게 되었음.

- 삭제된 것을 복귀하기 위한 Stack을 사용하였으며 모든 것들은 배열의 이동을 통해 구현하였음.

결과 : 시간 초과

원인 : 최대 1,000,000 * 200,000의 연산이 발생할 수 있으며 인덱스의 이동을 통해 구현했기 때문에 다음과 같은 부분에서 시간 초과가 발생하 수 있음.

현재 유저 인덱스 10

비활성 유저 인덱스 11 ~ 9999999

다음 활성 유저 인덱스 10000000

다음 인덱스를 찾기 위해 해당 과정을 무수히 반복해야함. 비효율적인 연산이 발생하고 있음을 파악할 수 있음.

최적화 접근

- 위와 같은 불 필요한 연산을 최소화하기 위해 양방향 링크드 리스트를 구현.

- 해당 리스트는 활성 유저만을 관리하고 있기 때문에 불 필요한 연산이 필요 없음.

- 비활성 유저의 경우 boolean형 isDel[] 배열을 사용하여 관리함.

- O(N)의 시간에서 인덱스 이동 시 O(1)로 시간을 줄여 효과적인 연산이 가능함.

해당 문제는 del 연산을 어떻게 처리하는지가 중점임

Code

시간 초과 코드

import java.util.*;

class Solution {
    static class User {
        int index;
        boolean active;

        public User(int index, boolean active) {
            this.index = index;
            this.active = active;
        }
    }

    static int nowIndex;
    static Stack<Integer> removed = new Stack<>();

    public String solution(int n, int k, String[] cmd) {
        
        nowIndex = k;
        User[] users = new User[n];
        for (int i = 0; i < n; i++) {
            users[i] = new User(i, true);  
        }

        for (String command : cmd) {
            processCommand(command, users);
        }

        return buildResult(users);
    }

    private static void processCommand(String command, User[] users) {
        StringTokenizer st = new StringTokenizer(command);
        String cmd = st.nextToken();

        switch (cmd) {
            case "U":
                moveUp(users, Integer.parseInt(st.nextToken()));
                break;
            case "D":
                moveDown(users, Integer.parseInt(st.nextToken()));
                break;
            case "C":
                delete(users);
                break;
            case "Z":
                undo(users);
                break;
        }
    }


    private static void moveUp(User[] users, int count) {
        int moveCount = 0;
        while (moveCount < count) {
            nowIndex--;
            if (users[nowIndex].active) {
                moveCount++;
            }
        }
    }


    private static void moveDown(User[] users, int count) {
        int moveCount = 0;
        while (moveCount < count) {
            nowIndex++;
            if (users[nowIndex].active) {
                moveCount++;
            }
        }
    }

    private static void delete(User[] users) {
        users[nowIndex].active = false; 
        removed.push(nowIndex); 

        if (isLastActiveRow(users)) {
            moveUp(users, 1); 
        } else {
            moveDown(users, 1); 
        }
    }


    private static boolean isLastActiveRow(User[] users) {
        for (int i = nowIndex + 1; i < users.length; i++) {
           if (users[i].active) {
             return false;  
         }
     }
     return true; 
    }


    private static void undo(User[] users) {
        int restoredIndex = removed.pop();
        users[restoredIndex].active = true; 
    }

    private static String buildResult(User[] users) {
        StringBuilder result = new StringBuilder();
        for (User user : users) {
            if (user.active) {
                result.append("O");
            } else {
                result.append("X");
            }
        }
        return result.toString();
    }
}

통과 코드

import java.util.*;

class Solution {
    static class Node{
        int pre;
        int next;
        public Node(int pre, int next){
            this.pre = pre;
            this.next = next;
        }
    }
    public String solution(int n, int k, String[] cmd) {
        String answer = "";
        Stack<Integer> delNode = new Stack<>();
        boolean[] isDel = new boolean[n];
        Node[] node = new Node[n]; 
        for(int i = 0; i < n; i++){
            node[i] = new Node(i-1, i +1);
        }
        node[n-1].next = -1; // 마지막 node 처리
        
        int nowIndex = k;
        
        for(String c : cmd){
            char command = c.charAt(0);
            if(command == 'U'){
                int cnt = Integer.parseInt(c.substring(2));
                while(cnt-- > 0) nowIndex = node[nowIndex].pre;
            }else if(command == 'D'){
                int cnt = Integer.parseInt(c.substring(2)); 
                while(cnt-- > 0) nowIndex = node[nowIndex].next;
            }else if(command == 'C'){
                delNode.push(nowIndex);
                isDel[nowIndex] = true;
                if(node[nowIndex].pre != -1) node[node[nowIndex].pre].next = node[nowIndex].next;
                if(node[nowIndex].next != -1) node[node[nowIndex].next].pre = node[nowIndex].pre;
                nowIndex = (node[nowIndex].next == -1) ? node[nowIndex].pre : node[nowIndex].next;
            }else if(command == 'Z'){
                int undoIndex = delNode.pop();
                isDel[undoIndex] = false;
                if(node[undoIndex].pre != -1) node[node[undoIndex].pre].next = undoIndex;
                if(node[undoIndex].next != -1) node[node[undoIndex].next].pre = undoIndex;
                
            }
        }
        
        // 결과 빌드
        StringBuilder result = new StringBuilder();
        for (int i = 0; i < n; i++) {
            if (isDel[i]) result.append('X');
            else result.append('O');
        }
        
        return result.toString();
    }
}

[프로그래머스] 경주로 건설 - JAVA

보안공돌이 — Thu, 3 Oct 2024 16:12:12 +0900

문제링크

https://school.programmers.co.kr/learn/courses/30/lessons/67259

프로그래머스

programmers.co.kr

문제 접근

전형적인 bfs 문제이나 다음과 같은 부분을 중점으로 코드를 구성함.

기존 bfs처럼 방문했다면 방문을 하지 않는 것이 아닌 다른 경로를 통해 해당 위치에 도착하는 경우가 비용이 더 저렴할 수 있다는 점을 고려하여 아래와 같은 로직을 구성함.

4방향에 대해 3차원 배열을 구성하고 비용이 적을 때만 해당 위치의 값을 갱신할 수 있도록 구성함.

if (newCost < cost[nx][ny][i]) {
cost[nx][ny][i] = newCost;

Code

import java.util.*;

class Solution {
    static class Car {
        int x, y, score, d;
        public Car(int x, int y, int score, int d) {
            this.x = x;
            this.y = y;
            this.score = score;
            this.d = d;
        }
    }
    
    public int solution(int[][] board) {
        int N = board.length;
        int[][][] cost = new int[N][N][4];
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                Arrays.fill(cost[i][j], Integer.MAX_VALUE);
            }
        }
        
        int answer = Math.min(minCost(board, 0, cost), minCost(board, 3, cost));
        return answer;
    }
    
    private int minCost(int[][] board, int startDir, int[][][] cost) {
        int[] dx = {1, 0, -1, 0};
        int[] dy = {0, -1, 0, 1};
        int N = board.length;
        Queue<Car> moveQueue = new LinkedList<>();
        
        cost[0][0][startDir] = 0;
        moveQueue.add(new Car(0, 0, 0, startDir));
        
        int result = Integer.MAX_VALUE;
        while (!moveQueue.isEmpty()) {
            Car now = moveQueue.poll();
            
            if (now.x == N - 1 && now.y == N - 1) {
                result = Math.min(result, now.score);
                continue;
            }
            
            for (int i = 0; i < 4; i++) {
                int nx = now.x + dx[i];
                int ny = now.y + dy[i];
                
                if (nx >= 0 && nx < N && ny >= 0 && ny < N && board[nx][ny] == 0) {
                    int newCost = now.score + ((now.d == i) ? 100 : 600);
                    if (newCost < cost[nx][ny][i]) {
                        cost[nx][ny][i] = newCost;
                        moveQueue.add(new Car(nx, ny, newCost, i));
                    }
                }
            }
        }
        
        return result;
    }
}

[프로그래머스] 거리두기 확인하기 - JAVA

보안공돌이 — Thu, 3 Oct 2024 16:06:35 +0900

문제링크

https://school.programmers.co.kr/learn/courses/30/lessons/81302

프로그래머스

programmers.co.kr

문제 접근

다음과 같은 조건을 만족해야 한다.

대기실은 5개이며, 각 대기실은 5x5 크기
거리두기를 위하여 응시자들 끼리는 맨해튼 거리1가 2 이하로 앉지 말아야 한다.
단, 응시자가 앉아있는 자리 사이가 파티션으로 막혀 있을 경우에는 허용함

맨해튼 거리 1인 경우와 2인 경우를 분리하여 코드를 구성한다면 보다 쉽게 문제를 해결 할 수 있다.

Code

class Solution {
    static final int size = 5;
    
    public int[] solution(String[][] places) {
        int[] answer = new int[size];
        
        int i = 0;
        for (String[] place : places) {
            answer[i++] = distance(place); 
        }
        return answer;
    }
    
    private static int distance(String[] place) {
        char[][] map = new char[size][size];
        
        for (int i = 0; i < size; i++) {
            map[i] = place[i].toCharArray(); 
        }
        
        return isPossible(map) ? 1 : 0;
    }
    
    private static boolean isPossible(char[][] map) {
        for (int i = 0; i < size; i++) {
            for (int j = 0; j < size; j++) {
                if (map[i][j] == 'P') {
                    if (!distanceManhattan(map, i, j)) {
                        return false;
                    }
                }
            }
        }
        return true;
    }
    
    private static boolean distanceManhattan(char[][] map, int x, int y) {
        int[] dx = {-1, 0, 1, 0};
        int[] dy = {0, -1, 0, 1};
        
        for (int dir = 0; dir < 4; dir++) {
            int nx = x + dx[dir];
            int ny = y + dy[dir];
            
            if (isValid(nx, ny) && map[nx][ny] == 'P') {
                return false;
            }
        }
        
        int[][] checkDist2 = {
            {-2, 0}, {2, 0}, {0, -2}, {0, 2}, {-1, -1}, {-1, 1}, {1, -1}, {1, 1}
        };
        
        for (int[] d : checkDist2) {
            int nx = x + d[0];
            int ny = y + d[1];
            
            if (isValid(nx, ny) && map[nx][ny] == 'P') {
                if (d[0] == 0) { 
                    if (map[x][(y + ny) / 2] != 'X') {
                        return false; 
                    }
                } else if (d[1] == 0) {  
                    if (map[(x + nx) / 2][y] != 'X') {
                        return false; 
                    }
                } else {
                    if (map[x][ny] != 'X' || map[nx][y] != 'X') {
                        return false; 
                    }
                }
            }
        }
        
        return true;
    }
    
    private static boolean isValid(int x, int y) {
        return x >= 0 && x < size && y >= 0 && y < size;
    }
}

[프로그래머스] 징검다리 건너기 - JAVA

보안공돌이 — Thu, 3 Oct 2024 15:56:32 +0900

문제링크

https://school.programmers.co.kr/learn/courses/30/lessons/64062

프로그래머스

programmers.co.kr

문제 접근

해당 문제를 해결하기 위해서는 다음과 같은 조건을 만족해야 한다.

1. 디딤돌의 숫자를 한 번 밟을 때 마다 1씩 줄어든다.

2. 0이 되면 해당 돌을 밟을 수 없다.

3. 무조건 가장 가까운 돌로만 건널 수 있다.

4. 최대로 건너뛸 수 있는 돌은 K개 이다.

"핵심 아이디어"

돌의 숫자 - 뛸 수 있는 인원이 <0 일 때 돌을 건너뛴다.

건너뛴 돌의 수가 K수와 같아진다면 건널 수 없다.

for(int stone : stones){
            if(stone - friends < 0){
                jump++;
            }else{
                jump = 0;
            }
            if(jump == k){
                return false;
            }
        }

뛸 수 인원이 20,000,000명 일 수 있기 때문에 1명부터 20,000,000을 모두 계산하는 것은 매우 비효율적이다.

이분탐색 기법을 활용하여 최대의 인원에서 / 2씩 수행하며 최소 값을 구하는 것이 현명하다.

Code

class Solution {
    public int solution(int[] stones, int k) {
        int answer = 0;
        
        int min =  1;
        int max = 200000000;
        
        while(min <= max){
            int mid = (min + max) / 2 ;
            // 넘어갈 수 있다면 
            if(isPossible(stones, k, mid)){
                min = mid +1 ;
                answer = Math.max(answer, mid);
            }else{
                // 못 넘어간다면 
                max = mid - 1;
            }
            
        }
        return answer;
    }
    
    public static boolean isPossible(int[] stones, int k, int friends){
        int jump = 0;
        for(int stone : stones){
            if(stone - friends < 0){
                jump++;
            }else{
                jump = 0;
            }
            if(jump == k){
                return false;
            }
        }
        return true;
    }
}

[프로그래머스] 보석 쇼핑 - JAVA

보안공돌이 — Thu, 3 Oct 2024 15:45:41 +0900

문제링크

https://school.programmers.co.kr/learn/courses/30/lessons/67258

프로그래머스

programmers.co.kr

문제 접근

해당 문제 해결을 위해 다음과 같은 조건을 만족해야 한다.

1. 모든 보석을 구매해야한다.

2. 모든 보석을 구매하며 가장 짧은 구간을 찾아야 한다.

1번 조건을 해결하기 위해 보석의 총 개수를 Set를 통하여 구하며 Map을 사용하여 보석을 Key로 지정하여 gemsSize와 동일한지 비교한다.

int gemsSize = allGems.size();

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

gemsMap.size() == gemsSize // 다음과 같은 조건이 만족된다면 1번 조건을 만족함.

2번 조건을 만족하기 위해서는 구간을 줄여나가는 것이 중요함. 1번 조건을 만족하는 상태에서 시작 지점을 점차 키워나간다면 가장 짧은 구간의 Start 지점을 찾을 수 있다.

즉, 슬라이딩 윈도우를 사용한다면 문제를 해결할 수 있다.

코드는 아래와 같다.

Code

import java.util.*;

class Solution {
    public int[] solution(String[] gems) {
        int[] answer = {};
        Set<String> allGems = new HashSet<>(Arrays.asList(gems));
        
        Map<String, Integer> gemsMap = new HashMap<>();
        
        
        int gemsSize = allGems.size();
        int minLength = Integer.MAX_VALUE;
        int start = 0, end = 0;
        int startIndex = 0;
        
        while(end < gems.length){
           
            gemsMap.put(gems[end], gemsMap.getOrDefault(gems[end], 0) + 1);
            end++;
            
            while(gemsMap.size() == gemsSize){
                if(end - start < minLength){
                    minLength = end - start;
                    startIndex = start;  
                }
                
                gemsMap.put(gems[start], gemsMap.get(gems[start]) -1);
                if(gemsMap.get(gems[start]) == 0 ){
                    gemsMap.remove(gems[start]);
                }
                start++;
            }
            
            
        }
        
        return new int[]{startIndex + 1, startIndex + minLength};
    }
}

[프로그래머스] 양과 늑대 - JAVA

보안공돌이 — Thu, 4 Jul 2024 09:39:11 +0900

문제링크

https://school.programmers.co.kr/learn/courses/30/lessons/92343?language=java

프로그래머스

programmers.co.kr

문제 접근

- 모든 상황에 대해 DFS 순회가 가능하도록 설계

해당 노드 방문 여부에 따른 Cnt 체크
sheepCnt가 wolfCnt보다 작거나 같은 경우 Return
부모 노드 방문, 자식 노드 미방문 시 순회.

Code

class Solution {

    int[] copyInfo;
    int[][] copyEdges;
    int maxSheepCnt = 0;
    
    int SHEEP = 0;
    int WOLF = 1;

    public int solution(int[] info, int[][] edges) {
        copyInfo = info; // 총 길이
        copyEdges = edges;
        boolean[] visited = new boolean[info.length];
        dfs(0, visited, 0, 0);

        return maxSheepCnt;
    }

    public void dfs(int idx, boolean[] visited, int sheepCnt, int wolfCnt) {
        visited[idx] = true; // 방문 노드 체크
        // if (gInfo[idx] == 0)
        if (copyInfo[idx] == SHEEP) { // 양이라면 
            sheepCnt++;
            maxSheepCnt = Math.max(maxSheepCnt, sheepCnt);
        } else { // 늑대라면
            wolfCnt++;
        }

        if (sheepCnt <= wolfCnt) { // 늑대가 양보다 같거나 많으면 종료
            return;
        }

        for (int[] edge : copyEdges) { // 모든 상황에 대한 순회
            if (visited[edge[0]] && !visited[edge[1]]) { // 부모 노드는 방문했고, 자식 노드는 방문하지 않았을 때 
            	boolean[] nextVisited = deepCopyVisitedArray(visited);
                
                dfs(edge[1], nextVisited, sheepCnt, wolfCnt);
            }
        }
    }
    
    public boolean[] deepCopyVisitedArray(boolean array[]){
        boolean[] copyVisitedArray = new boolean[array.length];
            for (int i = 0; i < array.length; i++) {
                copyVisitedArray[i] = array[i];
        }
        return copyVisitedArray;
    }
}

Code Review

- 코드 리펙터링 내용

- 작은 단위의 함수화

# 최대 값을 갱신하는 Math.max 를 활용하여 가독성을 증대 시켰음

 maxSheepCnt = Math.max(maxSheepCnt, sheepCnt);
// if (sheepCnt > maxSheepCnt) {
 //     maxSheepCnt = sheepCnt;
// }
 

     
# 아래 반복문을 함수로 변경하였음
                
boolean[] nextVisited = new boolean[visited.length];
for (int i = 0; i < visited.length; i++) {
                	nextVisited[i] = visited[i];

boolean[] nextVisited = deepCopyVisitedArray(visited);

    public boolean[] deepCopyVisitedArray(boolean array[]){
        boolean[] copyVisitedArray = new boolean[array.length];
            for (int i = 0; i < array.length; i++) {
                copyVisitedArray[i] = array[i];
        }
        return copyVisitedArray;
    }
}

배운 점

Java Collection Framework - Collection interface - Map

보안공돌이 — Tue, 2 Jul 2024 10:22:15 +0900

안녕하세요.

오늘은 Java Collection Freamwork의 마지막 자료구조인 Map에 대해 설명드리도록 하겠습니다.

Map 자료 구조의 경우와 같은 특징을 가지고 있습니다.

Key와 Value의 쌍으로 데이터를 저장한다.
Value의 경우 중복이 허용되지만, Key의 경우 중복을 허용하지 않는다.
중복된 키를 사용하게 되면 기존 값이 삭제 되고 마지막 저장 값을 다시 저장한다.
저장 순서를 보장하지 않는다.

또한, Map Interface 안에는 HashMap, LinkedHashMap, HashTable, TeeMap 등이 존재하는데요.

각각의 특징을 하나 하나 살펴보도록 하겠습니다.

Map의 Entry에 대해 먼저 알아보도록 하겠습니다.

Entry는 Map Interface 안에 있는 내부 인터페이스입니다.

Map에 저장되는 Key-Value 쌍의 Node 내부 클래스가 이를 구현하고 있다는 특징을 가지고 있습니다.

Map 자료구조를 보다 객체지향적인 설계를 하도록 유도하기 위함입니다.

그럼 HashMap부터 알아볼까요?

HashMap 은 기존은 HashTable의 단점을 보완한 컬렉션 입니다.

배열과 연결이 결합된 Hashing 형태로 Key,Value를 묶어 하나의 데이터로 저장한다는 특징을 가지고 있습니다.

Map의 기본적인 특징을 잘 보여주는 예시로 중복을 허용하지 않으며 순서를 보장하지 않습니다.

Key 및 Value로 Null을 허용한다는 특징도 가지고 있습니다.

다만, 비동기 처리로 동작하기 때문에 멀티 쓰레드 환경에서 적합하지 않습니다. 해당 경우는 다중 쓰레드에서 하나의 자료구조를 참조할 수 있도록 ConcurrentHashMap을 사용하곤 합니다.

다음은 LinkedHashMap입니다.

이전, 포스팅에서 Linked라는 이름이 붙으면 순서를 보장한다고 했던 것 기억하시나요?

해당 자료구조도 동일한 특징을 갖고 있습니다. HashMap의 특징을 가지고 있지만 들어온 순서를 보장한다는 특징을 보여주고 있습니다.

아래와 같이 10,20,50 순으로 넣게 된다면 해당 순서를 기억하여 10, 20,50 이 출력됨을 확인할 수 있습니다.

마지막으로 TreeMap 입니다.

LinkedHashMap과 유사한 특징을 가지지만 순서를 기억하는 것이 아닌 정렬이 된다는 특징을 갖습니다.

또한, 이진 검색 트리의 형태로 범위 검색 시 큰 장점을 가지고 있습니다.

다만, 정렬이 지속적으로 이루어지기 때문에 저장 시간의 경우 오래 걸린다는 특징을 가지고 있습니다.

그렇기 때문에 10,20,50,40을 넣더라도 나오는 순서는 -> 10,20,40,50으로 정렬된 것을 확인할 수 있습니다.

아래 문제들을 풀며 Map 자료구조에 대해 익혀보시는 것을 권장드립니다.

Java Collection Framework - Collection interface - Set

보안공돌이 — Fri, 21 Jun 2024 14:07:01 +0900

안녕하세요.

오늘은 이전 포스팅에 있어 Set 자료구조에 대해 알아보도록 하겠습니다.

Set Interface는 아래와 같은 특징을 가지고 있습니다.

데이터의 중복을 허용하지 않으며 순서를 유지하지 않음.
순서가 존재하지 않기 때문에 Index로 접근이 불가능함.
중복이 불가능하기 때문에 null 또한, 한 개만 저장할 수 있음.

그럼 HashSet에 대해 알아보도록 하겠습니다.

HashSet는 아래와 같은 특징을 가지고 있습니다.

배열과 연결 노드를 연결한 자료구조
임의 검색 접근 속도에서는 가장 빠른 속도를 보임.
추가, 삭제, 검색 등의 접근성이 매우 뛰어남.
순서가 보장되지 않아 순서 예측은 불가능.

Set<Integer> hashSet = new HashSet<>();

hashSet.add(70);
hashSet.add(20);
hashSet.add(90);
hashSet.add(20); // 중복

hashSet.size(); // 3 - 중복 카운트 X

hashSet.toString(); // [20, 90, 70]

만약, 순서를 유지하는 Set 자료 구조가 필요하다면 어떻게 해야 할까요?

즉, 순서 유지는 필요하지만 중복을 제거하고 싶다면 LinkedHashSet를 사용하면 됩니다

순서를 가지는 Set 자료구조
추가된 순서 또는 가장 최근에 접근한 순서대로 접근이 가능함
중복은 제거하며 순서를 유지하고 싶을 때 적합

Set<Integer> linkedHashSet = new LinkedHashSet<>();

linkedHashSet.add(70);
linkedHashSet.add(20);
linkedHashSet.add(80);
linkedHashSet.add(20); // 중복 추가

linkedHashSet.size(); // 3 - 중복 카운트 X

linkedHashSet.toString(); // [70, 20, 80] 입력 순서 유지

그럼, 데이터를 정렬하며 중복을 허용하지 않을 때는 어떤 자료구조를 사용하면 될까요?

TreeSet 자료를 사용하시면 되는데요.

TreeSet은 이진 검색 트리 자료구조를 기반으로 데이터를 저장합니다.

이를 통해 데이터를 정렬하고 범위 검색, 정렬, 검색 등에서 높은 성능을 보장한다는 것이 특징이며 Set을 기반으로 하고 있기 때문에 중복을 허용하지 않는 특징을 가지게 됩니다.

Set<Integer> treeSet = new TreeSet<>();

treeSet.add(5);
treeSet.add(3);
treeSet.add(4);
treeSet.add(1);
treeSet.add(2);

treeSet.toString(); // [1, 2, 3, 4, 5]

그럼 문제를 풀어보도록 하겠습니다.

해당 문제들이 어떤 자료구조에 적합한지 결정해 볼까요.

1. 중복을 허용하지 않는다. (y / n)

2. 순서가 중요하다. (y / n)

3. 정렬이 되어 있어야 한다. (y / n)

백준 3052 나머지

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashSet;
import java.util.Set;

public class BOJ_3052 {
    /*
     * 10개를 입력받은 뒤, 이를 42로 나눈 나머지를 구한다. 그 다음 서로 다른 값이 몇 개 있는지 출력하는 프로그램을 작성하시오.
     * 1. 중복을 허용하지 않는다. (y / n) => Y(서로 다른 값) 
     * 2. 순서가 중요하다.  (y / n) => N (순서가 중요하지 않음, 크기가 중요함)
     * 3. 정렬이 되어 있어야 한다. (y / n) => N (정렬이 중요하지 않음, 크기가 중요함)
     * 
     * 단순 Set 자료로 해결이 가능하기에 HashSet을 통해 문제를 해결 가능함.
     */
    public static void main(String[] args) throws NumberFormatException, IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 
        Set<Integer> set = new HashSet<>();

        for (int i = 0; i < 10; i++) {
            int temp = Integer.parseInt(br.readLine()) % 42;
            set.add(temp);
        }
        System.out.println(set.size());
    }
    
}

백준 13414 수강신청

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.StringTokenizer;

public class BOJ_13414{
        /*
     * 순서에 따라 정렬해야함. + 중복 발생하면 안된다. 
     * 
     * 1. 중복을 허용하지 않는다. (y / n) => Y(같은 값이 있으면 삭제 후 다시 삽입) 
     * 2. 순서가 중요하다.  (y / n) => Y (수강 신청 시간 )
     * 3. 정렬이 되어 있어야 한다. (y / n) => N 
     * 
     * 단순 Set 자료로 해결이 가능하기에 HashSet을 통해 문제를 해결 가능함.
     */
	public static void main(String[] args) throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());
        StringBuilder sb = new StringBuilder();
		int k = Integer.parseInt(st.nextToken());
        int l = Integer.parseInt(st.nextToken());
		LinkedHashSet<String> hs = new LinkedHashSet<>();
		String tmp;

		for(int i=0;i<l;i++){
			tmp = br.readLine();
			if(hs.contains(tmp)) hs.remove(tmp);
			hs.add(tmp);
		}
		Iterator<String> it = hs.iterator();
		while(it.hasNext()){
            sb.append(it.next() + "\n");
            if(--k < 1) break;
		}

        System.out.println(sb.toString());
		
		
	}
}

백준 2957

위 문제는 TreeSet을 이용하여 풀 수 있습니다.

해당 문제까지 풀어보시길 추천 드립니다.

Java Collection Framework - Collection interface - Queue

보안공돌이 — Thu, 20 Jun 2024 16:32:30 +0900

안녕하세요.

이전 시간에 이어 Collection Interface의 Queue를 배워보도록 하겠습니다.

Queue 자료 구조는 대표적인 FIFO 형태로 먼저 들어온 원소가 가장 먼저 나가는 특징을 가지고 있는 자료 구조입니다.

Queue의 구현체로는 양방향 큐라고 불리는 ArrayDeque, PriortyQueue 등이 존재합니다.

제공되는 메서드로는 다음과 같습니다.

그럼 우선 순위 큐에 대해 알아보도록 하겠습니다.

우선순위를 가지는 Queue로 부여된 우선순위에 맞춰 정렬되어 반환 값을 제공합니다.

우선순위를 지정하기 위해서는 compareTo 메서드를 통해 지정해주어야 합니다.

대표적인 특징으로는 배열을 저장 공간으로 사용하고 힙 형태로 데이터를 저장한다는 것인데요.

이를 통해 우선순위 갱신이 빠르게 진행되고 가장 큰 값, 혹은 작은 값은 빠르게 찾을 수 있다는 장점이 존재합니다.

우선순위를 지정하는 예제는 아래와 같습니다.

class Student implements Comparable<Student> {
    String name; 
    int priority; 

    public Student(String name, int priority) {
        this.name = name;
        this.priority = priority;
    }
    @Override
    public int compareTo(Student user) {
      
        if (this.priority < user.priority) {
            return -1;
        } else if (this.priority == user.priority) {
            return 0;
        } else {
            return 1;
        }
    }

}

그럼 Deque에 대해 알아볼까요?

Deque는 양방향으로 삽입, 삭제가 가능한 자료구조를 의미합니다.

큐와 스택의 특징을 모두 가지고 있어 상황에 맞춰 큐 혹은 스택으로의 사용이 용이합니다.

Deque의 조상은 Queue이며 구현체로 LinkdList, ArrayDeque가 존재합니다.

그럼 구현체인 ArrayDeque를 확인해 보도록 하겠습니다.

배열을 사용하여 구현되어 있기 때문에 스택의 사용 혹은 대기열로의 사용에서는 LinkedList보다 빠르다는 장점을 보여주고 있습니다.

또한, 사이즈의 제한이 없으며 null 저장을 허용하지 않는다는 특징을 가지고 있습니다.

그럼 LinkedList는 어떤 상황에서 유리할까요?

Queue로의 구현 시 ArrayDeque 보다 성능이 좋습니다.

ArrayDeque의 경우 배열을 기반으로 하기에 앞의 데이터가 삭제됨에 따라 빈 공간을 채우기 위해 데이터의 이동이 빈번하게 이루어지기 때문입니다.

큐 문제로는 아래 문제를 풀어보시면 이해가 빠를 것이라 생각합니다.

https://www.acmicpc.net/problem/2075

Deque 관련 문제로는 아래 문제를 풀어보시면 이해가 빠를 것이라 생각합니다.

https://www.acmicpc.net/problem/10866

다음 포스팅에서는 Set에 대해 알아보도록 하겠습니다.