문제

백준 2358번-평행선

평면에 n개의 점이 있다. 그중 두 개 이상의 점을 지나면서 x축 또는 y축에 평행한 직선이 몇 개인지 알아내는 프로그램을 작성하시오.

입력: 첫째 줄에 n(1 ≤ n ≤ 100,000)이 주어진다. 다음 n개의 줄에는 각 점의 좌표가 주어진다. 같은 좌표가 여러 번 주어질 수 있으며, 그런 경우 서로 다른 점으로 간주한다. 좌표는 절댓값이 231보다 작은 정수이다.

출력: 첫째 줄에 답을 출력한다.

예시

입력:

4
0 0
10 10
0 10
10 0

출력:

4

풀이

import java.util.*;
import java.io.*;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        StringTokenizer st;

        int n = Integer.parseInt(br.readLine());

        Map<Integer, Integer> y = new HashMap<>(), x = new HashMap<>();
        while (n-- > 0) {
            st = new StringTokenizer(br.readLine());
            int input = Integer.parseInt(st.nextToken());
            if (y.containsKey(input))
                y.put(input, y.get(input) + 1);
            else
                y.put(input, 0);

            input = Integer.parseInt(st.nextToken());
            if (x.containsKey(input))
                x.put(input, x.get(input) + 1);
            else
                x.put(input, 0);
        }

        int cnt = 0;
        for (int key : y.keySet())
            if (y.get(key) > 0)
                cnt++;

        for (int key : x.keySet())
            if (x.get(key) > 0)
                cnt++;

        bw.write(String.valueOf(cnt));
        bw.flush();
    }
}

회고

참고: https://graycode.tistory.com/350

문제

LeetCode 705-Design HashMap Design a HashMap without using any built-in hash table libraries.

Implement the MyHashMap class:

• MyHashMap() initializes the object with an empty map.
• void put(int key, int value) inserts a (key, value) pair into the HashMap. If the key already exists in the map, update the corresponding value.
• int get(int key) returns the value to which the specified key is mapped, or -1 if this map contains no mapping for the key.
• void remove(key) removes the key and its corresponding value if the map contains the mapping for the key.

예시

Input

["MyHashMap", "put", "put", "get", "get", "put", "get", "remove", "get"]
[[], [1, 1], [2, 2], [1], [3], [2, 1], [2], [2], [2]]

Output

[null, null, null, 1, -1, null, 1, null, -1]

Explanation

MyHashMap myHashMap = new MyHashMap();
myHashMap.put(1, 1); // The map is now [[1,1]]
myHashMap.put(2, 2); // The map is now [[1,1], [2,2]]
myHashMap.get(1);    // return 1, The map is now [[1,1], [2,2]]
myHashMap.get(3);    // return -1 (i.e., not found), The map is now [[1,1], [2,2]]
myHashMap.put(2, 1); // The map is now [[1,1], [2,1]] (i.e., update the existing value)
myHashMap.get(2);    // return 1, The map is now [[1,1], [2,1]]
myHashMap.remove(2); // remove the mapping for 2, The map is now [[1,1]]
myHashMap.get(2);    // return -1 (i.e., not found), The map is now [[1,1]]

풀이

class ListNode {
    int key, val;  // 각각 저장된 키와 값
    ListNode next; // 체이닝 방식으로 다음 노드를 가리키는 링크
    public ListNode(int key, int val, ListNode next) {
        this.key = key;
        this.val = val;
        this.next = next;
    }
}

class MyHashMap {
    static final int size = 19997; // 해시 테이블의 크기 (소수 사용 -> 충돌 줄이기)
    static final int mult = 12582917; // 해시 함수 성능 향상용 큰 소수 (곱셈 해시)
    ListNode[] data; // 각 해시 인덱스에 연결리스트를 저장하는 배열

    public MyHashMap() {
        this.data = new ListNode[size];
    }

    //곱셈 후 모듈러 연산으로 해시 인덱스 계산
    //일반적인 key % size보다 충돌이 훨씬 적은 고성능 해시 함수
    private int hash(int key) {
        // long으로 캐스팅한 이유는 key * mult가 int 범위를 넘을 수 있어서
        return (int)((long)key * mult % size);
    }

    public void put(int key, int val) {
        remove(key); // 같은 키 있으면 먼저 지움
        int h = hash(key);
        ListNode node = new ListNode(key, val, data[h]); // 새로운 노드를 헤드에 삽입(속도 빠름)
        data[h] = node;
    }

    public int get(int key) {
        int h = hash(key);
        ListNode node = data[h];
        //해당 인덱스(버킷)에 연결된 노드들 순회
        for(; node != null; node = node.next) {
            if (node.key == key) {
                return node.val;
            }
        }
        return -1;
    }

    //헤드 노드가 삭제 대상이면 바로 다음 노드를 넣음
    //중간 노드는 node.next로 탐색하면서 삭제
    public void remove(int key) {
        int h = hash(key);
        ListNode node = data[h];
        if (node == null) {
            return;
        }
        if (node.key == key) {
            data[h] = node.next;
        } else for (; node.next != null; node = node.next) {
            if (node.next.key == key) {
                node.next = node.next.next;
                return;
            }
        }
    }
}

회고

처음에는 output을 보고 배열로 풀었으나 HashMap을 구현하라는 문제의 취지와는 어긋나는 것 같아서 제일 좋아요 많이 받은 코드를 대신한다.

문제

LeetCode 2283-Check if Number Has Equal Digit Count and Digit Value

You are given a 0-indexed string num of length n consisting of digits.

Return true if for every index i in the range 0 <= i < n, the digit i occurs num[i] times in num, otherwise return false.

Constraints:

• n == num.length
• 1 <= n <= 10
• num consists of digits.

예시

Example 1:

• Input: num = "1210"
• Output: true
• Explanation: num[0] = '1'. The digit 0 occurs once in num. num[1] = '2'. The digit 1 occurs twice in num. num[2] = '1'. The digit 2 occurs once in num. num[3] = '0'. The digit 3 occurs zero times in num. The condition holds true for every index in "1210", so return true.

즉, 표로 정리하면 다음과 같다.

Example 2:

• Input: num = "030"
• Output: false
• Explanation: num[0] = '0'. The digit 0 should occur zero times, but actually occurs twice in num. num[1] = '3'. The digit 1 should occur three times, but actually occurs zero times in num. num[2] = '0'. The digit 2 occurs zero times in num. The indices 0 and 1 both violate the condition, so return false.

풀이

class Solution {
    public boolean digitCount(String num) {
        int[] count = new int[10]; // 숫자 0~9의 등장 횟수를 저장할 배열

        // 1단계: num 문자열을 순회하면서 각 숫자의 등장 횟수를 센다
        for (char c : num.toCharArray()) {
            int digit = c - '0';  // '3' 같은 문자 → 숫자 3으로 바꿔줌
            count[digit]++;       // 해당 숫자 등장 횟수 증가
        }

        // 2단계: num[i]와 실제 count[i]가 같은지 확인
        for (int i = 0; i < num.length(); i++) {
            int expected = num.charAt(i) - '0'; // num[i] → 기대되는 등장 횟수
            if (count[i] != expected) {
                return false; // 하나라도 틀리면 false
            }
        }

        return true; // 전부 통과하면 true
    }
}

회고

이번 문제는 문제 자체가 뭔 소리를 하나 싶어서 문제 이해에만 5분 넘게 사용한 것 같다..

문제

백준 3986번-좋은 단어 평석이는 단어 위로 아치형 곡선을 그어 같은 글자끼리(A는 A끼리, B는 B끼리) 쌍을 짓기로 하였다. 만약 선끼리 교차하지 않으면서 각 글자를 정확히 한 개의 다른 위치에 있는 같은 글자와 짝 지을수 있다면, 그 단어는 '좋은 단어'이다. 평석이가 '좋은 단어' 개수를 세는 것을 도와주자.

입력: 첫째 줄에 단어의 수 N이 주어진다. (1 ≤ N ≤ 100)

다음 N개 줄에는 A와 B로만 이루어진 단어가 한 줄에 하나씩 주어진다. 단어의 길이는 2와 100,000사이이며, 모든 단어 길이의 합은 1,000,000을 넘지 않는다.

출력: 첫째 줄에 좋은 단어의 수를 출력한다.

예시

입력:

3
ABAB
AABB
ABBA

출력:

2

풀이

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int result = 0;    // 좋은 단어 갯수
        int num = sc.nextInt();
        sc.nextLine();

        for (int i=0; i<num; i++) {
            String line = sc.nextLine();

            if (isGoodWord(line)) {
                result++;
            }
        }
        System.out.print(result);
    }

    private static boolean isGoodWord(String line) {
        Stack<Character> stack = new Stack<>();

        for (char ch:line.toCharArray()) {
            if (!stack.isEmpty() && stack.peek() == ch) {
                stack.pop();    // 짝이 맞으면 제거
            } else {
                stack.push(ch);    // 짝이 아니면 추가
            }
        }

        return stack.isEmpty();    // 비어 있어야 좋은 단어
    }
}

1. line.toCharArray()는 문자열을 문자 배열로 바꾸는 메소드이다.
2. for-each 문으로 line의 각 문자를 하나씩 ch에 꺼내서 반복한다.
3. 만약 스택이 비어있지 않고 스택의 맨 위 문자와 지금 문자가 같으면 pop()을 통해 제거한다.
4. 그렇지 않다면 push()를 통해 스택에 값을 추가한다.
5. 스택 마지막이 비어있으면 좋은 단어로 간주하고 result++를 진행한다.

회고

시간이 없다.. 시간을 내자

문제

LeetCode 70-Climbing Stairs You are climbing a staircase. It takes n steps to reach the top.

Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?

예시

Example 1:

• Input: n = 2
• Output: 2
• Explanation: There are two ways to climb to the top.
  1. 1 step + 1 step
  2. 2 steps

Example 2:

• Input: n = 3
• Output: 3
• Explanation: There are three ways to climb to the top.
  1. 1 step + 1 step + 1 step
  2. 1 step + 2 steps
  3. 2 steps + 1 step

풀이

class Solution {
    public int climbStairs(int n) {
        if (n <= 2) {
            return n;
        }

        int first = 1;
        int second = 2;

        for (int i = 3; i <= n; i++) {
            int thrid = first + second;
            first = second;
            second = thrid;
        }

        return second;
    }
}

1. 계단이 1칸이면 1가지 방법, 2칸이면 2가지 방법(1+1, 2) 밖에 없으므로 n이 2 이하일 때는 그대로 반환한다.
2. first는 1칸일 때의 방법 수, second은 2칸일 때의 방법 수를 의미한다.
3. 계단이 3칸일 때부터 n칸 까지 for문을 반복한다.
4. thrid에 현재 계단의 경우의 수를 저장하고, first, second를 다음 계산을 위해 한 칸씩 앞으로 옮긴다.
5. 반복문이 끝나면 second에는 n칸 계단을 올라가는 총 방법 수가 들어 있다.

회고

피보나치 수열에 관련된 문제들을 몇 개 풀어서 응용해봐야겠다는 생각이 든다.

문제

LeetCode 225-ImplementStackUsingQueues

Implement a last-in-first-out (LIFO) stack using only two queues. The implemented stack should support all the functions of a normal stack (push, top, pop, and empty).

Implement the MyStack class:

• void push(int x) Pushes element x to the top of the stack.
• int pop() Removes the element on the top of the stack and returns it.
• int top() Returns the element on the top of the stack.
• boolean empty() Returns true if the stack is empty, false otherwise.

Notes:

• You must use only standard operations of a queue, which means that only push to back, peek/pop from front, size and is empty operations are valid.
• Depending on your language, the queue may not be supported natively. You may simulate a queue using a list or deque (double-ended queue) as long as you use only a queue's standard operations.

예시

입력:

["MyStack", "push", "push", "top", "pop", "empty"]
[[], [1], [2], [], [], []]

출력:

[null, null, null, 2, 2, false]

풀이

class MyStack {
    Queue<Integer> q1;
    Queue<Integer> q2;

    public MyStack() {
        q1 = new LinkedList<>();
        q2 = new LinkedList<>();
    }

    public void push(int x) {
        q2.offer(x);

        while(!q1.isEmpty()) {
            q2.offer(q1.poll());
        }

        Queue<Integer> temp = q1;
        q1 = q2;
        q2 = temp;
    }

    public int pop() {
        return q1.poll();
    }

    public int top() {
        return q1.peek();
    }

    public boolean empty() {
        return q1.isEmpty();
    }
}

회고

Queue의 기본 메서드들을 잘 봐야겠다..!

문제

LeetCode 232번-Implement Queue using Stacks

Implement a first in first out (FIFO) queue using only two stacks. The implemented queue should support all the functions of a normal queue (push, peek, pop, and empty).

Implement the MyQueue class:

• void push(int x): Pushes element x to the back of the queue.
• int pop(): Removes the element from the front of the queue and returns it.
• int peek(): Returns the element at the front of the queue.
• boolean empty(): Returns true if the queue is empty, false otherwise.

예시

입력:

["MyQueue", "push", "push", "peek", "pop", "empty"]
[[], [1], [2], [], [], []]

출력:

[null, null, null, 1, 1, false]

설명:

MyQueue myQueue = new MyQueue();
myQueue.push(1); // queue is: [1]
myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
myQueue.peek(); // return 1
myQueue.pop(); // return 1, queue is [2]
myQueue.empty(); // return false

풀이

class MyQueue {

    private Stack<Integer> inStack;
    private Stack<Integer> outStack;

    public MyQueue() {
        inStack = new Stack<>();
        outStack = new Stack<>();
    }

    // 큐에 집어넣는다.
    public void push(int x) {
        inStack.push(x);
    }

    // 첫번째 요소를 제거하고 리턴한다.
    public int pop() {
        shiftStacks();
        return outStack.pop();
    }

    // 첫번째 요소를 리턴한다.
    public int peek() {
        shiftStacks();
        return outStack.peek();
    }

    // 큐가 비어있는지 확인한다.
    public boolean empty() {
        return inStack.isEmpty() && outStack.isEmpty();
    }

    // inStack에 있는 요소들을 outStack에 집어넣는다.
    private void shiftStacks() {
        if (outStack.isEmpty()) {
            while (!inStack.isEmpty()) {
                outStack.push(inStack.pop());
            }
        }
    }
}

Stack은 FIFO 구조이고, Queue는 LIFO이다. 따라서 두 개의 Stack을 갖고 구현해야 하는 문제이다.

1. 2개의 스택 inStack과 outStack을 선언하고, 생성자에서 초기화해주었다.
2. push() 메소드를 통해서 inStack에 값을 추가한다.
3. pop() 메소드와 peek() 메소드 둘 다 inStack에 있는 값을 outStack에 넣는 과정(LIFO -> FIFO)이 필요하다. -> shiftStacks() 3-1. 만약 outStack이 비어있다면 inStack에서 pop한 요소를 outStack에 push한다. outStack이 비어있지 않다면 굳이 추가하지 않고도 outStack에 있는 요소를 반환하면 된다. 3-2. 스택에서의 pop은 맨 위에 있는 요소(가장 마지막에 추가한 요소)를 리턴하고 삭제한다. 3-3. inStack에 가장 마지막에 들어온 요소를 outStack 가장 아래에 추가한다.
4. pop() 메소드는 outStack에 가장 위에 있는 요소를 리턴하고 삭제한다.
5. peek() 메소드는 outStack에 가장 위에 있는 요소를 리턴만 한다.
6. empty() 메소드는 inStack과 outStack 모두 비어있는지의 여부를 리턴한다.

회고

Stack을 갖고 Queue를 구현할 수 있다는 점이 흥미롭다. 이제 자료구조 코테 문제를 좀 푸나보다. 주말동안 자료구조를 다시 한 번 공부해야겠다..

문제

백준 31458번-!!초콜릿 중독 주의!! 이 문제에서 계산할 수식은 정수 하나와 $0$개 이상의 느낌표로 이루어져 있다. 정수는 $0$ 또는 $1$이며, 느낌표는 정수의 앞이나 뒤에 올 수 있다. 이 수식을 계산하는 규칙은 다음과 같다.

  $n!$은 $n$의 팩토리얼이다. $0!=1$, $1!=1$로 정의된다.   $!n$은 $n$의 논리 반전(logical not)이다. $!0=1$, $!1=0$으로 정의된다.

팩토리얼이나 논리 반전이 중첩되어 있으면 중첩된 횟수만큼 계산하며, $!n!$과 같이 둘 다 사용된 경우에는 팩토리얼을 먼저 계산한다. 예를 들어, $!!n!!=!(!((n!) !))$이다.

예시

입력:

6
0!
1!
!0
!1
!!0!!
!!1!!

출력:

1
1
1
0
1
1

풀이

1. 첫번째 풀이

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        StringBuilder sb = new StringBuilder();
        int T = sc.nextInt();
        sc.nextLine();

        while (T-- > 0) {
            String str = sc.nextLine();
            int left = 0;

            while ((left < str.length()) && (str.charAt(left) == '!')) {
                left++;
            }

            int right = str.length() - left - 1;
            int num = str.charAt(left) - '0';

            if (right > 0) {
                num = 1;
            }

            sb.append((num + left) % 2).append("\n");
        }


        System.out.print(sb);
        sc.close();
    }
}

맨 처음에는 if-else문을 통해서 0!이거나 1!이면 둘 다 1로 출력하도록 하고, !1이면 0, !0이면 1을 출력하도록 하려고 했다. 그런데 중첩된 거는 어떻게 해결해야할지 너무 막막했다. 결국 구글링을 통해 C++로 되어있는 코드를 자바에 맞게 작성하였다.

1. 먼저 왼쪽 느낌표의 개수를 구한다. left가 str보다 작으면서 charAt(left) == '!'라면 왼쪽 느낌표가 있는거다. ++를 해준다.
2. 오른쪽 느낌표의 개수는 전체 문자열의 길이(str.length()) - 왼쪽 느낌표의 개수(left) - 정수(1)을 빼준 값이다.
3. 정수는 str.charAt(left) - '0'을 해준 값이다. 3-1. charAt()은 0부터 시작한다. 따라서 만약 left가 1개가 있다면, charAt(1)은 왼쪽 느낌표의 뒤의 정수를 나타낼 것이다. 3-2. - '0'은(는) ASCII 코드 활용으로 문자를 정수로 변환하는 방식이다. 해당 과정을 생략하면 실제 left가 저장된 ASCII 코드값이 반환됨로 '0'을 빼줌으로써 0 또는 1을 반환한다.
4. 패러다임 계산: 오른쪽 느낌표는 정수값이 0이든 1이든 둘 다 1을 반환해주므로 오른쪽 느낌표가 있다면 1을 반환해주도록 한다.
5. 논리부정 계산: (num + left) % 2를 통해 나머지 값을 반환해준다.

2. 두번째 풀이

num ^= (left % 2);

sb.append(num).append("\n");

그리고 나는 문득 비트 연산자를 사용해서 계산할 수도 있지 않을까? 라는 생각을 했다. ^는 XOR 비트 연산자이다. 두 비트가 서로 다르면 1, 같으면 0을 반환한다.

1. 위에서 오른쪽 느낌표가 있다면 1을, 없다면 0을 num에 저장했을 것이다.
2. XOR 계산 2-1. left % 2가 0이라면, 0 ^ 0이므로 같아서 0을 반환한다. 2-2. left % 2가 1이라면, 0 ^ 1이므로 다르기 때문에 1을 반환한다.

💡 left % 2가 짝수라면, 부정->부정 이므로 다시 원래의 숫자를 반환하는 원리이다.

맨 위가 비트 연산자를 사용한 결과로, 나머지 두 개는 첫번째 풀이 방법이다. (백준이 익숙하지 않아서 같은 코드로 두 번 제출되었다.) 비트 연산자를 통해서 확실히 메모리 사용량이 줄어든 것을 볼 수 있다!

회고

int num = str.charAt(left) - '0';에서 '0'을 빼줌으로써 문자를 숫자로 변환할 수 있음을 새로 깨달았다. 즉, '0'을 빼지 않으면 숫자가 아니라 ASCII 코드값이 저장된다.

문제

백준 10280번-문자열 분석 문자열 N개가 주어진다. 이때, 문자열에 포함되어 있는 소문자, 대문자, 숫자, 공백의 개수를 구하는 프로그램을 작성하시오.

각 문자열은 알파벳 소문자, 대문자, 숫자, 공백으로만 이루어져 있다.

예시

입력:

This is String
SPACE    1    SPACE
 S a M p L e I n P u T     
0L1A2S3T4L5I6N7E8

출력:

10 2 0 2
0 10 1 8
5 6 0 16
0 8 9 0

풀이

1. 첫번째 풀이

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    String str = "";

    while (sc.hasNextLine()) {
        str = sc.nextLine();
        int lowerCase = 0;
        int upperCase = 0;
        int num = 0;
        int space = 0;
        char[] charArr = str.toCharArray();
        for (int i=0; i<charArr.length; i++) {
            if (charArr[i] == 32) { //공백
                space++;
            } else if ((48 <= charArr[i]) && (charArr[i] <= 57)) { //숫자
                num++;
            } else if ((65 <= charArr[i]) && (charArr[i] <= 90)) { //대문자
                upperCase++;
            } else { //소문자
                lowerCase++;
            }
        }
        System.out.println(lowerCase + " " + upperCase + " " + num + " " + space);
    }

    sc.close();
}

처음에 생각했던 방법은 char 배열로 바뀌어서 해당 영소문자, 대문자, 숫자, 공백에 맞는 ASCII 코드와 동일하면 거기에 해당되는 정수형 변수의 값을 늘리는 것으로 생각을 했다. 자주 사용되는 ASCII 코드는 쓸모가 있어서 영문자는 알겠지만 숫자와 공백은 몇 번째인지 몰라서 구글링해서 풀었다.

2. 두번째 풀이

while (sc.hasNextLine()) {
    str = sc.nextLine();
    int lowerCase = 0;
    int upperCase = 0;
    int num = 0;
    int space = 0;

    for (char c : str.toCharArray()) {
        if (Character.isDigit(c)) {
            num++;
        } else if (Character.isUpperCase(c)) {
            upperCase++;
        } else if (Character.isLowerCase(c)) {
            lowerCase++;
        } else {
            space++;
        }
}
    System.out.println(lowerCase + " " + upperCase + " " + num + " " + space);

두번째 방법은 다른 사람들은 어떻게 풀었는지 구경하다보니 알게된 방법이다. Character 클래스에 있는 isDigit(), isUpperCase(), isLowerCase()를 통해서 첫번째 방법을 대체할 수 있다. 이는 ASCII 코드를 몰라도 손쉽게 풀 수 있는 방법이다. 래퍼 클래스의 메소드들을 다시 한 번 훑어봐야겠다!

3. 세번째 풀이

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    String str = "";
    StringBuilder sb = new StringBuilder();

    while (sc.hasNextLine()) {
        str = sc.nextLine();
        int lowerCase = 0;
        int upperCase = 0;
        int num = 0;
        int space = 0;

        for (char c : str.toCharArray()) {
            if (Character.isDigit(c)) {
                num++;
            } else if (Character.isUpperCase(c)) {
                upperCase++;
            } else if (Character.isLowerCase(c)) {
                lowerCase++;
            } else {
                space++;
            }
        }

        sb.append(lowerCase).append(" ")
          .append(upperCase).append(" ")
          .append(num).append(" ")
          .append(space).append("\n");
    }
       System.out.print(sb);
    sc.close();
}

마지막은 String 대신 StringBuilder를 사용해서 append()를 통해서 문자열을 붙여나가는 방법이다. 다 담았다가 while문을 빠져나가면 그 때 System.out.print()를 통해 Builder에 담아둔 문자열들을 출력해준다.

위부터 세번째->두번째->첫번째 방법으로 푼 메모리와 시간이다. StringBuilder를 통해 메모리와 시간을 유의미하게 줄일 수 있었다.

회고

래퍼 클래스의 메소드들을 다시 한 번 훑어보자. 그리고 StringBuilder를 사용하자!

문제

백준 1032번:명령 프롬프트 이 문제는 검색 결과가 먼저 주어졌을 때, 패턴으로 뭘 쳐야 그 결과가 나오는지를 출력하는 문제이다. 패턴에는 알파벳과 "." 그리고 "?"만 넣을 수 있다. 가능하면 ?을 적게 써야 한다. 그 디렉토리에는 검색 결과에 나온 파일만 있다고 가정하고, 파일 이름의 길이는 모두 같다.

예시

입력:

3
config.sys
config.inf
configures

출력:

config????

풀이

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int cnt = sc.nextInt();
        sc.nextLine(); //개행 처리

        String[] files = new String[cnt];
        for(int i=0; i<cnt; i++) {
            files[i] = sc.nextLine();
        }

        String firstFile = files[0];
        StringBuilder pattern = new StringBuilder();

        for (int i=0; i<firstFile.length(); i++) {
            boolean isSame = true;
            char currentChar = firstFile.charAt(i);

            for (int j=1; j<cnt; j++) {
                if (currentChar != files[j].charAt(i)) {
                    isSame = false;
                    break;
                }
            }

            if (isSame) {
                pattern.append(currentChar);
            } else {
                pattern.append("?");
            }
        }

        System.out.println(pattern);
        sc.close();
    }
}

1. 첫번째 줄에 입력받은 파일의 개수만큼 String 배열 생성
2. sc.nextLine();을 통해 for문을 돌면서 파일 배열 목록에 값 입력
3. 첫번째 파일 이름의 개수만큼 for문을 돌면서 다음 파일 배열 목록들의 이름과 비교
4. 만약 첫번째 파일 이름의 char i번째와 다음 파일 이름의 char i번째가 같지 않다면, isSame 변수를 false로 설정하고 break;를 통해 해당 for문을 빠져나감
5. isSame이 true이면 현재 char를 StringBuilder에 추가하고, 그렇지 않다면 '?' 문자열을 추가
6. for문을 다 돌고 나면 해당 패턴을 출력하고 스캐너 close

회고

오랜만에 코딩테스트를 준비하려고 하니까 처음에는 막막했다. 45분이 권장사항 이었지만, 훨씬 오래 걸렸다. 처음에는 백준에 주어진 조건(파일이름 알파벳 소문자와 '.'로 이루어져있는지, N이 50보다 작거나 같은 자연수인지)을 모두 구현해야하는 줄 알고 복잡하게 생각해 더 어렵게 느껴졌다. 하지만 그게 아니었다.. 그 외에도 오늘 정기모임 스터디에서 추가 문제로 백준 10988번:팰린드롬인지 확인하기도 풀었다. 처음에는 이중for문으로 풀었는데, 챗gpt에서는 그냥 for문을 돌면서 if (str.charAt(i) != str.charAt(str.length()-1-i)) 조건문을 추가하는 방식도 있었다. 그런데, 정기모임 팀장(?)님의 풀이 방법 중 하나인 바로 StringBuilder sb = new StringBuilder().append(str).reverse();를 해서 바로 입력받은 문자열과 비교를 하는 방식도 있었는데 저런 방법도 있구나 생각이 많이 들었다. 오늘이 1일차인데, 내일 이사를 해서 당분간 정신 없을 것 같지만 끝까지 매일 미션을 완수해보자!

자바에서 Thread-Unsafe한 케이스를 알아봅시다.

1. static 변수를 사용할 경우

static 변수는 해당 클래스의 모든 인스턴스들 간에 공유되는 변수입니다. 즉, 클래스의 모든 객체들이 이 변수를 같은 메모리 위치에 공유하여 사용하게 됩니다.

2. singleton일 경우

Singleton이란 메모리 상에 오직 하나의 인스턴스만 있는 경우인 디자인 패턴 중 하나입니다. 인스턴스 생성을 외부에서 할 수 없고, 접근 제어자를 이용해서 클래스 내부에서만 생성되도록 제한합니다. 싱글톤에서 사용되는 getInstance() 메소드는 쓰레드에 안전하지 않기 때문에 synchronized 키워드를 붙이거나 다른 방법을 사용해야 합니다.

3. Collection

3-1. ArrayList

Note that this implementation is not synchronized. ...(중략)... If no such object exists, the list should be "wrapped" using the Collections.synchronizedList method. This is best done at creation time, to prevent accidental unsynchronized access to the list: List list = Collections.synchronizedList(new ArrayList(...));

자바 API를 보면 ArrayList는 thread unsafe하다고 나와있고, 만약 thread safe하게 사용하려면 Collections.synchronizedList() 메소드를 사용하라고 나와있습니다.

3-2. HashSet, HashMap

HashSet과 HashMap 또한 thread-unsafe 하기 때문에 아래와 같은 Collections의 메소드를 통하며 생성할 수 있습니다.

Set s = Collections.synchronizedSet(new HashSet(...));
Map m = Collections.synchronizedMap(new HashMap(...));

4. StingBuilder

멤버 변수로 사용하느냐 아니면 로컬 변수로 사용하냐에 의해서 결정하면 됩니다. 멤버 변수로 사용할 경우에는 StringBuffer를 사용해야 하고, 로컬 변수로 사용하는 경우에는 StringBuilder를 사용해도 됩니다.

참고 HashMap vs HashTable vs ConcurrentHashMap

도서 자바의신을 참고하였습니다.

1. Nested Class

nested : n. 집합 또는 구간의 순서를 지닌 계열(系列)에서, 각기 그 앞의 것에 포함되고, 또한 집합의 직경이나 구간의 길이가 0으로 수속(收束)하는 것.

Nested Class는 클래스 안의 클래스를 뜻합니다. 자바 기반의 UI를 처리할 때 사용자의 입력이나, 외부의 이벤트에 대한 처리를 하는 곳에서 주로 사용됩니다. 파일 이름은 반드시 public 클래스의 이름이어야 합니다. 그렇지 않으면 컴파일 에러가 발생합니다. Nested Class를 사용하는 이유는 다음과 같습니다.

• 한 곳에서만 사용되는 클래스를 논리적으로 묶어서 처리할 필요가 있을 때 -> static nested class
• 캡슐화가 필요할 때. 즉, 내부 구현을 감추고 싶을 때 -> inner class
• 소스의 가독성과 유지보수성을 높이고 싶을 때

2. Static Nested Class

Nested class는 감싸고 있는 외부 클래스의 어떤 변수든 접근 가능합니다. 단, static nested class는 불가능합니다. static nested class는 클래스를 묶기 위해 *사용되며, 겉으로 보기에는 유사하지만 *내부적으로 구현이 달라야할 때 사용됩니다.

public class University {
    static class Student {
    }
}

public class School {
    static class Student {
    }
}

위와 같이 University클래스의 Student 클래스와 School의 Student 클래스가 보기에는 유사하지만 내부적으로 구현이 달라야할 때 사용됩니다.

public class OutClass {
    static class StaticNested {
    }
}

이런식으로 되어 있다면 컴파일은 OutClass.class와 OutClass$StaticNested.class으로 나누어집니다. 접근을 할 때는 OutClass.StaticNested staticNested = new OutClass.StaticNested();로 접근하면 됩니다.

3. Inner Class

Inner Class는 캡슐화를 목적으로 하는 클래스입니다. 하나의 클래스에서 어떤 공통적인 작업을 수행하는 클래스가 필요한데 다른 클래스에서는 그 클래스가 전혀 필요없을 때 Inner class를 만들어 사용합니다. Inner 클래스의 객체를 생성하기 위해서는 먼저 Outer 클래스 객체를 생성해야 하고, 이 객체를 통해서 Inner 객체 생성이 가능합니다. 주로 GUI 프로그램을 만들 때 사용됩니다.

4. Anonymous Class

Anonymous Class는 이름이 없는 일회용 클래스로, 정의와 생성을 동시에 수행합니다.

class MyClass extends ParentClass {
    //...
}
MyClass mc = new MyClass();

보통 객체를 생성할 때 위와 같이 생성하지만 익명 클래스는 다음과 같이 생성합니다.

new ParentClass {
    //...
}

//또는

new 구현인터페이스이름 {
    //...
}

컴파일하고 난 후에는 클래스명이 없기 때문에 클래스명$1.class처럼 숫자로 붙습니다. 클래스를 만들고 클래스를 호출하면 그 정보는 메모리에 올라가게 되고, 클래스를 많이 만들수록 메모리는 많이 필요해지고 애플리케이션을 시작할 때 더 많은 시간이 소요됩니다. 따라서 이런 익명 클래스를 통해서 간단한 방법으로 객체를 생성할 수 있습니다.

지속적으로 수정해나갈 예정입니다. 2023-07-23 V1.0

도서 자바의신을 참고하였습니다.

1. String 클래스

public final class String
extends Object
implements Serializable, Comparable<String>, CharSequence

String 클래스는 위와 같이 Serializable, Comparable<String>, CharSequence를 구현하고 있습니다.

• Serializable : 구현해야하는 메소드가 없습니다. 그냥 선언하면 해당 객체를 파일로 저장하거나 다른 서버에 전송 가능한 상태가 됩니다.
• Comparable<String> : compareTo()라는 메소드 하나만 있는데, 객체 비교에 쓰이고 int값을 리턴합니다.
• CharSequence: 해당 클래스가 문자열을 다루기 위한 클래스라는 것을 명시적으로 나타냅니다.

String 클래스는 생성자가 굉장히 많은데, 그 중 가장 잘 쓰이는 것은 아래 2가지가 있습니다.

• String(byte[] bytes) : 현재 사용중인 플랫폼의 캐릭터 셋을 사용하여 제공된 byte배열을 디코딩한 String 객체를 생성합니다.
• String(byte[] bytes, String charsetName) : 지정한 이름을 갖는 캐릭터 셋을 사용하여 지정한 byte배열을 디코딩한 String 객체를 생성합니다.

2. String -> byte

String에서 byte로 변환하는 방법은 getBytes() 메소드를 사용하는 것입니다.

• byte[] getBytes() : 기본 캐릭터 셋의 바이트 배열을 생성합니다.
• byte[] getBytes(Charset charset) : 지정한 캐릭터 셋 객체 타입으로 바이트 배열을 생성합니다.
• byte[] getBytes(String charsetName) : 지정한 이름의 캐릭터 셋으로 바이트 배열을 생성합니다.

여기서 매개변수가 있는 getBytes() 메소드는 다른 시스템에서 전달받은 문자열을 byte 배열로 변환할 때 사용합니다. 이때, UnsupportedEncodingException 발생할 가능성이 있으므로 예외를 잡거나 던져주어야 합니다.

3. Charset

java.nio.charset.Charset 클래스 API에 정해진 표준 Charset은 다음과 같습니다.

• US-ASCII : 7bit ASCII
• ISO-8859-1 : ISO 라틴 알파벳
• UTF-8 : 8bit UCS(Unicode Character Set) 변환 포맷
• UTF-16BE : 16bit UCS 변환 포맷. big-endian byte 순서
• UTF-16LE : 16bit UCS 변환 포맷. little-endian byte 순서
• UTF-16 : 16bit UCS 변환 포맷. byte-order mark byte 순서

추가적으로 EUC-KR과 MS949라는 캐릭터 셋이 있는데, EUC-KR은 8bit 문자 인코딩으로, EUC의 일종이며 대표적인 한글 완성형 인코딩입니다. MS949는 Microsoft에서 만든 한글 확장 완성형 인코딩입니다.

byte배열로 생성할 때 사용한 캐릭터 셋을 문자열로 다시 전환할 때도 동일하게 사용해야 합니다.

byte[] arr = str.getBytes("UTF-16");
String str2 = new String(arr, "UTF-16");

4. String Methods

1) length()

public int length()는 문자열의 길이를 리턴합니다. 이 때, 공백도 길이에 포함됩니다.

String strEn = "hello";
String strKr = "안녕하세요";
String blank = " ";

System.out.println("strEn.length() = " + strEn.length()); //5
System.out.println("strKr.length() = " + strKr.length()); //5
System.out.println("blank.length() = " + blank.length()); //1

2) isEmpty()

public boolean isEmpty()는 문자열이 비어있는지 확인하는 메소드입니다. 만약 문자열이 비어있을 경우 true를 리턴합니다. 공백도 문자열에 포함되므로 false를 리턴합니다.

String strEn = "hello";
String blank = " ";
String empty = "";

System.out.println("strEn.isEmpty() = " + strEn.isEmpty()); //false
System.out.println("blank.isEmpty() = " + blank.isEmpty()); //false
System.out.println("empty.isEmpty() = " + empty.isEmpty()); //true

만약 공백도 true로 리턴하게끔 하려면 Java11부터 추가된 isBlank()을 사용하면 됩니다.

String blank = " ";

System.out.println("blank.isBlank() = " + blank.isBlank()); //true

3) equals()

• boolean equals(Object anObject)
• boolean equalsIgnoreCase(String anotherStr)

• 위 두 메소드는 동일한 값인지 비교할 때 사용됩니다. 여기서 IgnoreCase가 붙은 메소드들은 대소문자 구분을 하지 않습니다.

String str1 = "Hi";
String str2 = "Hi";
String str3 = new String("Hi");
String str4 = new String("hi");

System.out.println(str1 == str2); //true
System.out.println("str1.equals(str2) = " + str1.equals(str2)); //true
System.out.println(str1 == str3); //false
System.out.println("str1.equals(str3) = " + str1.equals(str3)); //true
System.out.println("str1.equalsIgnoreCase(str4) = " + str1.equalsIgnoreCase(str4)); //true

자바에서는 객체들을 재사용하기 위해 Constant Pool(상수 풀)이 있고, String의 경우 동일한 값을 갖는 객체가 있으면 이미 만든 객체를 재사용합니다. 따라서 str1==str2가 true로 나올 수 있었으나, 이는 지양하는 것이 좋습니다. 재사용하지 않으려면 str3과 같이 new 연산자를 사용해 String 객체를 새로 생성을 해주어야 합니다. str1==str3이 false가 나올 수 있던 이유입니다.

• int compareTo(String anotherStr)
• int compareToIgnoreCase(String str)

• compareTo() 메소드는 보통 정렬할 때 많이 사용됩니다. 매개변수가 알파벳순으로 앞에 있으면 양수, 뒤에 있으면 음수를 리턴합니다.

  String textA = "a";
  String textB = "b";
  String textC = "c";
  

System.out.println("textB.compareTo(textA) = " + textB.compareTo(textA)); //1 System.out.println("textB.compareTo(textC) = " + textB.compareTo(textC)); //-1 System.out.println("textA.compareTo(textC) = " + textA.compareTo(textC)); //-2

- boolean contentEquals(CharSequence cs)
- boolean contentEquals(StringBuffer sb)
-> 매개변수로 넘어오는 CharSequence를 구현한 클래스의 객체가 String 객체와 동일한지 비교합니다.
```java
String str = "hi";
StringBuffer sb = new StringBuffer("hi");
StringBuilder builder = new StringBuilder("hi");

System.out.println("str.equals(sb) = " + str.equals(sb)); //false
System.out.println("str.contentEquals(sb) = " + str.contentEquals(sb)); //true
System.out.println("str.contentEquals(builder) = " + str.contentEquals(builder)); //true

4) 특정 조건에 문자열이 있는지 확인하는 메소드

• boolean startsWith(String prefix) : 가장 많이 사용하는 메소드로 prefix로 시작하는지 확인.
• boolean startsWith(String prefix, int toffset) : 위 메소드와 동일하나 어디서부터 찾을지 지정 가능.
• boolean endsWith(String suffix) : suffix로 끝나는지 확인.
• boolean contains(CharSequence s) : 매개변수로 들어온 s값이 문자열에 존재하는지 확인. 중간에 있는 값 확인할 때 사용.
• boolean matches(String regex) : 정규표현식에 맞는 문자열인지 확인.

• boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len)
• boolean regionMatches(int toffset, String other, int ooffset, int len)

• 문자열 중에서 특정 영역이 매개변수로 넘어온 문자열과 동일한지 확인.

  • ignoreCase : true일 경우 대소문자 구분 없이 값 비교
  • toffset : 비교 대상 문자열의 확인 시작 위치 지정
  • other : 존재하는지를 확인할 문자열
  • ooffset : other 객체의 확인 시작 위치 지정
  • len : 비교할 char의 개수 지정

5) indexOf()

• int indexOf(int ch) : char는 정수형으로 자동으로 형변환해줍니다.
• int indexOf(int ch, int fromIndex)
• int indexOf(String str)
• int indexOf(String str, int fromIndex)

• 앞에서부터 문자열이나 char를 찾는 메소드입니다. 0부터 시작하며, 찾고자 하는 값이 없으면 -1을 리턴합니다.

• int lastIndexOf(int ch)
• int lastIndexOf(int ch, int fromIndex)
• int lastIndexOf(String str)
• int lastIndexOf(String str, int fromIndex)

• 뒤에서부터 찾는 메소드입니다.

6) char단위 값 추출하는 메소드

• char charAt(int index) : 특정 위치의 char값을 리턴함.
• void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) : dst라는 char배열 내에 srcBegin에서 srcEnd 사이에 있는 char를 저장하는데 이때, dst배열의 시작 위치는 dstBegin입니다.
• int codePointAt(int index) : 특정 위치의 유니코드 값 리턴. 리턴 타입은 int지만 char로 형 변환도 가능.
• int codePointBefore(int index) : 특정 위치 앞에 있는 char의 유니코드 값 리턴. 리턴 타입은 int지만 char로 형변환도 가능.
• int codePointCount(int beginIndex, int endIndex) : 지정한 범위에 있는 유니코드 개수 리턴.
• int offsetByCodePoints(int index, int codePointOffset) : 지정된 index부터 offset이 설정된 인덱스를 리턴. 문자열 인코딩과 관련된 문제를 해결하기 위해서 사용됨.

7) Char -> String, String -> Char

(1) Char -> String

• static String copyValueOf(char[] data) : char배열에 있는 값을 문자열로 변환함.
• static String copyValueOf(char[] data, int offset, int count) : char배열에 있는 값을 문자열로 변환함. 단, offset 위치부터 count까지의 개수만큼만 문자열로 변환함.

  char[] values = new char[]{'H', 'e', 'l', 'l', 'o'};
  String str = String.copyValueOf(values);
  System.out.println("str = " + str); //Hello
  

str = String.copyValueOf(values, 1, 2); System.out.println("str = " + str); //el

#### (2) String -> Char
- `char[] toCharArray()` : 문자열을 char 배열로 변환함.

![Choonsik을 디버깅했을 때](https://velog.velcdn.com/images/choonsik_dev/post/118d584a-8154-43b4-9c62-77251f560533/image.png)

어떤 String 객체를 만들더라도, 그 객체 내부에는 char 배열을 포함합니다.


### 8) substring()
- `String substring(int beginIndex)` : beginIndex부터 끝까지 대상 문자열을 잘라 String으로 리턴함.
- `String substring(int beginIndex, int endIndex)` : beginIndex부터 endIndex까지 대상 문자열을 잘라 String으로 리턴함.
- `CharSequence subSequence(int beginIndex, int endIndex)` : beginIndex부터 endIndex까지 대상 문자열을 잘라 CharSequence로 리턴함.

### 9) split()
- `String[] split(String regex)` : regex(정규표현식)에 맞추어 문자열을 잘라 String 배열로 리턴함.
- `String[] split(String regex, int limit)` : 위 메소드와 동일하나 limit보다 커서는 안됨.

자바에서 문자열을 나누는 방법에는 split()메소드와 StringTokenizer를 활용한 방법 2가지가 있습니다.
<table border="1">
  <th></th>
  <th>split()</th>
  <th>StringTokenizer</th>
  <tr>
    <td>정규 표현식</td>
    <td>⭕️</td>
    <td>❌</td>
  </tr>
    <tr>
    <td>특정 String</td>
    <td>❌</td>
    <td>⭕️</td>
  </tr>
    <tr>
    <td>특정 알파벳이나 기호 하나</td>
    <td>⭕️</td>
    <td>⭕️</td>
  </tr>
</table>
정규표현식을 사용하여 문자열을 나눌 때는 split() 메소드를 사용하고, 특정 String을 사용하여 문자열을 나눌 경우 StringTokenizer를 사용하면 됩니다. 특정 알파벳이나 기호 하나로 나눌 때는 둘 다 사용해도 됩니다.

### 10) replace()
- `String replace(char oldChar, char newChar)` : 해당 문자열에 있는 oldChar의 값을 newChar로 대치함.
- `String replace(CharSequence target, CharSequence replacement)` : 해당 문자열에 있는 target과 같은 값을 replacement로 대치함.
- `String replaceAll(String regex, String replacement)` : regex(정규표현식)에 포함되는 모든 내용을 replacement로 대치함.
- `String replaceFirst(String regex, String replacement)` : regex(정규표현식)에 포함되는 첫번째 내용을 replacement로 대치함.

하지만 위 메소드를 사용한다고 해서 <span style="color:red">기존 문자열의 값은 바뀌지 않습니다</span>. 또한 <span style="color:red">대소문자를 구분</span>합니다.

```java
String str = "Choonsik";
System.out.println("str.replace('o', 'z') = " + str.replace('o', 'z')); //Chzznsik
System.out.println("str.replace('c', 'a') = " + str.replace('c', 'a')); //Choonsik
System.out.println("str = " + str); //Choonsik

11) format()

• static String format(String format, Object...args) : format에 있는 문자열의 내용 중 변환해야 하는 부분을 args의 내용으로 변경함.
• static String format(Locale l, String format, Object...args) : 위 메소드와 동일하며, Locale 타입 l에 선언된 지역에 맞추어 출력함. 만약 Locale을 지정하지 않으면 자바 프로그램이 수행되는 OS의 지역 정보 제공함.

String str = "제 이름은 %s 입니다. 나이는 %d살 입니다.";
String realStr = String.format(str, "춘식이", 3);
System.out.println("realStr = " + realStr); //제 이름은 춘식이 입니다. 나이는 3살 입니다.

대치해야할 문자열이 n개일 때, format뒤에 n+m개가 오는 것은 상관없지만 n개보다 적은 변수를 명시하면 MissingFormatArgumentException이 발생합니다.

String realStr = String.format(str, "춘식이");

Exception in thread "main" java.util.MissingFormatArgumentException: Format specifier '%d'

12) 대소문자 바꾸는 메소드

• String toLowerCase()
• String toLowerCase(Locale locale)

• 모든 문자열을 소문자로 변경하는데, 지정한 지역 정보에 맞추어 변경할 수도 있습니다.

• String toUpperCase()
• String toUpperCase(Locale locale)

• 모든 문자열을 대문자로 변경하는데, 지정한 지역 정보에 맞추어 변경할 수도 있습니다.

13) 기본자료형 -> 문자열

• static String valueOf(boolean b)
• static String valueOf(char c)
• static String valueOf(char[] data)
• static String valueOf(char[] data, int offset, int count)
• static String valueOf(double d)
• static String valueOf(float f)
• static String valueOf(int i)
• static String valueOf(long l)
• static String valueOf(Object obj) : toString()을 구현한 객체나 정상적인 객체를 매개변수로 넘기면 toString()의 결과를 리턴합니다. 만약 null이 넘어오면 "null"이라는 문자열을 리턴해줍니다.

String str = null;
System.out.println(str); //null

14) intern()

intern() 메소드는 절대로 사용해서는 안되는 메소드입니다. 자바로 구현되지 않고 C로 구현되어 있는 native 메소드 중 하나입니다.

5. StringBuffer, StringBuilder

String은 immutable 객체입니다. String 문자열을 더하면 새로운 String 객체가 생서되고, 기존 객체는 GC의 대상이 됩니다. 따라서 이 점을 보완하기 위해 StringBuffer와 StringBuilder가 탄생하게 됩니다. 둘 다 모두 CharSequence 인터페이스의 구현 클래스입니다.매개변수로 받는 작업할 때 String이나 StringBuilder보다는 CharSequence 타입으로 받는 것이 좋습니다.

• StringBuffer : Thread Safe. 인스턴스 변수가 선언되고 여러 thread에서 이 변수를 동시에 접근할 때 사용
• StringBuilder : 빠름. JDK5부터 String에서 더하기 연산을 사용할 경우 컴파일할 때 자동으로 해당 연산은 StringBuilder로 변환함. 하나의 메소드 내에서 문자열을 생성하여 더할 떄 사용.

StringBuffer와 StringBuilder는 문자열을 더하더라도 새로운 객체를 새로 생성하지 않습니다. 또한 더할 때는 append()라는 메소드를 사용하는데, 매개변수로 모든 기본 자료형과 참조 자료형이 포함됩니다.

지속적으로 수정해나갈 예정입니다. 2023-07-23 v1.0

도서 자바의신을 참고하였습니다.

1. 예외 종류

java.lang.Throwable은 Error와 Exception을 포함한 최상위 클래스입니다. Error는 자바 프로그램 밖에서 발생한 예외로, 프로세스에 영향을 미치지만 Exception은 해당 쓰레드에만 영향을 줍니다. Exception은 다시 RuntimeException(=UncheckedException)과 CheckedException으로 나뉩니다. RuntimeException은 컴파일 시 체크되지 않으므로 예외가 발생한 것을 미리 감지하지 못할 때 발생합니다. 이와 반대로 CheckedException은 java.lang.Exception을 확장한 클래스들로 컴파일 시 체크 가능합니다.

2. Throwable 클래스

Exception과 Error의 공통 부모 클래스는 java.lang.Throwable클래스입니다. Exception와 Error의 성격은 다르지만, 모두 동일한 이름의 메소드를 사용하여 처리하기 위해 동일한 부모 클래스를 상속받으며, Exception과 Error를 처리할 때 Throwable로 처리해도 됩니다.

1) Throwable 생성자

• Throwable()
• Throwable(String message)
• Throwable(String message, Throwable cause)
• Throwable(Throwable cause)

Throwable 생성자에는 위 4가지 생성자가 있으며, 매개변수인 Throwable cause를 통해 별도의 예외 원인을 객체로 넘겨줄 수 있습니다.

2) Thowable 메소드

• public String getMessage() : 예외 메시지를 String 형태로 제공받음. 어떤 예외가 발생했는지 확인할 때 유용함.
• public String getLocalizedMessage() : 로컬 예외 메시지를 받지만, 특정 클래스에서 이 메소드가 재정의되어 있지 않은 경우 getMessage()와 동일한 결과값을 리턴함.
• public String toString() : getMessage()보다 더 자세하게 예외 클래스명도 제공함.
• public void printStackTrace() : 매우 자세하게 어디서 무슨 예외가 발생했는지 알려주기 때문에 운영에 배포될 소스에는 사용하면 안됨.

public class ExceptionMain {
    public static void main(String[] args) {
        try {
            crunch(null);
        } catch (NullPointerException e) {
            //System.out.println(e.getMessage()); //null
            //System.out.println(e.getLocalizedMessage()); //null
            //System.out.println(e.toString());   //java.lang.NullPointerException
            e.printStackTrace();
            //java.lang.NullPointerException
            //    at com.test.exception.ExceptionMain.mash(ExceptionMain.java:19)
            //    at com.test.exception.ExceptionMain.crunch(ExceptionMain.java:16)
            //    at com.test.exception.ExceptionMain.main(ExceptionMain.java:6)
        }
    }

    static void crunch(int[] a) {
        mash(a);
    }
    static void mash(int[] b) {
        System.out.println(b[0]);
    }
}

3. throws

throws 키워드는 예외가 발생된 메소드를 다시 호출한 메소드로 던지는 것을 말합니다. 이미 throws한 것을 다시 throws 하는 것은 별로 좋지 않습니다. 가장 좋은 방법은 throws하는 메소드를 호출하는 메소드에서 try~catch로 처리하는 방법입니다. 메소드를 throws할 때는 2가지 이상의 예외를 던질 수도 있습니다.

try 블록 내에서 예외를 발생시킬 경우에는 다음과 같이 throw예약어를 적어둔 뒤 예외를 객체를 생성하거나 예외 클래스명을 명시해야 합니다.

public static void main(String[] args) {
    try {
        throw new MyException("m");
    } catch (MyException e) {
        e.printStackTrace();
    }
 }

만약 throw한 예외 클래스가 catch 블록에 선언되어 있지 않거나, throws에 선언되어 있지 않다면 컴파일 에러가 발생합니다. catch 블록에서 예외를 throw할 경우에도 메소드 선언의 throws 구문에 해당 예외가 정의되어 있어야 합니다.

4. 커스텀 예외

Throwable이나 Exception 클래스를 상속 받으면 커스텀 예외 클래스를 생성할 수 있습니다. 하지만, Throwable은 Exception말고도 Error를 자식클래스로 포함하기 때문에, Exception 클래스 상속받는 것을 더 추천합니다.

5. 예외 처리 전략

만약 커스텀 예외 클래스에서 extends Exception을 통해서 만들었지만, 런타임 시에 예외가 발생할 확률이 더 높다면 extends RuntimeException으로 선언하는 것이 좋습니다. 이렇게 변경하면 해당 예외를 throw하는 메소드를 사용하더라도 trycatch문으로 묶지 않아도 컴파일 에러가 발생하지 않습니다. 하지만, 이 경우에는 예외 발생 시 해당 클래스를 호출하는 다른 클래스에서 예외를 처리하도록 구조적인 안전 장치(호출하는 메소드에서 trycatch문이 있어야 함)가 되어 있어야 합니다.

public void methodCaller() {
    try {
        methodCallee();
    } catch(Exception e) {
        //예외 처리
    }
}

public void methodCallee() {
    //RuntimeException 발생 가능성 있는 부분
    //여기서 try~catch문이 없다면 methodCaller에 있어야 함.
}

지속적으로 수정해나갈 예정입니다. 2023-07-22 v1.0

도서 자바의신, 이것이 자바다를 참고하였습니다.

1. Object

모든 자바 클래스의 부모는 java.lang.Object 클래스입니다. 아무런 상속을 받지 않으면, Object 클래스를 확장합니다. Object 클래스에 선언되어 있는 메소드는 두 가지로 분류될 수 있습니다.

• 객체를 처리하기 위한 메소드
• 쓰레드를 위한 메소드

1) 객체를 처리하기 위한 메소드

• public boolean equals(Object obj) : 현재 객체와 파라미터로 넘어온 obj 객체가 같은지 확인함.
• public int hashCode() : 객체에 대한 해시코드값(16진수로 제공되는 객체의 메모리 주소)을 리턴함.
• public String toString() : 객체를 문자열로 표현한 값 리턴함.
• public Class<?> getClass() : 현재 객체의 Class 클래스 객체를 리턴함.
• protected void finalize() : 현재 객체가 더 이상 쓸모없을 때 GC에 의해 호출됨.
• protected Object clone() : 객체의 복사본을 만들어 리턴함.

2) 쓰레드 처리를 위한 메소드

• public void notify(): 이 객체의 모니터에 대기하고 있는 단일 쓰레드를 깨움.
• public void notifyAll(): 이 객체의 모니터에 대기하고 있는 모든 쓰레드를 깨움.
• public void wait() : 다른 쓰레드가 현재 객체에 대한 notify()나 notifyAll()을 호출할 때 까지 현재 쓰레드가 대기하고 있도록 함.
• public void wait(long timeout) : wait()와 동일한 기능을 제공하며, timeout만큼 대기함. 즉, timeout을 넘을 경우 현재 쓰레드는 다시 깨어나고, 시간은 밀리세컨드(1/1,000)초 단위임.
• public void wait(long timeout, int nanos) : 위 메소드보다 더 자세한 밀리초+나노초(1/10억초) 만큼 대기함. nanos값은 0~999,999 사이의 값만 지정 가능함.

2. toString()

toString() 메소드는 System.out.println()과 같은 출력 메소드에 매개 변수로 들어가는 경우 혹은 객체에 더하기 연산을 하는 경우 자동 호출됩니다. 재정의를 해주지 않았을 경우 다음과 같은 결과값을 리턴합니다. getClass().getName() + '@' + Integer.toHexString(hashCode())

• getClass().getName() : 현재 클래스의 패키지명과 클래스명을 리턴함.
• hashCode() : int 타입으로 반환되는 객체 해시코드 값
• Integer.toHexString() : int값을 16진수로 변환함.

3. equals()

객체의 값을 비교할 때는 == 또는 !=를 사용하는 것은 지양하고, equals() 메소드를 사용하는 것이 좋습니다. ==는 주소값을 비교하기 때문에 기본자료형만 사용 가능합니다. equals() 메소드를 오버라이딩하지 않으면 hashCode() 값을 비교하기 때문에, equals() 메소드를 오버라이딩할 때 hashCode()도 같이 오버라이딩해 주어야 합니다. 만약 둘 다 함께 재정의하지 않으면 Collection(HashSet, HashMap, HashTable)을 사용할 때 문제가 발생합니다. equals() 메소드를 오버라이딩할 때 지켜야 할 5가지는 다음과 같습니다. (모두 null이 아니라는 전제 하)

• 재귀(reflexive) : X 객체의 X.equals(X)는 항상 같아야 함.
• 대칭(symmetric) : X, Y 객체에서 Y.equals(X)가 true를 리턴하면 X.equals(Y)도 true를 리턴해야 함.
• 타동적(transitive) : X, Y, Z 객체에서 X.equals(Y)가 true이고, Y.equals(Z)가 true면 X.equals(Z)도 true를 리턴해야 함.
• 일관(consistent) : X, Y 객체에서 객체가 변경되지 않은 상황에서는 몇 번을 호출하더라도 X.equals(Y)는 항상 true이거나 false여야 함.
• null과의 비교 : X 객체의 X.equals(null)은 항상 false여야 함.

4. hashCode()

hashCode() 메소드는 기본적으로 객체의 메모리 주소를 16진수로 리턴합니다. 만약, 어떤 2개의 객체가 서로 동일하다면, hashCode()는 무조건 동일해야 합니다. hashCode()를 오버라이딩시 지켜야 할 조건은 다음과 같습니다.

• 자바 애플리케이션이 수행되는 동안, 어떤 객체에 대해서 이 메소드가 호출될 때에는 항상 동일한 int값을 리턴해야 합니다. 단, 자바를 실행할 때마다 같은 값일 필요는 없습니다.
• 어떤 두 객체에 대하여 equals()가 true일 경우, 두 객체의 hashCode()는 동일한 int값을 리턴해야 합니다.
• 두 객체의 equals()가 false를 리턴했다고 해서, hashCode()값이 무조건 달라야 할 필요는 없지만, 서로 다른 int값을 제공하면 hashtable의 성능 향상에 도움이 됩니다.

지속적으로 수정해나갈 예정입니다. 2023-07-22 v1.0

도서 자바의신, 이것이 자바다를 참고하였습니다.

1. 패키지

패키지는 수많은 클래스를 분류하기 위해 사용됩니다. 패키지는 소스의 가장 첫 줄에 있어야 하며, 패키지 선언은 한 번만 해야 합니다.

package 상위패키지.하위패키지;

public class classA {
    ...
}

패키지 이름과 위치한 폴더 이름이 같아야하는데, 그렇지 않다면 컴파일이 되지 않습니다. 또한 패키지 이름을 java로 시작하면 안됩니다. 자바 표준 API에서만 사용하기 때문입니다. 그럴 경우 java.lang.SecurityException "Prohibited package name:java" 라는 에러가 발생하게 됩니다.

1) 패키지명 규칙

패키지 이름은 모두 소문자로 작성하는 것이 관례이며, 자바 예약어를 사용하면 안됩니다. 숫자로 시작하면 안되고, _와 $를 제외한 특수 문자 사용이 안됩니다. 주로 com.회사명.프로젝트명으로 작성합니다.

2) 패키지 선언이 포함된 클래스 컴파일

javac -d .           ClassName.java  <- 현재 폴더 내에서 생성
javac -d ..\bin      ClassName.java  <- 현재 폴더와 같은 위치의 bin 폴더에 생성
javac -d C:\Temp\bin ClassName.java  <- C:\Temp\bin 폴더에 생성

2. 접근 제어자

• public : 누구나 접근 가능합니다. 소스 파일의 이름은 public인 클래스 이름과 동일해야 합니다.
• protected : 같은 패키지 혹은 상속받은 관계에서 접근 가능합니다.
• (default) : package-private라고도 하며 같은 패키지에서만 접근 가능합니다.
• private : 같은 클래스에서만 접근 가능합니다.

3. 상속

class 자식클래스 extends 부모클래스 {...}

자바에서의 상속은 단일 상속만 가능합니다. 상속을 받으면 부모 클래스에 있는 public 및 protected로 선언된 모든 메소드나 변수를 자식 클래스에서 사용 가능합니다. 단, 접근 제어자가 없거나 private은 상속 대상에서 제외됩니다. 자식 클래스의 생성자를 호출하면, 부모 클래스의 기본 생성자가 실행됩니다.

1) 상속과 생성자

• 부모 클래스에 기본 생성자가 없다면? 괜찮습니다.
• 그런데, 매개변수가 있는 생성자만 있다면? 부모 클래스에 기본 생성자가 없다는 컴파일 에러가 발생합니다. 부모 클래스의 상속을 받는 자식 클래스의 모든 생성자가 실행될 때, 개발자가 따로 지정하지 않아도 컴파일러가 자식 클래스를 컴파일할 때 자동으로 super()라는 문장이 들어가게 됩니다. 이 super()는 부모 클래스의 생성자를 호출한다는 의미로, super()는 반드시 자식 클래스의 생성자에서 가장 첫줄에 선언되어야 합니다.
• 매개 변수를 갖는 생성자가 여러개거나, 혹은 null을 넘겨준다면? 부모 클래스로의 참조가 매우 모호하다는 컴파일 에러가 발생합니다. super()를 사용하여 생성자를 호출할 때에는 모호하게 null을 넘기는 것보다는 호출하고자 하는 생성자의 기본 타입을 넘겨주는 것이 좋습니다.
• 자식 클래스에서 부모 클래스와 같은 생성자를 만들면, 그 매개변수로 하는 부모 클래스의 생성자를 호출하나? 아닙니다. 자바는 부모의 기본 생성자를 찾는 것이 기본입니다. super()를 이용해서 부모 생성자를 꼭 호출해야 합니다.

4. 메소드 오버라이딩(Overriding)

오버라이딩은 부모 클래스에서 정의한 메소드를 자식 클래스에서 재정의해서 사용하고 싶을 경우 사용됩니다. 오버라이딩은 부모 클래스와 동일한 시그니처(메소드명, 매개 변수의 타입과 개수)와 동일한 리턴 타입을 갖는 자식 클래스의 메소드가 존재할 때 성립됩니다. 접근 제어자는 달라도 되지만, 확장되는 경우에만 허용됩니다. 축소될 경우에는 컴파일 에러가 발생합니다. ex) private -> pulic ⭕️, public -> private ❌

오버로딩: 확장 (메소드의 매개 변수들을 확장) 오버라이딩: 재정의 (부모 클래스의 메소드 시그니처를 복제해서 자식 클래스에서 재정의)

5. 참조 자료형의 형변환

ParentClass parentClass = new ChildClass(); //⭕️ UpCasting

ChildClass childClass = new ParentClass();  //❌
//Incompatible types. Found: 'com.test.inheritance.ParentClass', required: 'com.test.inheritance.ChildClass'

부모 클래스는 자식 클래스에 있는 모든 메소드와 변수 사용 불가능합니다. 컴파일러에서는 자식 객체를 생성할 때 부모 생성자를 사용하면 안된다고 위와 같이 컴파일 에러를 발생시킵니다. 따라서 명시적으로 형 변환(casting)을 한다고 알려줘야 합니다.

ChildClass childClass = (ChildClass) new ParentClass(); //DownCasting

이 경우에는 컴파일 에러는 발생하지 않지만, ClassCastException이 발생합니다.

참고로, 기본 자료형의 경우 데이터의 범위가 넓어져도 값이 바뀌지 않기 때문에(int -> long) 형변환을 굳이 명시적으로 하지 않아도 자동 형 변환이 됩니다. 하지만 long -> int로 형 변환을 하면 값이 바뀔 수도 있기 때문에 명시적으로 형 변환을 해야 합니다. 이 때, 값이 동일하다는 보장은 전혀 없습니다.

6. instanceof

객체 instanceof 클래스(타입)

객체의 타입을 확인할 때 사용됩니다. 만약 객체가 해당 클래스의 타입이라면 true값을 리턴받습니다. 주의할 점은 부모 타입도 true를 리턴하기 때문에, 가장 하위에 있는 자식 타입부터 확인해야한다는 것입니다.

7. 다형성(Polymorphism, 多形性)

선언 시 모두 Parent로 선언해도 실제로 호출되는 메소드는 생성자를 사용한 클래스에 있는 것이 호출됩니다. 각 객체의 실제 타입은 다르기 때문입니다. 즉, 형변환을 하더라도 실제 호출되는 것은 원래 객체에 있는 메소드가 호출되는 것을 다형성이라고 합니다.

8. 인터페이스(Interface)

public interface 인터페이스A {
    몸통없는메소드();
}

public class 구현클래스 implements 인터페이스A, 인터페이스B {
    //인터페이스에 정의된 모든 메소드 구현...
}

인터페이스와 추상 클래스를 사용하는 이유는 무엇일까요? 우선 설계 시 선언해 두면 개발할 때 기능을 구현하는 데에만 집중이 가능하고, 개발자의 역량에 따른 메소드명과 매개변수 선언의 격차가 완화됩니다. 공통적인 인터페이스와 추상 클래스를 선언해 놓으면, 선언과 구현 구분할 수 있습니다. 인터페이스는 상속이 아니라, implements 키워드를 사용함으로써 해당 클레스에서 구현해야 하는 인터페이스들을 정의함으로써 클래스에 짐을 지어주고, 인터페이스에 정의된 모든 메소드를 구현해야 컴파일이 됩니다. 객체를 생성할 때는 인터페이스 변수명 = new 구현클래스();로 선언해주면 되며, 단일 상속을 해야 하는 클래스와는 달리 여러 인터페이스를 구현할 수 있습니다.

9. 추상(abstract) 클래스

public abstract classA {
    public abstract void methodA(); //추상 메서드

    public String test() {
        //몸통 있는 메서드 사용 가능
    }
}

추상 클래스는 자바에서 마음대로 초기화하고 실행 불가능합니다. 단, 추상 클래스를 구현한 클래스로는 초기화와 실행 가능합니다. 추상 클래스는 abstract으로 선언된 메소드가 0개 이상이면 되고, 만약 1개라도 있으면 그 클래스는 반드시 abstract으로 선언되어야 합니다. 또한 몸통있는 메소드가 있어도 상관 없으며 static이나 final 메소드도 상관 없습니다.(단, 인터페이스는 안됩니다.) 어떤 메소드들은 미리 구현해놔도 상관없는데, 그렇다고 클래스를 만들자니 애매한 경우 사용됩니다.

10. final

final 키워드는 어디에 선언하느냐에 따라 그 용도가 다릅니다.

• 클래스(final class ClassA {...}) : 상속 불가 -> 더 이상 확장해서는 안되는 클래스로, 누군가 이 클래스를 상속받아서 내용 변경해서는 안될 때 사용합니다.
• 메소드(final void methodA() {...}) : Overriding 불가
• 변수(final int variableA = 1;) : 더 이상 바꿀 수 없음 -> 인스턴스 변수나 static으로 선언된 클래스 변수는 변수 생성과 동시에 초기화해야 합니다.

클래스가 final이라 해서 그 안에 있는 인스턴스 변수나 클래스 변수가 final일 필요는 없습니다.

final MemberDTO dto = new MemberDTO();
dto = new MemberDTO();     //❌
dto.name = "Java";        //⭕️ MemberDTO 안에 있는 name 변수는 final이 아님.

클래스, 인터페이스, 추상 클래스를 표로 정리하면 다음과 같습니다.

11. Enum 클래스(=열거형 클래스)

enumeration : n. 셈, 계산, 열거, 목록, 열람표

public enum EnumA (extends java.lang.Enum){
    MON, TUE, WED
}

public enum EnumB {
    RED(2), BLUE(350), GREEN(6) //상수 값 지정 가능하나 값 동적 할당은 불가능
}

Enum 클래스는 JDK 1.5부터 추가된 클래스로, 상수의 집합 클래스를 의미합니다. 별도로 타입이나 값을 지정할 필요 없고, 상수들을 쉼표로 나열하면 됩니다. 만약 상수들만 선언할 경우 세미콜론도 필요 없습니다. 각각의 상수들은 public static final입니다.

Enum 클래스에 지정된 상수를 사용하려면 EnumA.MON처럼 enum클래스명.상수명으로 지정함으로써 객체 생성이 완료됩니다. Enum 클래스에 생성자를 만들 수는 잇지만 생성자를 통한 객체 생성은 불가능하며, 각 상수를 Enum 클래스 내에서 선언할 때만 생성자 사용이 가능합니다. 생성자의 접근제어자는 package-private과 private만 사용 가능합니다.

Enum 클래스는 무조건 java.lang.Enum클래스를 상속받는데, 컴파일러가 알아서 protected Enum(String name, int ordinal)생성자를 호출해줍니다. 여기서 ordinal은 enum 상수의 순서이며, 선언된 순서대로 0부터 증가합니다. 만약 클래스 내 같은 키워드가 있으면 컴파일 에러를 발생시킵니다.

1) Enum 클래스 메소드

• int compareTo(E e) : 매개변수 e와의 순서(ordinal) 차이를 리턴함. e가 더 앞에 있으면 양수, 뒤면 음수, 같으면 0 리턴함.
• Class<E> getDeclaringClass() : 클래스 타입의 enum 리턴함.
• String name() : 상수 이름을 리턴함.
• int ordinal() : 상수 순서를 리턴함.
• static <T extends Enum<T>> T valueOf(Class<T> enumType, String name)
• values() : API에는 없는 메소드로, enum 클래스에 선언되어 있는 모든 상수를 배열로 리턴함.

지속해 수정해 나갈 예정입니다. 2023-07-08 v1.0 2023-07-22 v1.1 - 인터페이스, 추상클래스, enum 내용 추가함

• Mutable: adj. 변할 수 있는, 잘 변하는

• Immutable: adj. 변경할 수 없는, 불변의

Mutable 변수는 값을 재할당할 수도 있고, 값을 바꿀 수도 있습니다. 그와 반대로 immutable 변수는 값을 바꿀 수가 없고 재할당을 할 수 없습니다. Immutable 변수는

• 멀티스레드일 때 thread safety를 보장해주고,
• 값을 바꿀 수 없기 때문에 보안성이 높아집니다.

대표적인 예로 자바의 String이 있습니다.

String is Immutable

만약 new 연산자를 사용해서 String 객체를 생성하면 String constant pool 영역 밖 Heap에 생성됩니다. 하지만 모두 Heap 영역에 생기기 때문에 GC의 영역 대상이 됩니다.(Java7~)

String strA = "a";
String strB = "b";
System.out.println(System.identityHashCode(strA)); //1651191114
System.out.println(System.identityHashCode(strB)); //1579572132

strA = strA + strB;
System.out.println(System.identityHashCode(strA)); //783286238   

System.identityHashCode 메소드는 hashCode 메소드로 오버라이딩 하지 않은 객체의 해시코드값을 10진수로 변환해주는 메소드입니다. strA와 strB 그리고 strA와 strB를 더한 strA 변수의 메모리 주소가 다른 것을 확인할 수 있습니다. String은 + 연산을 할 때 strA가 참조하고 있는 힙의 값이 재할당되는 것이 아니라, heap에 새로 만들어서 그 주소를 재참조합니다.

String의 hashCode() 메소드로 호출했을 때는 ASCII 코드랑 같은 값이 나왔다..!

String strA = "a";
System.out.println(System.identityHashCode(strA)); //1651191114

strA = "hello";
System.out.println(System.identityHashCode(strA)); //1579572132

Mutable -> Immutable

Mutable을 immutable로 변경하려면 아래의 규칙들을 따라야 합니다.

• 모든 필드들을 private final 로 지정합니다.

• setter 메서드가 있으면 안됩니다.
• mutable 필드를 리턴하는 getter 메서드가 있으면 안됩니다.
  • 객체를 리턴하는 getter 메서드가 있다면, 이 객체는 반드시 immutable 해야 합니다.
  • 레퍼런스 타입의 필드에 적용됩니다.
  • 또는 mutable 필드를 get해야 한다면 방어적 복사를 해야 합니다.
• 자녀 클래스에서 메서드 override를 금지시켜야 합니다. 즉, 클래스 상속이 불가능하도록 final 클래스로 지정해줍니다.

아래의 Person 클래스는 name이라는 필드를 갖고, get과 set 모두 가능한 mutable한 클래스 입니다.

public class Person {
    private String name;

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
} 

Immutable하게 바꾸려면 우선 생성자를 제외하고 상태를 바꿀만한 메서드는 모두 제거해야합니다. 여기서는 setName()이 해당됩니다.

public class Person {
    private String name;

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

필드가 현재 private으로만 되어있으므로, final 키워드를 붙여줌으로써, Person 클래스에서만 name 필드를 접근 가능하도록 수정해줍니다.

public class Person {
    private final String name;

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

이렇게 변경된 클래스 Person을 상속 받음으로써 아래와 같이 mutable처럼 사용될 수 있습니다.

public class NewPerson extends Person {

    private String newName;

    public NewPerson(String name) {
        super(name);
        newName = name;
    }

    @Override
    public String getName() {
        return this.newName;
    }

    public void setName(String newName) {
        this.newName = newName;
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new NewPerson("choonsik");
        System.out.println("person.getName() = " + person.getName()); //choonsik

        NewPerson newPerson = (NewPerson) person;
        System.out.println("newPerson.getName() = " + newPerson.getName()); //choonsik

        newPerson.setName("Java");
        System.out.println("person.getName() = " + person.getName()); //Java
    }
}

분명히 newPerson에서 setName을 해주었는데, person의 name이 변경되었습니다. 왜 그럴까요? 그 이유는 바로, Person 클래스를 상속받은 NewPerson 클래스에서 getName() 메소드를 NewPerson의 name을 리턴하도록 재정의했기 때문입니다. 따라서 person.getName()을 하게되면 실제로는 NewPerson 클래스의 재정의된 getName()을 호출합니다. 따라서 상태가 바뀐 것 처럼 보이게 됩니다. 이를 막기 위해, Person 클래스를 상속받지 못하도록 클래스 또한 final 클래스가 되도록 final 키워드를 붙여줍니다.

public final class Person {
    private final String name;

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

그런데 만약 객체의 필드 중에 mutable 객체를 가리키는 레퍼런스가 있다면 어떻게 될까요?

public class RGB {
    public int r;
    public int g;
    public int b;

    public RGB(int r, int g, int b) {
        this.r = r;
        this.g = g;
        this.b = b;
    }
} 

위와 같은 mutable한 RGB 클래스가 있다고 가정을 합니다. 그리고, Person의 클래스는 다음과 같습니다.

public final class Person {
    private final String name;
    private final RGB rgb;

    public Person(String name, RGB rgb) {
        this.name = name;
        this.rgb = rgb;
    }

    public String getName() {
        return name;
    }

    public RGB getRGB() {
        return rgb;
    }
}

모든 필드가 private final로 되어있고, 상태를 변경시키는 setter 메서드도 없으며 클래스 또한 상속이 불가능한 final 클래스인데 완벽한 immutable 일까요? 아닙니다. 다음 코드를 보겠습니다.

public static void main(String[] args) {
    RGB green = new RGB(0, 128, 0);

    Person person = new Person("choonsik", green);
    System.out.println("person.getRGB().g = " + person.getRGB().g); //128

    green.g = 0;
    System.out.println("person.getRgb().g = " + person.getRGB().g); //0
}

Person 클래스에서는 분명히 RGB값을 변경하는 메소드가 없었음에도 불구하고 green 값이 바뀐 것을 확인할 수 있습니다. Person의 생성자를 보게 되면 RGB 라는 객체(레퍼런스)를 받게 됩니다. 따라서, RGB의 값이 변경되면 Person 또한 바뀐 RGB 객체를 바라보게 됩니다.

public Person(String name, RGB rgb) {
    this.name = name;
    this.rgb = new RGB(rgb.r, rgb.g, rgb.b);
}

이를 해결하기 위해서, Person 객체를 생성할 때 파라미터값으로 넘어오는 RGB 객체를 사용해 다시 새로운 RGB 객체를 생성하고 person의 rgb 멤버 변수는 이 새로운 객체를 가리키게 됩니다. 즉, green.g = 0;을 했을 때에도 변경되지 않은 값(128)을 리턴해주게 됩니다. 그래도! 문제가 있습니다.

RGB myRGB = person.getRGB();
myRGB.g = 0;
System.out.println("person.getRgb().g = " + person.getRGB().g); //0

여기서는 Person 클래스의 getRGB() 메소드에서 문제가 되는데, Person이 가지고 있는 RGB 객체를 그대로 리턴해주었기 때문에 문제가 발생한겁니다. 다시 말해, 리턴할 때의 RGB 객체는 값을 변경할 수 있는 mutable 객체로 값을 person에서 getRGB()를 하더라도 실질적으로는 Mutable한 객체 RGB를 전달해주기 때문에 값이 변경된 것입니다. 이를 해결하기 위해서, getRGB()를 할 때 다시 한 번 새로운 RGB를 리턴하도록 변경해주어야 합니다. -> 방어적 복사

public RGB getRGB() {
    return new RGB(rgb.r, rgb.g, rgb.b);
}

방어적 복사 : 객체를 복사해서 새로운 독립적인 객체를 생성하는 복사 기법. 기존의 객체와는 별개로 관리되어 기존 객체의 값이 변경되지 않는다.

Collection은 어떻게 Immutable 하도록 변경할 수 있을까?

RGB 클래스에서 toString()을 재정의해 주었습니다.

public class RGB {
    public int r;
    public int g;
    public int b;

    public RGB(int r, int g, int b) {
        this.r = r;
        this.g = g;
        this.b = b;
    }

    @Override
    public String toString() {
        return "RGB{" +
                "r=" + r +
                ", g=" + g +
                ", b=" + b +
                '}';
    }
}

Person 클래스의 RGB 필드 대신 List<RGB> rgbs를 새로 만들고, copy() 메소드가 추가되었습니다.

public final class Person {
    private final String name;
    private final List<RGB> rgbs;

    public Person(String name, List<RGB> rgbs) {
        this.name = name;
        this.rgbs = copy(rgbs);
    }

    public String getName() {
        return name;
    }

    public List<RGB> getRGBs() {
        return copy(rgbs);
    }

    private List<RGB> copy(List<RGB> rgbs) {
        List<RGB> cps = new ArrayList<>();
        rgbs.forEach(o -> cps.add(new RGB(o.r, o.g, o.b)));
        return cps;
    }
}

이 copy 메소드에서 List를 새로 생성하고, 이 새로 생성된 cps에 파라미터로 들어온 List rgbs의 각 객체를 꺼내 cps에 추가해주고, cps를 리턴해줍니다. 이렇게 함으로써 방어적 복사를 할 수가 있습니다.

public static void main(String[] args) {
    RGB red = new RGB(128, 0, 0);
    RGB green = new RGB(0, 128, 0);
    RGB blue = new RGB(0, 0, 128);

    List<RGB> rgbs = new ArrayList<>();
    rgbs.add(red);
    rgbs.add(green);
    rgbs.add(blue);

    Person person = new Person("choonsik", rgbs);
    List<RGB> rgbList = person.getRGBs();
    System.out.println("rgbList.toString() = " + rgbList.toString()); 
    //[RGB{r=128, g=0, b=0}, RGB{r=0, g=128, b=0}, RGB{r=0, g=0, b=128}]
    }

만약 List<RGB> rgbs 가 immutable이라면 copy() 메소드를 다음과 같이 변경하면 됩니다. 얕은 복사를 통해 List는 새로 만들지만 안에 있는 RGB 객체는 같은 레퍼런스를 복사하게 됩니다.

private List<RGB> copy(List<RGB> rgbs) {
    return new ArrayList<>(rgbs); //얕은 복사: 주소값 복사
}

또는 생성자를 변경해줄 수도 있습니다.

public Person(String name, List<RGB> rgbs) {
    this.name = name;
    this.rgbs = Collections.unmodifiableList(rgbs);
}

public List<RGB> getRGBs() {
    return this.rgbs;
}

참조 Java Strings are Immutable - Here's What That Actually Means 불변 객체(immutable object)는 안정적인 개발에 아주 도움이 됩니다! 불변 객체의 개념과 장점, 구현 방법을 자바 예제를 통해 배워보아요~! <- 강추👍🏻 Immutable Classes and Objects in Java

직장이 코엑스 근처인데, 어찌된게 인프콘 2022도 춘식이 팬미팅도 다 코엑스에서 열렸는데 한 번도 당첨이 되지 않을까.

처음에는 인프콘 떨어졌다는 메일을 받았는데, 카카오톡으로 연속 두 번이나 확인 사살 받았습니다. 그러니까 전 총 3번의 탈락 알람을 받은거죠!!! 🥲 그런데, 다행히도 인프콘 시간표를 공유하면 총 25명에게 입장권을 준다고 합니다. 그 중 한명이 되고 싶네요. 인프콘 관계자 분은 소중한 입장권 하나를 저에게 주시면 인프콘에 선정된 동기와 함께 손잡고 알차게 세션 듣다가 가겠습니다!

• 부호부: 0은 양수를, 1은 음수를 나타냅니다.
• 지수부: 소수점 이전 숫자열(정수)를 나타냅니다.
• 가수부: 소수점 이후 숫자열(소수) 전체를 나타냅니다.

Float은 부호 1자리 + 지수 8자리 + 가수 23자리 총 32비트를 나타냅니다. Double은 부호 1자리 + 지수 11자리 + 가수 52자리 총 64비트는 나타냅니다.

예를 들어 263.3 이라는 숫자가 있다고 가정해봅시다. 정수 263을 이진수로 변환하려면 2로 계속 나누어 나머지를 위에서부터 위로 적어주면 되는데, 결과값은 100000111이 나옵니다. 소수 0.7을 이진수로 변환하려면 2를 반복해서 곱해주면서 그 결과가 1이 나오거나 반복되는 숫자가 나올 때 까지 진행해주면 됩니다. 0.7은 0011이 반복해서 나왔으며 결과값은 010011001100110011... 이 나옵니다.

263.3 = 100000111.010011001100110011....

single precision 에서는 부호 1자리 + 지수 8자리 + 가수 23자리 총 32비트를 나타냅니다.

x xxxxxxxx xxxxxxxxxxxxxxxxxxxxxxx

263.3은 양수이므로 부호는 0이 됩니다.

0 xxxxxxxx xxxxxxxxxxxxxxxxxxxxxxx

정규화를 하기 위해 소수점을 왼쪽으로 이동시켜 정수 부분이 1이 되도록 만들어주어야 합니다.

1.00000111010011001100110011.... X 2⁸

소수점을 왼쪽으로 8번 이동시켰으므로 지수부는 8이 됩니다. 지수부 8을 표현하기 위해 bias 127(double에서는 1023)을 더해줍니다. 지수부는 8bit로 256개의 수를 표현할 수 있는데, 음수와 양수 모두를 나타내기 위해 일정한 상수(127)을 더해주어 표현합니다. 8 + 127 = 135로, 135를 다시 이진수로 변환하면 10000111이 나옵니다.

0 10000111 xxxxxxxxxxxxxxxxxxxxxxx

나머지 가수부는 위에서 소수점 뒤 00000111010011001100110011.... 을 23비트까지 잘라줍니다.

0 10000111 00000111010011001100110 0100 0011 1000 0011 1010 0110 0110 0110 -> 32bit

위 사진은 IEEE 754 Converter 사이트를 통해 결과값을 얻은 것으로 동일한 결과가 나왔음을 알 수 있습니다. 실제로 입력한 값은 263.3이지만 실제로 float에 저장된 값은 263.29998779296875 이라고 합니다. 따라서 왜 중요한 계산에서는 float이나 double을 지양해야 하는지 알 수 있었습니다.

참고 Chapter 2. The Structure of the Java Virtual Machine 부동소수점 (+ 실수계산 오차가 생기는 이유) IEEE Standard 754 Floating Point Numbers - GeeksforGeeks Decimal to IEEE 754 Floating Point Representation IEEE-754 Floating Point Converter

• JRE(Java Runtime Environment): JRE는 자바 애플리케이션이 구동되기 위한 최소한의 환경입니다. JVM과 개발 도구들이 포함되어 있습니다.
  • JVM(Java Virtual Machine): OS에 독립적으로 구동될 수 있도록 JVM 위에 애플리케이션이 돌아갑니다.
• JDK(Java Development Kit): 개발자는 개발하기 위해 JDK를 설치해야 합니다. JDK는 완전한 개발 환경을 만들어 주며, JRE와 개발 도구를 포함합니다.

JVM 아키텍처

1. Class Loader Subsystem

JVM은 RAM 안에서 상주합니다. 자바를 실행하게 되면, Class Loader Subsystem이 실행되면서 클래스 파일(.class)들을 RAM으로 가져오는데, 이를 동적 클래스 로딩이라고 합니다. Class Loader Subsystem을 통해 런타임 시 처음으로 로드될 때 동적으로 클래스 파일을 Loading, Linking 및 Initialization 합니다.

• Loading: 특정 이름을 가진 클래스 또는 인터페이스 바이너리 데이터를 찾고 JVM method area에 저장합니다.
• Linking: 클래스 또는 인터페이스를 가져와 실행될 수 있도록 런타입 상태의 JVM에 결합해 주는 프로세스입니다.
• Initialization: 컴파일러에 의해 제공되는 클래스 및 인터페이스 초기화 메서드 <clinit> 실행을 해 초기화합니다.

2. Runtime Data Area

Runtime Data Area는 JVM이 OS에서 실행될 때 할당받는 메모리 영역입니다.

Class Loader Subsystem은 클래스 파일을 읽는 것 외에도 바이너리 데이터를 생성하고 각 클래스에 대한 정보를 Method Area에 적재합니다. 모든 클래스 파일이 로드가 완료되면, heap 메모리에 클래스 파일을 나타내는 하나의 클래스 객체를 만듭니다. 이 클래스 객체는 나중에 코드에서 클래스 정보(클래스명, 부모명, 메서드, 변수정보, 정적 변수 등)을 읽는데 사용됩니다.

1) Method Area(=Static Area, Class Area)

Method Area는 JVM이 시작될 때 생성되며, JVM 한 개에 하나의 Method Area만 생깁니다. 모든 JVM thread들은 같은 Method Area를 공유합니다. Method Area는 논리적으로 Heap에 포함되며, Java 7 이전에는 Heap의 PermGen이라는 영역에 속했지만, Java 8 이후로는 Metaspace라는 OS가 관리하는 영역으로 옮겨졌습니다. Method Area는 static 변수, 런타임 상수 풀, 필드 데이터, 메소드 데이터, 클래스로더 레퍼런스 등 클래스 레벨의 데이터를 저장합니다.

2) Heap

Heap 또한 JVM 당 하나의 Heap Area가 생기며, 모든 JVM thread들은 같은 Heap을 공유합니다. new 연산자로 생성된 모든 객체와 관련된 인스턴스 변수와 배열, 문자열에 대한 정보를 가진 String Pool 등이 Heap 영역에 저장되며, GC의 대상이 됩니다. Method Area와 Heap은 멀티 스레드에서 공유되는 메모리로, Method Area와 Heap Area에 저장되는 데이터들은 thread safe 하지 않습니다.

Java 7의 Permanent 영역은 보통 Class의 메타 정보나 method의 메타 정보, Static 변수와 상수 정보들이 저장되는 공간으로 흔히 메타데이터 저장 영역이라고도 합니다. Java 8부터는 Native 영역으로 이동하여 Metaspace 영역으로 변경되었습니다. 기존 permanent 영역에 존재하던 Static Object 변수, 상수는 Heap 영역으로 이동되었습니다. Heap 영역은 JVM에 의해 관리되는 영역이며, Native 영역은 OS 레벨에서 관리하는 영역으로 구분됩니다. Metaspace가 Native 메모리를 이용함으로써 개발자는 영역 확보의 상한을 크게 신경 쓸 필요가 없어져서 제거되었습니다.

3) Stack

Stack은 공유 자원이 아니므로 thread safe하고 각 thread가 시작되면, 메서드 호출을 저장하기 위한 별도의 런타임 스택이 각각 생성됩니다. 모든 메소드를 호출할 때마다 하나의 Frame이 생성되어 런타임 스택의 맨 위에 추가(push)되며 이러한 항목을 Stack Frame이라고 합니다.

각 stack frame은 실행 중인 메서드가 속한 클래스의 로컬 변수 배열, 피연산자 스택(메소드 내 연산을 위해 바이트 코드 명령문들이 있는 공간), 런타임 상수 풀에 대한 참조가 있습니다. 로컬 변수 배열과 피연산자 스택의 크기는 컴파일하는 동안 결정됩니다. 따라서 스택 프레임의 사이즈는 메소드에 의해 크기가 고정됩니다.

메소드가 정상적으로 실행 후 종료되거나 에러가 발생했을 때 해당 frame은 stack으로부터 제거(pop)됩니다. 만약 에러가 발생했다면, 각 줄의 stack trace(pringStackTrace() 메소드명의 유래가 여기서 나오네요.)를 한 스택 프레임에 나타냅니다.

stack의 사이즈는 동적이거나 고정될 수 있습니다. 만약 스레드가 큰 스택을 요구한다면 StackOverflowError가 발생하고, 만약 새로운 frame을 생성해야 하는데 메모리가 충분하지 않다면 OutOfMemoryError가 발생합니다.

4) PC Registers

각 JVM 스레드가 시작되면 PC Register는 현재 실행 중인 명령의 주소(Method area의 메모리 주소)를 기억하기 위해 PC(Program Counter) Register가 생성됩니다. 실행이 끝나면, PC register는 다음 명령의 주소로 업데이트됩니다.

5) Native Method Stack

Java thread에 대한 모든 상태를 준비한 후 JNI를 통해 호출되는 네이티브 메소드 정보(C/C++)를 저장하기 위해 별도의 기본 스택이 생성됩니다.

네이티브 스레드가 한 번 생성되고 초기화되면, 자바 스레드의 run() 메소드를 호출합니다. run() 메소드가 리턴될 때 uncaught exeption을 포착하면 네이티브 스레드는 JVM을 종료해야 하는지 여부를 확인합니다. 스레드가 종료되면 모든 네이티브 및 자바 스레드의 리소스들은 해제됩니다. 네이티브 스레드는 자바 스레드가 종료되면 회수됩니다. 따라서 운영 체제는 모든 스레드를 스케줄링할 수 있고 사용할 수 있는 CPU로 참조합니다.

3. Execution Engine

bytecode의 실제 실행은 Execution Engine에서 이루어집니다. Execution Engine은 Runtime data areas에 할당된 데이터를 읽어 bytecode의 명령을 한 줄씩 실행합니다.

1) Interpreter

Interpreter는 바이트코드를 해석하고 명령을 하나씩 실행합니다. 하나의 바이트코드 라인을 빠르게 해석할 수는 있지만, 그 결과를 실행하는 작업은 느립니다.

2) Just-In-Time(JIT) Compiler

JIT는 모든 바이트코드를 네이티브코드(machine code)로 컴파일하고, 반복되는 메소드 호출에 대해 네이티브 코드를 직접 제공하여 향상된 속도를 제공합니다. 네이티브 코드는 캐시에 저장되므로 컴파일된 코드를 더 빨리 실행할 수 있습니다.

3) Garbage Collector (GC)

객체가 더이상 참조되지 않으면 GC는 해당 객체를 제거하고 사용되지 않은 메모리를 회수합니다.

참고 Understanding JVM Architecture JVM에 관하여 - Part 3, Run-Time Data Area 자바 메모리 구조(Runtime Data Area) Java Heap (with GC) JDK 8에서 Perm 영역은 왜 삭제됐을까

지속적으로 수정해나갈 예정입니다. 2023-07-13 v1.0