코딩처럼

직장인 필수 파워포인트 기본 단축키 모음

pongic — Tue, 29 Apr 2025 16:39:43 +0900

파워포인트(PowerPoint)를 사용할 때, 단축키만 잘 활용해도 작업 속도가 눈에 띄게 빨라진다.
파워포인트를 잘 다루는 것만으로도 작업 효율과 발표 완성도가 크게 달라진다.

기본적인 파워포인트 단축키 정리

1. 슬라이드 작업

Ctrl + M : 새 슬라이드 추가
Crtl + D : 선택한 슬라이드 개체 복제
Ctrl + Shift + D : 현재 슬라이드 복제

2. 저장 및 파일 관리

Ctrl + S : 파일 저장
Ctrl + O : 파일 열기
Ctrl + P : 인쇄

3. 실행 관련

Ctrl + Z : 실행 취소
Ctrl + Y : 실행 복원

4. 개체 다루기

Ctrl + A : 모두 선택
Ctrl + C : 복
Ctrl + V : 붙여넣기
Ctrl + X : 잘라내기
Delete : 삭제
Ctrl + G : 그룹화
Ctrl + Shift + G : 그룹해제

웹 서버와 WAS 서버의 차이

pongic — Tue, 29 Apr 2025 14:09:12 +0900

웹 개발 또는 인프라 구조를 공부하면 꼭 등장하는 개념 WEB WAS 서버

이 둘은 모두 웹 서비스에 필수적인 요소이지만 역할과 기능은 분명히 다르다.

웹 서버(Web Server)란 무엇인가요?

정적인 콘텐츠를 클라이언트에게 제공하는 역할

예를 들어 HTML, CSS, 이미지 등과 같은 파일 그대로를 전달해주는 역할

WAS(Web Application Server) 서버란 무엇인가요?

동적인 콘텐츠를 처리하는 서버

사용자의 입력이나 요청에 따라 백엔드 로직을 실행하고, 결과를 생성해서 브라우저로 전달하는 역할

예를 들어 로그인, 게시판 작성 등 단순한 정적 페이지로 처리할 수 없는 기능들

웹 서버와 WAS 비교

주 기능	정적 콘텐츠 제공	동적 콘텐츠 처리
처리 대상	HTML, CSS, JS, 이미지 등	Java, Python, PHP 등 백엔드 로직
요청 처리	요청된 파일을 그대로 응답	코드 실행 후 결과를 생성하여 응답
대표 프로그램	Apache, Nginx	Tomcat, JBoss, WebLogic
속도	빠름 (처리 단순)	상대적으로 느림 (처리 복잡)

실제 서비스에서는 웹 서버와 WAS는 함께 구성되어 협업

웹 서버가 간단한 정적 요청을 먼저 처리하고, 복잡한 동적 요청은 WAS로 전달

이렇게 나누면 서버 부담이 줄고, 속도도 빨라지기 때문에 서비스 안정성과 확장성이 향상된다.

[파워포인트 PPT] 정렬 단축키 설정

pongic — Thu, 19 Sep 2024 22:52:15 +0900

파워포인트를 사용하면서 많은 단축키를 사용하지만 정렬에 대한 부분은 마우스로 정렬을 클릭 가운데 정렬, 우측 정렬, 좌측 정렬처럼 일일이 클릭해서 사용하는 경우가 많다.

하지만, 해당 과정을 단축키로 지정해서 키보드로 입력하게 된다면 작업 속도는 배로 빨라질 것이다.

그럼 어떻게 세팅하는지 자세히 알아보자

PPT 화면에서 상단에 있는 영역 빈 공간 우클릭

우클릭 후 리본 메뉴 사용자 지정 클릭

빠른 실행 도구 모움 클릭

명령 선택 박스에서 모든 명령 선택

정렬 관련 명령 선택 후(1) 추가 버튼(2) 클릭

확인 버튼 클릭 시 상단에 빠른 실행 도구 영역 생성

해당 화면에서 Alt 키를 누르면 번호 표출

사용하고자 하는 명령에 대해 번호 입력 Alt + 1

이처럼 빠른 실행 도구를 커스텀 하여 마우스 없이 키보드 만으로 귀찮은 작업인 정렬을 빠르게 작업할 수 있도록 설정해 보았다. 정렬 이외에도 자주 쓰는 명령어들이 있다면 상단에 내용을 참고하여 새롭게 빠른 실행 도구를 만들어서 활용해 보자.

귀찮은 건 줄여야지

[알고리즘] 삽입 정렬 정리

pongic — Thu, 19 Sep 2024 22:13:29 +0900

삽입 정렬(Insertion Sort)은 비교 기반의 정렬 알고리즘으로, 배열의 각 요소를 순차적으로 선택하여 적절한 위치에 삽입하면서 배열을 정렬하는 방식이다. 이 알고리즘은 현재 배열의 일부분을 이미 정렬된 상태로 유지하면서, 새로운 요소를 삽입하는 방식으로 작동한다. 거의 정렬된 데이터에서 매우 효율적으로 동작하며, 구현이 간단하고 직관적인 특징이 있다.

동작 방식

초기 상태: 첫 번째 요소는 이미 정렬된 것으로 가정한다.
두 번째 요소부터 시작: 배열의 두 번째 요소를 선택한다.
왼쪽에 있는 정렬된 부분과 비교: 선택한 요소를 왼쪽의 정렬된 부분에 삽입할 적절한 위치를 찾기 위해 비교한다.
삽입: 비교하여 자신보다 큰 값들은 한 칸씩 오른쪽으로 이동시키고, 자신의 자리를 찾으면 그 위치에 삽입한다.
반복: 이 과정을 배열의 끝까지 반복한다.

장점

간단하고 구현이 쉬움: 알고리즘 구조가 직관적이기 때문에 간단하게 구현할 수 있다.
거의 정렬된 데이터에 효율적: 데이터가 이미 정렬되어 있거나 거의 정렬된 경우 매우 빠르게 동작한다.
제자리 정렬(In-place sorting): 별도의 메모리를 거의 사용하지 않는다. 정렬을 위한 추가적인 메모리가 필요하지 않기 때문에 메모리 효율적이다.
안정성(Stable): 동일한 값들이 원래의 순서를 유지한다.

단점

비효율성: 요소를 삽입할 때 왼쪽 부분의 요소들을 모두 비교해야 하므로, 큰 배열이나 역순으로 정렬된 배열에서 성능이 좋지 않다.
시간 복잡도: 최악의 경우 시간 복잡도는 O(n²)로, 배열이 역순으로 정렬되어 있을 경우 많은 비교와 이동이 발생한다.

※ 시간 복잡도
최선의 경우 (O(n)): 배열이 이미 정렬되어 있을 경우, 삽입할 때 비교가 거의 발생하지 않으므로 선형 시간에 완료
평균 및 최악의 경우 (O(n²)): 일반적으로 요소를 삽입할 위치를 찾기 위해 많은 비교와 이동이 필요할 때는 이중 루프가 사용되므로, 시간 복잡도는 O(n²)가 된다.

코드

public class InsertionSort {

    // 삽입 정렬 알고리즘
    public static void insertionSort(int[] arr) {
        // 1. 배열의 두 번째 요소부터 끝까지 순차적으로 탐색
        for (int i = 1; i < arr.length; i++) {
            int key = arr[i];  // 현재 삽입할 값 (key)
            int j = i - 1;  // key 앞에 있는 요소들의 인덱스

            // 2. 현재 key 값보다 큰 값들을 오른쪽으로 한 칸씩 이동
            while (j >= 0 && arr[j] > key) {
                arr[j + 1] = arr[j];  // 요소를 한 칸씩 오른쪽으로 이동
                j--;  // 한 칸 왼쪽으로 이동하며 비교
            }
            
            // 3. key 값을 적절한 위치에 삽입
            arr[j + 1] = key;
        }
    }

    // 배열 출력 메서드
    public static void printArray(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

    // 메인 메서드
    public static void main(String[] args) {
        int[] arr = {12, 11, 13, 5, 6};

        System.out.println("정렬 전 배열:");
        printArray(arr);

        insertionSort(arr);  // 삽입 정렬 호출

        System.out.println("정렬 후 배열:");
        printArray(arr);
    }
}

코드 설명

insertionSort 메서드:
- 이 메서드는 배열 arr의 두 번째 요소부터 시작해서 마지막 요소까지 탐색하며 정렬한다.
- key: 현재 삽입하고자 하는 값
- j: key의 앞에 있는 요소들을 비교하는 인덱스
외부 for문:
- 배열의 두 번째 요소부터 탐색을 시작하며, 현재 요소가 적절한 위치에 삽입될 때까지 앞의 요소들과 비교한다.
내부 while문:
- 현재 삽입하고자 하는 값 key와 그 이전의 값들을 차례로 비교한다.
- arr [j] > key이면, arr [j]를 오른쪽으로 한 칸 옮기고, j를 하나씩 줄이면서 비교를 이어간다.
- 이 과정을 반복하다가 key가 더 작은 값을 만나거나 배열의 시작에 도달하면, while문을 탈출한다.
key 삽입:
- 더 이상 비교할 필요가 없을 때, key 값을 적절한 위치에 삽입한다. arr [j + 1] 자리가 key의 위치가 된다.

동작 과정 예시

배열 {12, 11, 13, 5, 6}을 정렬하는 과정

첫 번째 단계 (i = 1):
- key = 11, j = 0
- arr [0] = 12는 key(11) 보다 크므로 오른쪽으로 이동
- key(11)은 arr [0]에 삽입
- 결과: {11, 12, 13, 5, 6}
두 번째 단계 (i = 2):
- key = 13, j = 1
- arr [1] = 12는 key(13) 보다 작으므로 이동하지 않고 key는 제자리에 위치
- 결과: {11, 12, 13, 5, 6}
세 번째 단계 (i = 3):
- key = 5, j = 2
- arr [2] = 13은 key(5) 보다 크므로 오른쪽으로 이동
- arr [1] = 12도 key(5) 보다 크므로 오른쪽으로 이동
- arr [0] = 11도 key(5) 보다 크므로 오른쪽으로 이동
- key(5)는 arr [0]에 삽입
- 결과: {5, 11, 12, 13, 6}
네 번째 단계 (i = 4):
- key = 6, j = 3
- arr [3] = 13은 key(6) 보다 크므로 오른쪽으로 이동
- arr [2] = 12도 key(6) 보다 크므로 오른쪽으로 이동
- arr [1] = 11은 key(6) 보다 작으므로 이동하지 않고 key는 arr [2]에 삽입
- 결과: {5, 6, 11, 12, 13}

삽입 정렬은 작은 데이터셋이나 이미 어느 정도 정렬된 데이터를 처리할 때 유용하며, 큰 데이터셋에서는 효율적이지 않을 수 있다.

[알고리즘] 시간 복잡도

pongic — Wed, 18 Sep 2024 21:13:04 +0900

시간 복잡도는 알고리즘의 효율성을 평가하는 중요한 척도이다. 주어진 입력 크기 n에 따라 알고리즘이 실행되는 데 걸리는 시간을 수학적으로 표현한 것이다. 이를 통해 알고리즘이 커지는 입력에 대해 얼마나 효율적인지 판단할 수 있다.

시간 복잡도 종류

O(1): 상수 시간 복잡도
- 입력 크기에 상관없이 실행 시간이 일정하다.
- 예: 배열에서 첫 번째 요소를 읽는 작업
- 이 코드는 입력 크기에 상관없이 언제나 한 번만 실행되므로 시간 복잡도는 O(1)이다. n이 커져도 동일한 작업을 하며, 실행 시간이 변하지 않는다.

public class ConstantTime {
    public static void main(String[] args) {
        int n = 100;
        System.out.println("첫 번째 요소: " + n);
    }
}

O(n): 선형 시간 복잡도
- 입력 크기 n에 비례하여 실행 시간이 증가한다.
- 예: 배열을 한 번 순회하는 작업
- 이 코드에서 for 루프는 배열의 길이만큼 반복된다. 즉, 배열의 크기가 커지면 반복 횟수도 비례하여 증가하므로 시간 복잡도는 O(n)이다.

public class LinearTime {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        for (int i = 0; i < arr.length; i++) {
            System.out.println("요소: " + arr[i]);
        }
    }
}

O(log n): 로그 시간 복잡도
- 입력 크기가 증가할수록 실행 시간이 느리게 증가한다. 매번 입력 크기를 절반으로 줄이는 방식의 알고리즘에서 자주 나타난다.
- 예: 이진 탐색
- 이 코드는 binarySearch를 사용하여 배열에서 특정 요소를 찾는다. 이진 탐색은 매번 배열을 절반으로 나누기 때문에 시간 복잡도는 O(log n)이다. 배열의 크기가 커져도 비교 횟수는 로그에 비례하여 증가한다.

import java.util.Arrays;

public class LogarithmicTime {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7};
        int key = 5;
        int result = Arrays.binarySearch(arr, key);
        System.out.println("키의 위치: " + result);
    }
}

O(n²): 이차 시간 복잡도
- 입력 크기 n에 비례하여 제곱으로 실행 시간이 증가한다. 중첩된 반복문에서 주로 발생한다.
- 예: 버블 정렬, 선택 정렬
- 여기서는 이중 for 루프가 사용되었으므로 배열의 크기가 증가하면 반복 횟수는 입력 크기 n의 제곱에 비례한다. 시간 복잡도는 O(n²)이다.

public class QuadraticTime {
    public static void main(String[] args) {
        int[][] matrix = {{1, 2}, {3, 4}};
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                System.out.println("요소: " + matrix[i][j]);
            }
        }
    }
}

O(2^n): 지수 시간 복잡도
- 입력 크기가 조금만 커져도 실행 시간이 매우 빠르게 증가한다. 재귀적 문제 풀이에서 자주 나타난다.
- 예: 재귀적인 피보나치 수열 계산
- 이 코드에서 피보나치 수열을 재귀적으로 계산하는 알고리즘은 매우 비효율적이다. 동일한 값을 여러 번 계산하기 때문에 시간 복잡도는 O(2^n)이다.

import java.util.Arrays;

public class NLogNTime {
    public static void main(String[] args) {
        int[] arr = {5, 3, 1, 6, 4, 2};
        Arrays.sort(arr);
        System.out.println("정렬된 배열: " + Arrays.toString(arr));
    }
}

빅오 표기법(Big-O Notation)

시간 복잡도는 빅오 표기법으로 표현한다. 빅오 표기법은 알고리즘의 최악의 경우에 대한 실행 시간을 나타내며, 입력 크기 n이 매우 커질 때 성능을 평가하는 데 사용된다. 이 표기법은 입력 크기 증가에 따른 주요 성능 패턴을 설명하는 데 유용하며, 미세한 상수 시간이나 작은 차이는 무시한다.

예를 들어, O(2n + 3)이라는 표현이 있을 때, 이는 결국 큰 입력에서 선형적으로 동작하므로 *O(n)* 으로 간략화된다.

중요성

시간 복잡도는 알고리즘의 효율성을 평가하는 핵심 지표이다. 같은 문제를 해결하는 다양한 알고리즘 중에서 시간 복잡도가 작은 알고리즘을 선택하면 큰 입력에 대해 더 빠른 성능을 보일 수 있다.

[Python] 리스트 (List) 정리

pongic — Wed, 11 Sep 2024 10:35:58 +0900

개요

Python에서 가장 많이 사용되는 자료형 중 하나로, 여러 개의 값을 순서대로 저장할 수 있는 가변적인 시퀀스(sequence)이다. 리스트는 대괄호([])로 감싸고, 값들은 쉼표(,)로 구분한다. 리스트에 저장되는 값은 다양한 자료형(정수, 문자열, 부동소수점 등)을 포함할 수 있으며, 리스트 내에 또 다른 리스트를 저장할 수 있다.

기본 동작과 주요 메서드

리스트 생성 : 리스트는 대괄호를 사용해 생성할 수 있다.

my_list = [1, 2, 3, 4, 5]
print(my_list)  # [1, 2, 3, 4, 5]

리스트 접근 및 인덱싱 : 리스트의 요소는 인덱스를 사용해 접근할 수 있으며, 인덱스는 0부터 시작한다.

print(my_list[0])  # 1
print(my_list[2])  # 3

리스트 길이 확인 : len() 함수를 사용하면 리스트의 길이를 확인할 수 있다.

print(len(my_list))  # 5

리스트 요소 추가 : append() 메서드를 사용해 리스트의 마지막에 요소를 추가할 수 있다.

my_list.append(6)
print(my_list)  # [1, 2, 3, 4, 5, 6]

리스트 요소 추가 : insert() 메서드를 사용해 특정 위치에 요소를 삽입할 수 있다.

my_list.insert(2, 99)
print(my_list)  # [1, 2, 99, 3, 4, 5, 6]

리스트 요소 삭제 : remove() 메서드는 리스트에서 첫 번째로 발견된 해당 값을 제거한다.

my_list.remove(99)
print(my_list)  # [1, 2, 3, 4, 5, 6]

리스트 요소 삭제 : pop() 메서드는 리스트에서 마지막 요소를 제거하고 반환한다. 인덱스를 지정하면 해당 위치의 요소를 제거한다.

my_list.pop()
print(my_list)  # [1, 2, 3, 4, 5]

my_list.pop(2)
print(my_list)  # [1, 2, 4, 5]

리스트의 슬라이싱 : 리스트의 특정 범위를 추출하려면 슬라이싱을 사용한다.

sub_list = my_list[1:3]
print(sub_list)  # [2, 4]

리스트의 반복문 처리 : for 문을 사용해 리스트의 모든 요소를 순회할 수 있다.

for element in my_list:
    print(element)
# 출력:
# 1
# 2
# 4
# 5

코드 예시

# 리스트 생성
fruits = ["apple", "banana", "cherry"]

# 리스트에 요소 추가
fruits.append("orange")
print(fruits)  # ["apple", "banana", "cherry", "orange"]

# 리스트에서 요소 제거
fruits.remove("banana")
print(fruits)  # ["apple", "cherry", "orange"]

# 인덱스를 사용한 리스트 접근
print(fruits[0])  # "apple"

# 슬라이싱
print(fruits[1:3])  # ["cherry", "orange"]

# 리스트의 모든 요소 순회
for fruit in fruits:
    print(fruit)
# 출력:
# apple
# cherry
# orange

[IT] 블록체인, 비트코인을 넘어선 기술 혁명의 시작

pongic — Tue, 10 Sep 2024 00:29:56 +0900

IT 분야에 관심이 많은 사람이라면, 블록체인에 대해 한번쯤은 들어봤을 것이다. 이유는 바로 어느 순간 등장한 비트코인이라는 암호화폐의 등장이라고 할 수 있다.

헝가리 부다페스트에 자리한 사토시 나카모토 동상

비트코인(Bitcoin)은 지난 2009년, 사토시 나카모토라는 익명의 인물에 의해 처음 제안된 디지털 화폐이다. 비트코인은 단순한 암호화폐를 넘어서, 현대 금융 시스템에 혁신적인 변화를 가져온 기술로 평가받고 있다. 암호화폐의 기본 개념부터 시작해, 비트코인이 어떻게 작동하는지, 그리고 그 배경에 깔려 있는 블록체인 기술에 대해 알아보는 것은 오늘날의 디지털 경제를 이해하는 데 필수적이다.

비트코인 일러스트

블록체인 개요

블록체인은 데이터를 블록 단위로 묶어 연결된 분산형 장부이다. 이 블록들은 각각의 트랜잭션(거래) 데이터를 기록하며, 각 블록은 이전 블록과 암호학적으로 연결되어 있어 체인을 형성한다. 블록체인의 핵심은 신뢰성과 투명성을 보장하는 기술이다.

주요특징

분산형 네트워크
블록체인은 중앙 서버가 없이, 네트워크에 참여하는 여러 노드(컴퓨터)가 동일한 원장(거래 내역)을 보관한다. 이로 인해 중앙 권한의 중개자 없이도 신뢰할 수 있는 시스템 구현한다.
투명성
모든 트랜잭션은 블록체인에 기록되어 네트워크 참여자들이 언제든지 검증이 가능하다. 이로 인해 트랜잭션은 변경 불가능하고 공개적으로 유지된다.
변경 불가성(불변성)
한 번 기록된 데이터는 수정하거나 삭제 불가능. 블록체인은 암호학적으로 각 블록이 연결되어 있어, 데이터를 변경하려면 체인의 모든 블록을 수정해야 하므로 사실상 불가능하다.
보안성
각 트랜잭션은 암호화되어 저장되며, 여러 노드가 참여하는 합의 알고리즘을 통해 신뢰를 확보한다. 이를 통해 부정한 트랜잭션이 네트워크에 기록되는 것을 방지한다.
합의 알고리즘
블록체인 네트워크는 작업증명(Proof of Work, PoW)*, 지분증명(Proof of Stake, PoS)** 등 다양한 합의 알고리즘을 통해 트랜잭션을 검증하고 블록을 생성한다 이를 통해 중앙 관리자 없이도 트랜잭션의 유효성을 보장한다.

작업증명 (Proof of Work, PoW)*

블록체인 네트워크에서 새로운 블록을 추가하기 위해 복잡한 수학 문제를 해결하는 방식이다. 이 문제를 해결하는 과정은 채굴(mining)이라고 하며, 이를 통해 네트워크의 보안을 유지하고 트랜잭션을 검증한다.

지분증명(Proof of Stake, PoS)**
블록체인 네트워크에서 새로운 블록을 생성하기 위해 참여자의 지분(즉, 보유한 암호화폐의 양)이나 지분의 기간을 기준으로 블록 생성 권한을 부여하는 방식이다.

활용사례

암호화폐
비트코인, 이더리움 같은 암호화폐에서 안전한 거래를 보장하는데 사용
공급망 관리
제품의 이동 경로를 추적하고, 그 정보를 투명하게 관리하는 데 블록체인이 사용
디지털 신원
개인의 신원 정보 관리 및 인증에 사용
의료 기록 관리
의료 기록의 투명성, 보안성, 신뢰성을 확보하는 데 블록체인 기술이 사용

블록체인과 비트코인의 관계

비트코인은 블록체인 기술을 기반으로 만들어진 최초의 암호화폐이다.
블록체인은 비트코인 외에도 다양한 암호화폐나 응용 서비스에 사용된다. 이더리움 같은 다른 암호화폐는 블록체인 기술을 활용하여 스마트 계약, 탈중앙화 애플리케이션(DApp) 등 더 다양한 기능을 제공한다.
비트코인은 블록체인 기술의 금융적 활용에 집중하지만, 블록체인은 그 외에도 물류, 의료, 공공 서비스 등 다양한 분야에서 혁신적인 역할을 할 수 있다.

비트코인은 블록체인 기술의 대표적인 적용 사례이며, 블록체인은 금융을 넘어 다양한 산업에서 투명성과 보안성을 제공하는 기술로 주목받고 있다.

[DB] PostgreSQL 정리

pongic — Mon, 9 Sep 2024 23:55:31 +0900

PostgreSQL은 오픈 소스 관계형 데이터베이스 관리 시스템(RDBMS)으로, 다양한 기능과 확장성을 갖춘 데이터베이스

해당 데이터베이스는 신뢰성, 데이터 무결성, 표준 SQL 준수 등의 측면에서 강력한 성능을 자랑하며, 전 세계에서 가장 많은 개발자와 기업이 사용

특징

오픈 소스
PostgreSQL은 자유롭게 사용할 수 있는 오픈 소스 소프트웨어로, 누구나 코드에 접근 및 수정 가능
ACID 준수
PostgreSQL은 트랜잭션에서 Atomicity, Consistency, Isolation, Durability를 준수하여 데이터의 일관성과 신뢰성 보장
표준 SQL 준수
PostgreSQL은 ANSI SQL 표준을 따르며, 표준 SQL 기능을 거의 완벽하게 지원
확장성
함수, 데이터 타입, 연산자 등을 확장할 수 있어 다양한 요구사항에 맞게 데이터베이스 기능 확장 가능
다양한 데이터 타입
기본적인 정수, 실수, 문자열, 날짜/시간 등의 데이터 타입 외에도 JSON, Hstore(키-값 저장), XML 등 비정형 데이터 저장 가능
복잡한 쿼리 지원
하위 쿼리, 복잡한 조인, CTE(Common Table Expression) 등 고급 SQL 쿼리 기능 지원
트리거*와 저장 프로시저**
데이터를 처리하기 전후에 자동으로 실행되는 트리거와 저장 프로시저를 지원하여, 데이터 처리 로직을 서버 측에서 관리 가능

트리거(Trigger)*
데이터베이스에서 특정 이벤트가 발생할 때 자동으로 실행되는 저장된 절차 트리거는 주로 INSERT, UPDATE, DELETE 등의 작업이 수행될 때 데이터 무결성을 유지하거나 자동으로 추가적인 작업을 처리하기 위해 사용

프로시저(Procedure)**

데이터베이스에서 미리 컴파일되어 저장된 SQL 문의 집합으로, 특정 작업이나 기능을 수행하기 위해 작성된 프로그램

주요 기능

MVCC(다중 버전 동시성 제어)
트랜잭션의 격리성과 동시성을 보장 및 데이터의 일관성을 유지하기 위한 기술로, 동시에 여러 사용자가 데이터를 읽고 쓰기 가능
복제 및 클러스터링
PostgreSQL은 스트리밍 복제를 통해 데이터를 여러 서버에 실시간으로 복제하여 데이터 안정성과 확장성을 높임
파티셔닝
큰 테이블을 여러 개의 작은 테이블로 나누어 관리하는 파티셔닝 기능을 통해 성능 최적화
JSON 및 NoSQL 기능
PostgreSQL은 JSON 형식의 데이터를 저장하고 쿼리 할 수 있어, 관계형 데이터베이스와 NoSQL* 데이터베이스의 장점을 결합한 하이브리드 환경 지원
전문 검색
텍스트 검색을 위한 Full-Text Search 기능을 제공해, 문서 내 검색을 효율적으로 수행 가능

NoSQL*
전통적인 관계형 데이터베이스(RDBMS)와 달리, 고정된 스키마 없이 데이터를 저장하고 관리하는 비관계형 데이터베이스 시스템 주로 대용량의 비정형 또는 반정형 데이터를 처리하고, 확장성을 중시하는 시스템에서 사용 현대의 데이터 관리 환경에서 많이 채택되고 있음

사용 사례

웹 애플리케이션 데이터베이스
많은 웹 애플리케이션에서 기본적인 데이터 저장소로 PostgreSQL을 사용
분석 및 데이터 웨어하우스
대량의 데이터를 저장하고 처리하는 데이터 웨어하우스 및 분석 시스템에서 사용
GIS(지리 정보 시스템)
PostgreSQL은 PostGIS* 라는 확장을 통해 지리적 데이터 처리 가능 이는 위치 기반 서비스, 지도 데이터 관리 등에 사용

PostGIS*
PostgreSQL 데이터베이스에 지리 정보 시스템(GIS) 기능을 추가하는 확장 기능 위치 기반 데이터를 저장하고 관리하며, 공간 쿼리 및 분석을 수행 가능하게 해 줌

장점

성능 최적화
네트워크 트래픽 감소 및 실행 속도 향상
캡슐화
복잡한 로직을 프로시저 내에 감춰 응용 프로그램 코드를 단순화
보안 강화
사용자에게 직접 테이블 접근 권한을 부여하지 않고도 데이터 조작 가능

단점

이식성 제한
데이터베이스 벤더마다 프로시저 작성 방식이 달라 이식성이 낮을 수 있음.
디버깅 어려움
서버 측에서 실행되므로 디버깅이 복잡할 수 있음.
과도한 서버 부하
로직이 복잡해질수록 데이터베이스 서버에 부하가 증가할 수 있음.

참고할만한 사이트

https://bigdown.tistory.com/983

[Spring] AllArgsConstructor, NoArgsConstructor

pongic — Wed, 7 Dec 2022 21:06:26 +0900

@NoArgsConstructor	파라미터가 없는 기본 생성자를 생성
@AllArgsConstructor	모든 필드 값을 파라미터로 받는 생성자를 만듦

@NoArgsConstructor
@AllArgsConstructor
public class User {

  private Long id;
  
  @NonNull
  private String name;
  
  @NonNull
  private String pw;
  
  private int age;

User user1 = new User(); // @NoArgsConstructor
User user3 = new User(1L, "user3", "1234", null); // @AllArgsConstructor

[Spring API 계층] DTO(Data Transfer Object)

pongic — Wed, 7 Dec 2022 21:04:19 +0900

DTO란?

데이터를 전송하기 위한 용도의 객체 정도로 생각

클라이언트에서 서버 쪽으로 전송하는 요청 데이터,

서버에서 클라이언트 쪽으로 전송하는 응답 데이터의 형식으로 데이터 전송이 이루어진다.

이 구간에서 DTO를 사용

DTO 클래스가 요청 데이터를 하나의 객체로 전달 받는 역할을 해준다

@RestController
@RequestMapping("/v1/members")
public class MemberController {
    @PostMapping
    public ResponseEntity postMember(MemberDto memberDto) {
        return new ResponseEntity<MemberDto>(memberDto, HttpStatus.CREATED);
    }

		...
		...
}

DTO 클래스를 사용하면 유효성 검증 로직을 DTO 클래스로 빼내어 핸들러 메서드의 간결함을 유지

@PostMapping
    public ResponseEntity postMember(@RequestBody MemberPostDto memberPostDto) {
        return new ResponseEntity<>(memberPostDto, HttpStatus.CREATED);
    }

@RequestBody

JSON 형식의 Request Body를 MemberPostDto 클래스의 객체로 변환 시켜주는 역할

[Spring] Spring Framework 개념 및 정리

pongic — Mon, 17 Oct 2022 14:57:31 +0900

Spring Framework이란?

자바 플랫폼을 위한 오픈소스 애플리케이션 프레임워크로서 엔터프라이즈급 애플리케이션을 개발하기 위한 모든 기능을 종합적으로 제공하는 경량화된 솔루션이다.

Spirng Framework는 컨테이너로 자바 객체를 담고 직접 관리한다.

Java 기반의 웹 애플리케이션 개발을 위한 Framework에 Spring Framework만 있는 것은 아니다.

Apache Struts2나 Apache Wicket, JSF(Java Server Faces), Grails 같은 Java 또는 JVM 기반의 Web Framework들이 존재하며, 현재도 꾸준히 그 기능들이 업데이트되고 있다.

자주 사용하는 이유는 대부분의 기업들이 기업용 엔터프라이즈 시스템용 애플리케이션 개발에 있어 Framework을 선택할 때, 개발 생산성을 높이고 어떻게 하면 애플리케이션의 유지 보수를 조금 더 용이하게 할 것인가에 많은 초점을 맞추기 때문에 Spring Framework를 사용한다.

Spring Framework 장점

POJO(Plan Old Java Object) 기반의 구성
DI(Dependency Injection) 지원
AOP(Aspect Oriented Programming) 지원
Java 언어를 사용함으로써 얻는 장점

Spring Framework는 POJO 프로그래밍을 지향하기 위해 IoC/DI, AOP, PSA라는 기술을 제공한다.

POJO

Java로 생성하는 순수한 객체를 의미한다.

POJO 프로그래밍으로 불리기 위한 규칙

Java나 Java의 스펙에 정의된 것 이외에는 다른 기술이나 규약에 얽매이지 않아야 한다.
특정 환경에 종속적이지 않아야 한다.

POJO 프로그래밍이 필요한 이유

재사용이 가능하고 확장 가능한 유연한 코드를 작성할 수 있다.
코드가 깔끔해진다.
디버깅하기도 상대적으로 쉽다.
테스트 역시 단순해진다.
객체지향적인 설계를 제한 없이 적용할 수 있다.

IoC(Inversion of Control)

애플리케이션 흐름의 주도권이 뒤바뀐 것을 의미한다.

메서드나 객체의 호출 작업을 개발자가 결정하는 것이 아니라 외부에서 결정되는 것을 의미한다.

이러한 IoC의 개념이 적용되어 있는 것이 DI이다.

DI(Dependency Injection)

DI는 IoC 개념을 조금 구체화시킨 것이라고 볼 수 있다.

의존성 주입이라는 의미이며 객체를 직접 생성하는 것이 아닌 외부에서 생성한 후 주입시켜주는 방식이다.

객체 간의 관계를 느슨하게 해 준다. 클래스 내부에서 다른 클래스의 객체를 생성하게 되면 두 클래스 간에 의존 관계가 성립하게 된다. 클래스 내부에서 new를 사용해 객체를 직접 생성하지 않고 생성자 등을 통해 외부에서 다른 클래스의 객체를 전달받고 있다면 의존성 주입이 이루어지고 있는 것이다.

AOP(Aspect Oriented Programming)

관점 지향 프로그래밍이라고 불린다. 어떤 로직을 기준으로 핵심적인 관점, 부가적인 관점으로 나누어서 보고 그 관점을 기준으로 각각 모듈화 하겠다는 것이다.

예를 들어 핵심 관심 사항에는 커피 메뉴를 구성하기 위해 커피 종류를 등록하는 것과 고객이 커피를 주문하는 기능이고 커피 주문 애플리케이션에 아무나 접속하지 못하도록 제한하는 애플리케이션 보안에 대한 부분은 애플리케이션 전반에 공통적으로 적용되는 기능이기 때문에 공통 관심 사항에 해당된다.

AOP는 다시 말해 애플리케이션의 핵심 업무 로직에서 로깅이나 보안, 트랜잭션 같은 공통 기능 로직들을 분리하는 것이다.

[Java] Getter, Setter 메서드 정리

pongic — Tue, 11 Oct 2022 19:28:41 +0900

Getter, Setter 사용 이유

자바에서는 데이터 보호와 은닉을 위한 효과적인 방법으로 접근 제어자를 사용한다.

객체지향의 캡슐화의 목적을 달성하면서도 데이터의 변경이 필요한 경우는 getter와 setter 메서드를 사용한다.

대표적으로 private 접근제어자가 포함되어 있는 객체의 변수의 데이터 값을 추가하거나 수정하고 싶을 때 사용

코드 예시

public class GetterSetterTest {
    public static void main(String[] args) {
        Worker w = new Worker();
        w.setName("김코딩");
        w.setAge(30);
        w.setId(5);

        String name = w.getName();
        System.out.println("근로자의 이름은 " + name);
        int age = w.getAge();
        System.out.println("근로자의 나이는 " + age);
        int id = w.getId();
        System.out.println("근로자의 ID는 " + id);
    }
}

class Worker {
    private String name; // 변수의 은닉화. 외부로부터 접근 불가
    private int age;
    private int id;

    public String getName() { // 멤버변수의 값 
        return name;
    }

    public void setName(String name) { // 멤버변수의 값 변경
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age < 1) return;
        this.age = age;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }
}

/* 출력값
근로자의 이름은 김코딩
근로자의 나이는 30
근로자의 ID는 5
*/

Setter 메서드

외부에서 메서드에 접근하여 조건에 맞을 경우 데이터 값을 변경 가능하게 해 준다.

일반적으로 메서드명에 set- 을 붙여서 사용한다.

Getter 메서드

설정한 변수 값을 읽어오는 데 사용하는 메서드이다.

Setter와 Getter 메서드를 활용하면 데이터를 효과적으로 보호하면서도 의도하는 값으로 값을 변경하여 캡슐화를 보다 효과적으로 달성할 수 있다.

[Network] REST API 개념 및 성숙도 모델

pongic — Mon, 10 Oct 2022 18:03:07 +0900

REST API란?

REST API는 웹에서 사용되는 데이터나 자원(Resource)을 HTTP URI로 표현하고, HTTP 프로토콜을 통해 요청과 응답을 정의하는 방식을 말한다. 여기서 REST는 Representational State Transfer의 약자로 로이 필딩의 박사학위 논문에서 웹(HTTP)의 장점을 최대한 활용할 수 있는 아키텍처로써 처음 소개되었다.

REST API 성숙도 모델

REST 성숙도 모델은 총 4단계로 나누어진다. 그러나 실제로 엄밀하게 3단계까지 지키기 어렵기 때문에 2단계까지만 적용해도 좋은 API디자인이라고 볼 수 있고, 이런 경우 HTTP API라고도 부른다.

성숙도 모델 0단계

단순히 HTTP 프로토콜을 사용하기만 해도 된다. 하지만 해당 API를 REST API라고 할 수는 없으며 좋은 REST API를 작성하기 위한 기본 단계

성숙도 모델 1단계

개별 리소스와의 통신을 준수해야 한다. 모든 자원은 개별 리소스에 맞는 엔드포인트(Endpoint)를 사용해야 한다는 것과 요청하고 받은 자원에 대한 정보를 응답으로 전달해야 한다.

예약 가능한 시간 확인이라는 요청의 응답으로 받게 되는 자원(Resource)은 허준이라는 의사의 예약 가능한 시간대이다.

그렇기 때문에 요청 시 엔드포인트를 사용하였다.

특정 시간에 예약하게 되면 실제 slot이라는 자원(Resource)의 123이라는 id를 가진 자원(Resource)이 변경되기 때문에 하단의 특정 시간에 예약이라는 요청에는/slot/123으로 실제 변경되는 자원(Resource)을 엔드포인트로 사용하였다.

엔드포인트 작성 시에는 동사, HTTP 메서드, 혹은 어떤 행위에 대한 단어 사용은 지양하고, 명사 형태의 단어로 작성하는 것이 바람직하다.

요청을 하였을 때 해당 시간이 마감되어 예약이 불가능한 경우를 가정하면 아래와 같이 응답을 받아야 한다.

성숙도 모델 2단계

CRUD에 맞게 적절한 HTTP 메서드를 사용하는 것에 중점을 둔다.

예약 가능한 시간을 확인하는 것은 조회(READ)하는 행위를 의미하고 특정 시간에 예약한다는 것은 예약을 생성(CREATE)한다는 것과 같다. 조회(READ) 하기 위해서는 GET 메서드를 사용하여 요청을 보내고, GET 메서드는 body를 가지지 않기 때문에 query parameter를 사용하여 자원(Resource)을 전달한다.

예약을 생성(CREATE) 하기 위해서는 POST 메서드를 사용하여 요청을 보낸다. 이 경우 응답 코드도 201 Created로 명확하게 작성해야 한다.

HTTP 메서드

GET	서버의 데이터를 변화시키지 않는 요청에 사용하고 지정된 리소스의 표현을 요청한다.
POST	요청마다 새로운 리소스를 생성한다. 데이터 등록에 사용
PUT	요청마다 같은 리소스를 반환한다. 데이터 교체에 주로 사용, 멱등성을 가지는 특징이 있다.
PATCH	리소스의 부분 수정의 용도로 사용한다.
DELETE	지정된 리소스를 삭제한다.
HEAD	GET 요청과 동일한 응답을 요청하지만 응답에 body는 없다.
OPTIONS	대상 리소스에 대한 통신 옵션
CONNECT	대상 리소스로 식별되는 서버에 대한 터널을 설정한다.
TRACE	대상 리소스에 대한 경로를 따라 메시지 루프백(Loopback) 테스트를 수행한다.

성숙도 모델 3단계

마지막 단계는 HATEOAS(Hypertext As The Engine Of Application State)라는 약어로 표현되는 하이퍼미디어 컨트롤을 적용한다. 3단계 요청은 2단계와 동일하지만 응답에 자원(Resource)의 URI를 포함한 링크 요소를 삽입하여 작성한다.

허준이라는 의사의 예약 가능 시간을 확인 후 그 시간대에 예약을 할 수 있는 링크를 삽입하거나 특정 시간에 예약을 완료하고 나서는 그 예약을 다시 확인할 수 있도록 링크를 작성해 넣을 수도 있다.

[Java / 자료구조] Deque 개념 및 정리

pongic — Mon, 10 Oct 2022 17:14:11 +0900

Deque 정의

Deque는 Double Ended Queue의 양방향 대기열이라고도 불리는 자료구조이다.

양방향으로 열려있는 구조로 Queue와 외형적으로 비슷한 구조이다. 그러나 Deque는 Stack과 Queue와 달리 LIFO, FIFO와 같은 순서에 구속되지 않는다.

Deque 특징

Stack 및 Queue를 모두 사용할 수 있다.

Deque는 양쪽으로 데이터를 추가하고 삭제할 수 있어서 Stack과 Queue를 구현할 수 있다. 추가와 삭제를 양쪽에서 제어할 수 있어서 여러 형태로 사용할 수 있다.

추가를 제한하는 구조

한쪽에서만 데이터 추가가 가능하고 삭제는 양방향에서 가능하게 구현한다면 아래와 같은 구조

데이터 추가의 방향이 정해진 상태가 된다. 왼쪽으로 삭제하는 형태는 Stack과 같고 오른쪽으로 삭제하는 형태는 Queue와 같다.

삭제를 제한하는 구조

데이터 추가는 양쪽에서 가능하지만, 삭제는 한 방향에서만 가능하게 구현한다면 아래와 같은 구조

왼쪽에서 추가하는 형태는 Stack과 같고 오른쪽에서 추가하는 형태는 Queue와 같다.

양방향 끝에서 데이터 추가, 삭제가 용이하다.

Stack과 Queue에서 추가할 데이터나 삭제할 데이터의 인덱스 정보를 가지고 있듯이 Deque도 양쪽의 추가 삭제할 데이터의 인덱스 정보를 가지고 있어서 양쪽 끝의 데이터에 접근과 추가, 삭제가 용이하다.

양방향 끝이 아닌 임의 데이터만 추가하거나 삭제하는 건 불가능하다.

Deque는 양방향 끝의 인덱스 정보를 가지고 있다. 따라서 양방향의 데이터가 아닌 중간에 있는 데이터에 접근하려고 하면 인덱스 정보가 없어서 접근할 수 없다.

Deque 선언

Deque<Integer> deque = new LinkedList<>();
Deque<Integer> deque = new ArrayDeque<>();

Deque를 선언할 때 보통 LinkedList와 ArrayDeque를 사용한다.

Deque 값 삽입

add()	마지막에 원소를 삽입한다. 용량 초과 시 예외(Exception)가 발생한다.
addFirst()	맨 앞에 원소를 삽입한다. 용량 초과 시 예외(Exception)가 발생한다.
addLast()	마지막에 원소를 삽입한다. 용량 초과 시 예외(Exception)가 발생한다.
offer()	마지막에 원소를 삽입한다. 삽입 성공 시 true, 용량 제한에 걸리는 경우 false를 리턴한다.
offerFirst()	맨 앞에 원소를 삽입한다. 삽입 성공 시 true, 용량 제한에 걸리는 경우 false를 리턴한다.
offerLast()	마지막에 원소를 삽입한다. 삽입 성공 시 true, 용량 제한에 걸리는 경우 false를 리턴한다.

Deque 값 삭제

remove()	맨 앞의 원소 제거 후 해당 원소를 리턴한다. 덱이 비어있는 경우 예외(Exception)가 발생한다.
removeFirst()	맨 앞의 원소 제거 후 해당 원소를 리턴한다. 덱이 비어있는 경우 예외(Exception)가 발생한다.
removeLast()	마지막 원소 제거 후 해당 원소를 리턴한다.덱이 비어있는 경우 예외(Exception)가 발생한다.
poll	맨 앞의 원소 제거 후 해당 원소를 리턴한다. 덱이 비어있는 경우 null 리턴
pollFirst()	맨 앞의 원소 제거 후 해당 원소를 리턴한다. 덱이 비어있는 경우 null 리턴
pollLast()	마지막 원소 제거 후 해당 원소를 리턴한다. 덱이 비어있는 경우 null 리턴

Deque 값 확인

getFirst()	맨 앞의 원소를 리턴한다. 덱이 비어있는 경우 예외(Exception)가 발생한다.
getLast()	마지막 원소를 리턴한다. 덱이 비어있는 경우 예외(Exception)가 발생한다.
peek()	맨 앞의 원소를 리턴한다. 덱이 비어있는 경우 null 리턴
peekFirst()	맨 앞의 원소를 리턴한다. 덱이 비어있는 경우 null 리턴
peekLast()	마지막 원소를 리턴한다 .덱이 비어있는 경우 null 리턴

추가적인 메서드 확인하려면 아래 사이트를 참고

https://www.geeksforgeeks.org/deque-interface-java-example/

Deque interface in Java with Example - GeeksforGeeks

A Computer Science portal for geeks. It contains well written, well thought and well explained computer science and programming articles, quizzes and practice/competitive programming/company interview Questions.

www.geeksforgeeks.org

[DB] 데이터베이스 정규화 (1NF, 2NF, 3NF) 개념 및 정리

pongic — Sun, 9 Oct 2022 17:03:55 +0900

정규화 (Normalization)

데이터베이스의 설계를 재구성하는 기술이다. 정규화를 통해 불필요한 데이터를 없앨 수 있고 삽입, 삭제, 갱신 시 발생할 수 있는 각종 이상현상들을 방지할 수 있다.

이상현상

갱신 이상 (Update anomaly)
삽입 이상 (Insertion anomaly)
삭제 이상 (Deletion anomaly)

갱신 이상

동일한 데이터가 여러 행에 걸쳐 있을 때에 어느 데이터를 갱신해야 하는지에 대한 논리적 일관성이 없어 발생

다음과 같이 두 개의 레코드가 동일한 사람일 때 (519번) 갱신을 하는 경우 어떤 데이터를 해야 하는지에 대한 문제가 발생

삽입 이상

데이터 삽입을 못하는 경우

Dr.Newsome이 아직 가르칠 수업이 정해지지 않은 경우에는 데이터를 추가하지 못하는 상황이 발생한다. 수업을 NULL와 같은 값으로 지정하지 않는 이상 데이터를 추가할 수 없다.

삭제 이상

데이터의 특정 부분을 지울 때 의도치 않게 다른 부분들도 함께 지워지는 현상

한 직원 데이터의 수업 관련 데이터를 지우기 위해서는 레코드 전체가 사라져 결국에는 의도치 않게 직원의 다른 데이터들도 같이 삭제되는 현상이 발생한다.

정규화 과정

제 1정규화 (1NF)

테이블의 칼럼이 원자 값(하나의 값)을 갖도록 테이블을 분해하는 것이다.

현재 테이블은 속성 하나는 하나의 속성값만을 가져야 한다는 1차 정규형에 위배된다.

제 1정규화를 거치면 아래와 같다.

제 2정규화 (2NF)

제 1정규화를 진행한 테이블에 대해 완전 함수 종속을 만족하도록 테이블을 분해하는 것이다. 완전 함수 종속이라는 것은 기본키의 부분집합이 결정자가 되어선 안된다는 것을 의미한다.

이 테이블에서 기본키는 (학번, 수업)으로 복합키이다. 그리고 (학번, 수업)인 기본키는 성적을 결정하고 있다.

강의실이라는 컬럼은 기본키의 부분집합인 수업에 의해 결정될 수 있다.

즉, 기본키(학번, 수업)의 부분키인 수업이 결정자이기 때문에 위의 테이블은 아래와 같이 분해하여 별도의 테이블로 관리하여 제 2정규화를 만족시킬 수 있다.

제 3정규화 (3NF)

제 2정규화를 진행한 테이블에 대해 이행적 종속을 없애도록 테이블을 분해하는 것이다. 이행적 종속이라는 것은

A -> B, B -> C 가 성립할 때 A -> C 가 성립되는 것을 의미한다.

기존의 테이블에서 학번이 수업을 결정하고 있고 수업은 강의실을 결정하고 있다. 그렇기 때문에 아래와 같이 테이블을 분해해야 한다.

BCNF 정규화

제 3정규화를 진행한 테이블에 대해 모든 결정자가 후보키가 되도록 테이블을 분해하는 것이다.

특강 수강 테이블에서 기본키는 (학생 번호, 특강 이름)이다. 그리고 기본키는 교수를 결정하고 있는데 또한 여기서 교수는 특강 이름을 결정하고 있다.

하지만 문제는 교수가 특강이름을 결정하는 결정자이지만 후보키가 아니라는 것이다. 그래서 BCNF 정규화를 만족시키기 위해서 테이블을 아래와 같이 분해한다.

참고할만한 사이트

https://www.w3schools.in/dbms/database-normalization

Database Normalization

Database normalization is a database schema design technique, by which an existing schema is modified to minimize redundancy and dependency of data. Normalization split a large table into smaller tables and define relationships between them to increases th

www.w3schools.in

https://www.guru99.com/database-normalization.html

What is Normalization in DBMS (SQL)? 1NF, 2NF, 3NF Example

Normalization in Database 1NF, 2NF, 3NF, BCNF, 4NF, 5NF, 6NF. Normalization is a database design technique which organizes tables in a manner that reduces redundancy and dependency of data.

www.guru99.com

[DB] MySQL DDL, DML, DCL 등 명령어

pongic — Fri, 7 Oct 2022 16:39:02 +0900

SQL 문법 종류

Data Definition Language(DDL)
Data Manipulation Language(DML)
Data Control Language(DCL)
Data Query Language(DQL)
Transaction Control Language(TCL)

Data Definition Language(DDL)

DDL은 데이터를 정의할 때 사용하는 언어이다. 테이블을 만들 때 사용하는 CREATE, 테이블을 제거할 때 사용되는 DROP 등이 해당된다. 데이터베이스의 테이블과 같은 오브젝트를 정의할 때 사용한다.

CREATE : 테이블을 생성하거나 데이터베이스를 생성하는 명령어

// 데이터베이스 생성
CREATE DATABASE [데이터베이스명];

// 테이블 생성
CREATE TABLE [테이블명];

CREATE TABLE users (
  id INT PRIMARY KEY AUTO_INCREMENT,
  username varchar(50),
  password varchar(50)
);

DROP : 생성한 테이블이나 데이터베이스를 삭제하는 명령어

// 데이터베이스 삭제
DROP DATABASE [데이터베이스명];

// 테이블 삭제
DROP TABLE [테이블명];

TRUNCATE : 생성한 테이블에서 데이터를 삭제하는 명령어

TRUNCATE TABLE [테이블명];

ALTER : 생성한 테이블에서 구조를 변경하는 명령어

// COLUMN 추가
ALTER TABLE [테이블명] ADD [컬럼명] [데이터타입];

// COLUMN 삭제
ALTER TABLE [테이블명] DROP [삭제할컬럼명];

// COLUMN 타입 수정
ALTER TABLE [테이블명] MODIFY [변경할컬럼] [변경할타입];

// COLUMN 이름 변경
ALTER TABLE [테이블명] CHANGE [기존칼럼명] [변경할컬럼명];

// COLUMN 테이블명 변경
ALTER TABLE [기존테이블명] RENAME [변경할테이블명];

Data Manipulation Language(DML)

DML은 데이터베이스에 데이터를 저장할 때 사용하는 언어이다. INSERT 처럼 새로운 레코드를 추가할 때, 데이터를 삭제하는 DELETE, 변경하는 UPDATE가 포함된다.

SELECT : 데이터 조회하는 명령어

// 테이블 내 모든 데이터 조회
SELECT * FROM [테이블명];

// 특정 컬럼 지정 조회
SELECT [컬럼명] FROM [테이블명];

// 조건 조회
SELECT [컬럼명] FROM [테이블명] WHERE [조건];

INSERT : 데이터 삽입하는 명령어

//모든 컬럼에 데이터 입력하는 경우
INSERT INTO [테이블명] VALUES([값1], [값2], ...);

//특정 컬럼을 지정해서 데이터 입력하는 경우
INSERT INTO [테이블명]([컬럼명1], [컬럼명2], ...) VALUES([값1], [값2], ...);
INSERT INTO [테이블명] SET [컬럼명]=[값], ...;

UPDATE : 데이터를 수정하는 명령어

UPDATE [테이블명] SET [컬럼명] = [값] ... WHERE [조건];

Data Control Language(DCL)

DCL은 데이터베이스에 대한 접근 권한과 관련된 문법이다. 어느 유저가 데이터베이스에 접근할 수 있는지 권한을 설정한다. 권한을 주는 GRANT나 권한을 가져가는 REVOKE등이 포함된다.

GRANT : 권한 설정하는 명령어

// 사용자 권한 부여
GRANT [권한종류] ON [대상] TO [계정명] IDENTIFIED BY [암호] [WITH GRANT OPTION];

// EX. 모든 권한을 가진 계정 생성
GRANT ALL ON *.* TO test@localhost IDENTIFIED BY "test1";

// GRANT로 계정생성 후 아래의 명령어를 실행해야 적용된다.
FLUSH PRIVILEGES;

REVOKE : 권한 삭제하는 명령어

// 권한 해제 명령어
REVOKE INSERT, UPDATE, CREATE ON [DB명,테이블명] TO [user@host];

// 전체 권한 해제 명령어
REVOKE ALL ON [DB명,테이블명] TO [user@host];

COMMIT : 작업한 결과를 물리적 디스크로 저장하고, 조작 작업이 완료됨을 사용자에게 알려주는 명령어

COMMIT;

ROLLBACK : 작업했던 내용을 원래의 상태로 복구하기 위한 명령어, COMMIT 하기 이전의 상태만 ROLLBACK 가능

ROLLBACK;

[DB] 데이터베이스 관계 (1:1, 1:N, N:M) 정리

pongic — Thu, 6 Oct 2022 21:14:32 +0900

관계형 데이터베이스 키워드 정리

데이터 : 각 항목에 저장되는 값
테이블(table or relation) : 사전에 정의된 열의 데이터 타입대로 작성된 데이터가 행으로 축적된다.
칼럼(column or field) : 테이블의 한 열을 가리킨다.
레코드(record or tuple) : 테이블의 한 행에 저장된 데이터이다.
키(key) : 테이블의 각 레코드를 구분할 수 있는 값이다. 각 레코드마다 고유한 값을 가진다. 기본키(Primary Key)와 외래키(Foreign Key)등이 있다.

1 : 1 관계

하나의 레코드가 다른 테이블의 레코드 한 개와 연결된 경우이다.
각 전화번호가 단 한 명의 유저와 연결되어 있고, 그 반대도 동일하다면 1:1 관계이다.
1:1 관계는 자주 사용하지 않는다.
1:1로 나타낼 수 있는 관계라면 User 테이블에 phone_id를 대신해 phone_number를 직접 저장하는 것이 나을 수 있다.

1 : N 관계

하나의 레코드가 서로 다른 여러 개의 레코드와 연결된 경우이다.
한 명의 유저가 여러 전화번호를 가질 수 있다.
여러 명의 유저가 하나의 전화번호를 가질 수는 없다.
1:N 관계는 관계형 데이터베이스에서 가장 많이 사용한다.

N : M 관계

여러 개의 레코드가 다른 테이블의 여러 개의 레코드와 관계가 있는 경우이다.
N:M 관계를 위해 스키마를 디자인할 때에는 Join 테이블을 만들어 관리한다.
1:N 관계와 비슷하지만, 양방향에서 다수의 레코드를 가질 수 있다.

customer_package 테이블에서는 고객 한 명이 여러 개의 여행 상품을 가질 수 있고. 여행 상품 하나가 여러 개의 고객을 가질 수 있다.
customer_package 테이블은 customer_id와 package_id를 묶어주는 역할이다.
customer_package 테이블을 통해 어떤 고객이 몇 개의 여행 상품을 구매했는지 또는 어떤 여행 상품이 몇 명의 고객을 가지고 있는지 등을 확인할 수 있다.
조인 테이블을 생성하더라도, 조인 테이블을 위한 기본키(cp_id)는 반드시 있어야 한다.

자기 참조 관계

테이블 내에서 관계가 필요할 때
추천인이 누구인지 파악하기 위해 사용한다.
한 명의 유저는 한 명의 추천인을 가질 수 있다. 그러나 여러 명이 한 명의 유저를 추천인으로 등록할 수 있다.
1:N 관계와 유사하다고 생각할 수 있지만 일반적으로 1:N 관계는 서로 다른 테이블의 관계를 나타낼 때 표현하는 방법이다.

[DB] SQL (Structured Query Language)과 NoSQL 개념 및 정리

pongic — Wed, 5 Oct 2022 17:47:36 +0900

SQL이란?

데이터베이스 언어로 주로 관계형 데이터베이스에서 사용한다. 예를 들어 MySQL, Oracle, SQLite, PostgreSQL 등 다양한 데이터베이스에서 SQL 구문을 사용할 수 있다.

일반적인 프로그래밍 언어와 달리 대화식 언어이기 때문에 명령문이 짧고 간결하다.

SQL은 데이터베이스 용 프로그래밍 언어이다. 데이터베이스에 쿼리를 보내 원하는 데이터를 가져오거나 삽입할 수 있다.

쿼리(query)는 질의문이라는 뜻을 가지고 있다. 쿼리는 저장되어 있는 데이터를 필터 하기 위한 질의문이라고 볼 수 있다.

그리고 SQL은 데이터가 구조화된 테이블을 사용하는 데이터베이스에서 활용할 수 있다. 다시 말해 SQL을 사용하기 위해서는 데이터 구조가 고정되어 있어야 한다.

ACID

ACID는 데이터베이스 내에서 일어나는 하나의 트랜잭션(transaction)의 안전성을 보장하기 위해 필요한 성질이다.

Atomicity(원자성) : 하나의 트랜잭션에 속해있는 모든 작업이 전부 성공하거나 전부 실패해서 결과를 예측할 수 있어야 한다. 하나의 단위로 묶여있는 여러 작업이 부분적으로 실행된다면 업데이트가 일어났지만 누가 업데이트했는지 모르거나 업데이트 날짜가 누락되는 등 데이터가 오염될 수 있다.
Consistency(일관성) : 데이터베이스의 상태가 일관되어야 한다. 하나의 트랜잭션 이전과 이후, 데이터베이스의 상태는 이전과 같이 유효해야 한다.
Isolation(격리성, 고립성) : 모든 트랜잭션은 다른 트랜잭션으로부터 독립되어야 한다
Durability(지속성) : 만약 런타임 오류나 시스템 오류가 발생하더라도 해당 트랜잭션에 대한 로그 즉, 해당 기록은 영구적이어야 한다.

데이터베이스 종류

관계형 데이터베이스

테이블의 구조와 데이터 타입 등을 사전에 정의하고, 테이블에 정의된 내용에 알맞은 형태의 데이터만 삽입할 수 있다.
행(row)과 열(column)로 구성된 테이블에 데이터를 저장한다. 각 행은 열의 데이터 형식에 맞는 데이터가 저장되고 각 열은 하나의 속성에 대한 정보를 저장한다.
데이터를 사용할 때 매우 수월하다.
SQL을 활용해 원하는 정보를 쿼리 할 수 있다.
테이블 간의 관계를 직관적으로 파악할 수 있다.
대표적인 관계형 데이터베이스는 MySQL, Oracle, SQLite, PostgressSQL, MariaDB 등이 있다.

비관계형 데이터베이스(NoSQL)

데이터가 고정되어 있지 않은 데이터베이스
데이터를 읽어올 때 스키마에 따라 데이터를 읽어 온다. (schema on read)
데이터를 입력하는 방식에 따라, 데이터를 읽어올 때 영향을 미친다.
대표적인 NoSQL은 몽고DB, Casandra 등이 있다.

NoSQL 구성

Key-Value 타입 : 속성을 Key-Value의 쌍으로 나타내는 데이터를 배열의 형태로 저장한다. Ex. Redis, Dynamo
문서형(Document) 데이터베이스 : 데이터를 테이블이 아닌 문서처럼 저장하는 데이터베이스를 의미한다. JSON과 유사한 형식의 데이터를 문서화하여 저장한다. 각각의 문서는 하나의 속성에 대한 데이터를 가지고 있고, 컬렉션이라고 하는 그룹으로 묶어서 관리한다. Ex. MongoDB
Wide-Column 데이터베이스 : 데이터베이스의 열(Column)에 대한 데이터를 집중적으로 관리하는 데이터베이스이다. 각 열에는 Key-Value 형식으로 데이터가 저장되고 칼럼 패밀리(column families)라고 하는 열의 집합체 단위로 데이터를 처리할 수 있다. 하나의 행에 많은 열을 포함할 수 있어서 유연성이 높다. 주로 규모가 큰 데이터 분석에 사용된다. Ex. Cassandra, HBase
그래프(Graph) 데이터베이스 : 자료구조의 그래프와 비슷한 형식으로 데이터 간의 관계를 구성하는 데이터베이스이다. 노드(nodes)에 속성별(entities)로 데이터를 저장하고 각 노드간 관계는 선(edge)으로 표현한다. Ex. Neo4J, InfiniteGraph

SQL 기반 데이터베이스 VS NoSQL 기반 데이터베이스

	SQL 기반 데이터베이스	NoSQL 기반 데이터베이스
데이터 저장(Storage)	SQL을 이용해서 데이터를 저장 정해진 형식에 맞게 데이터를 저장	key-value, document, wide-column, graph등의 방식으로 데이터를 저장
스키마(Schema)	고정된 형식의 스키마 필요 데이터 속성별로 열에 대한 정보를 미리 정해두어야 한다.	동적으로 스키마의 형태를 관리할 수 있다. 개별 속성에 대해서 모든 열에 대한 데이터를 반드시 입력X
쿼리(Querying)	테이블의 형식과 테이블간의 관계에 맞춰 요청해야한다.	데이터 그룹 자체를 조회 구조화 되지 않은 쿼리 언어로도 데이터 요청 가능
확장성(Scalability)	수직적으로 확장 CPU를 사용하는 확장 비용이 많이 들고 복잡하고 시간이 많이 소모	수평적으로 확장 많은 트래픽을 보다 편리하게 관리 상대적으로 비용 저렴

SQL 기반의 관계형 데이터베이스를 사용하는 경우

데이터베이스의 ACID 성질을 준수해야 하는 경우 : 예외적인 상황을 줄이고, 데이터베이스의 무결성을 보호해야 하는 경우 예를 들어 전자 상거래를 비롯한 모든 금융 서비스를 위한 소프트웨어 개발에서는 반드시 ACID 성질을 준수해야 한다.
소프트웨어에 사용되는 데이터가 구조적이고 일관적인 경우 : 소프트웨어의 규모가 많은 서버를 필요하지 않고 일관된 데이터를 사용하는 경우

NoSQL 기반의 비관계형 데이터베이스를 사용하는 경우

데이터의 구조가 거의 또는 전혀 없는 대용량의 데이터를 저장하는 경우 : 소프트웨어 개발에 정형화 되지 않은 많은 양의 데이터가 필요한 경우 NoSQL을 적용하는 것이 더 효율적일 수 있다.
클라우드 컴퓨팅 및 저장공간을 최대한 활용하는 경우 : 소프트웨어에 데이터베이스의 확장성이 중요하다면 별다른 번거로움 없이 확장할 수 있는 NoSQL 데이터베이스를 사용하는 것이 좋다.
빠르게 서비스를 구축하는 과정에서 데이터 구조를 자주 업데이트하는 경우 : 시장에 빠르게 프로토타입을 출시해야 하는 경우, 소프트웨어 버전별로 많은 다운타임 없이 데이터 구조를 자주 업데이트해야 하는 경우

[Network] HTTP (HyperText Transfer Protocol) 기본 개념 및 정리

pongic — Tue, 4 Oct 2022 18:54:52 +0900

HTTP (HyperText Transfer Protocol)란?

HTML과 같은 문서를 전송하기 위한 Application Layer 프로토콜이다. HTTP는 웹 브라우저와 웹 서버의 소통을 위해 디자인 되었다. 전통적인 클라이언트-서버 모델에서 클라이언트가 HTTP Messages 양식에 맞춰 요청을 보내면, 서버도 HTTP Messages 양식에 맞게 응답한다. HTTP는 특정 상태를 유지하지 않는 특징이 있다.

HTTP Messages 구조

HTTP Messages는 두 가지 유형이 있다. 요청(Requests)와 응답(Responses)

HTTP Messages는 텍스트 정보로 구성되는데 개발자는 이를 직접 작성할 필요가 거의 없다. 구성 파일, API, 기타 인터페이스에서 자동으로 완성해주기 때문이다.

start line : 요청이나 응답의 상태를 나타낸다. 항상 첫 번째 줄에 위치한다. 응답(Responses)에서는 status line이라고 부른다.
HTTP headers : 요청을 지정하거나, 메시지에 포함된 본문을 설명하는 헤더의 집합이다.
empty line : 헤더와 본문을 구분하는 줄이다.
body : 요청과 관련된 데이터나 응답과 관련된 데이터 또는 문서를 포함한다. 요청과 응답의 유형에 따라 선택적으로 사용한다.

요청(Requests)

Start line
- 수행할 작업 (GET, PUT, POST 등)이나 방식(HEAD or OPTIONS)을 설명하는 method
- 요청 대상(URL이나 URI)또는 프로토콜, 포트, 도메인의 절대 경로, 형식은 HTTP method마다 다르다.
- HTTP 버전

Headers
- Request headers : fetch를 통해 가져올 리소스나 클라이언트 자체에 대한 자세한 정보를 포함한다.
- General headers : 메시지 전체에 해당하는 헤더이다.
- Representation headers (Entity headers) : body에 담긴 리소스의 정보를 포함하는 헤더이다.

Body
- HTTP messages 구조의 마지막에 위치한다.
- 모든 요청에 body가 필요하지는 않다. GET, HEAD, DELETE, OPTIONS 처럼 서버에 리소스를 요청하는 경우에는 body가 필요하지 않다. POST, PUT과 같은 일부 요청은 데이터를 업데이트하기 위해 사용한다.
- Single-resource bodies(단일-리소스 본문) : 헤더 두 개(Content-Type, Content-Length)로 정의된 단일 파일로 구성된다.
- Multiple-resource bodies(다중-리소스 본문) : 여러 파트로 구성된 본문에서는 각 파트마다 다른 정보를 지닌다.

응답(Responses)

Status line
- 응답의 첫 줄
- 현재 프로토콜의 버전
- 상태 코드 - 요청의 결과를 나타낸다. (200, 302, 404등)
- 상태 텍스트 - 상태 코드에 대한 설명

Headers
- Response headers : 위치 또는 서버 자체에 대한 정보와 같이 응답에 대한 부가적인 정보를 갖는 헤더이다.
- General headers : 메시지 전체에 적용되는 헤더이다.
- Representation headers (Entity headers) : body에 담긴 리소스의 정보를 포함하는 헤더이다.

Body
- HTTP messages 구조의 마지막에 위치한다.
- 모든 응답에 body가 필요하지는 않다. (201, 204와 같은 상태 코드)
- Single-resource bodies(단일-리소스 본문) : 길이가 알려졌을 경우는 두 개의 헤더(Content-Type, Content-Length)로 정의하고 모를 때에는 Transfer-Encoding이 chunked로 설정되어 있으며, 파일은 chunk로 나뉘어 인코딩되어 있다.
- Multiple-resource bodies(다중-리소스 본문) : 서로 다른 정보를 담고 있는 body이다.

HTTP 메서드

GET

가장 많이 쓰이고 서버에게 리소스를 달라고 요청한다.

POST

요청 데이터 처리, 주로 데이터 등록에 사용된다.

PUT

리소스를 대체한다. 해당 리소스가 없으면 생성한다. 업데이트 하기 위해 서버로 데이터를 보내는 데 사용된다.

PATCH

리소스를 일부만 변경한다.

DELETE

리소스를 삭제한다.

HTTP 상태코드

1xx

요청이 수신되어 처리중

2xx

요청 정상 처리

4xx

클라이언트 오류, 잘못된 문법등으로 서버가 요청을 수행할 수 없다.

5xx

서버 오류, 서버가 정상 요청을 처리하지 못한다.

[알고리즘] 순열(permutation)과 조합(Combination) 정리

pongic — Mon, 3 Oct 2022 18:19:35 +0900

순열(permutation)

요소 N개 중에 M개를 선택하여 순서에 상관있게 뽑는 경우의 수

카드 뽑기

A, B, C, D, E로 이뤄진 5장의 카드

순서를 생각하며 3장을 선택할 때 경우의 수

모든 카드를 1장씩 나열하면서, 나열된 카드가 3장에 도달하면 카드의 나열을 중지한다.

첫 번째 나열하는 카드를 선택하는 방법에는 다섯 가지가 있다.
첫번째 카드를 나열하고 난 다음, 두 번째 카드를 선택하는 방법에는 네 가지가 있다.
두번째 카드를 나열하고 난 다음, 세 번째 카드를 선택하는 방법에는 세 가지가 있다.

따라서 5 X 4 X 3 = 60 가지의 방법이 있다.

이렇게 n개 중에서 일부만을 선택하여 나열하는 것을 순열이라고 한다.

순열은 순서를 지키며 나열해야 한다.

5장에서 3장을 선택하는 모든 순열의 수 = 5P3 = (5 X 4 X 3 X 2 X 1) / (2 X 1) = 60

일반식 nPr = n! / (n - r)!

코드 예제

// 반복문 코드

public static ArrayList<String[]> permutationLoop() {
  // 순열 요소가 인자로 주어질 경우, 인자 그대로 사용하면 되지만, 인자가 주어지지 않고
  // 문제 안에 포함되어 있을 경우 이런 식으로 직접 적어서 사용한다.
    String[] lookup = new String[]{"A", "B", "C", "D", "E"};
    ArrayList<String[]> result = new ArrayList<>();

    for (int i = 0; i < lookup.length; i++) {
      for (int j = 0; j < lookup.length; j++) {
        for (int k = 0; k < lookup.length; k++) {
          if (i == j || j == k || k == i) continue;
            String[] input = new String[]{lookup[i], lookup[j], lookup[k]};
            result.add(input);
        }
      }
    }
  return result;
}

/*
[
  [ 'A', 'B', 'C' ], [ 'A', 'B', 'D' ], [ 'A', 'B', 'E' ],
  [ 'A', 'C', 'B' ], [ 'A', 'C', 'D' ], [ 'A', 'C', 'E' ],
  [ 'A', 'D', 'B' ], [ 'A', 'D', 'C' ], [ 'A', 'D', 'E' ],
  [ 'A', 'E', 'B' ], [ 'A', 'E', 'C' ], [ 'A', 'E', 'D' ],
  [ 'B', 'A', 'C' ], [ 'B', 'A', 'D' ], [ 'B', 'A', 'E' ],
  [ 'B', 'C', 'A' ], [ 'B', 'C', 'D' ], [ 'B', 'C', 'E' ],
  [ 'B', 'D', 'A' ], [ 'B', 'D', 'C' ], [ 'B', 'D', 'E' ],
  [ 'B', 'E', 'A' ], [ 'B', 'E', 'C' ], [ 'B', 'E', 'D' ],
  [ 'C', 'A', 'B' ], [ 'C', 'A', 'D' ], [ 'C', 'A', 'E' ],
  [ 'C', 'B', 'A' ], [ 'C', 'B', 'D' ], [ 'C', 'B', 'E' ],
  [ 'C', 'D', 'A' ], [ 'C', 'D', 'B' ], [ 'C', 'D', 'E' ],
  [ 'C', 'E', 'A' ], [ 'C', 'E', 'B' ], [ 'C', 'E', 'D' ],
  [ 'D', 'A', 'B' ], [ 'D', 'A', 'C' ], [ 'D', 'A', 'E' ],
  [ 'D', 'B', 'A' ], [ 'D', 'B', 'C' ], [ 'D', 'B', 'E' ],
  [ 'D', 'C', 'A' ], [ 'D', 'C', 'B' ], [ 'D', 'C', 'E' ],
  [ 'D', 'E', 'A' ], [ 'D', 'E', 'B' ], [ 'D', 'E', 'C' ],
  [ 'E', 'A', 'B' ], [ 'E', 'A', 'C' ], [ 'E', 'A', 'D' ],
  [ 'E', 'B', 'A' ], [ 'E', 'B', 'C' ], [ 'E', 'B', 'D' ],
  [ 'E', 'C', 'A' ], [ 'E', 'C', 'B' ], [ 'E', 'C', 'D' ],
  [ 'E', 'D', 'A' ], [ 'E', 'D', 'B' ], [ 'E', 'D', 'C' ]
]
*/

반복문의 개수 = 요소를 뽑는 개수

5개의 요소 중 3개를 뽑는 조건 : 하나의 반복문당 5개의 요소를 순회하고 반복문을 3번 중첩하여 3개의 요소를 뽑는다.

중복된 요소는 제거

같은 인덱스를 선택하는 것은 중복된 요소를 선택한다는 것과 같다. 하지만 순열은 중복된 요소를 허용하지 않기 때문에 동일한 인덱스인지 검사한다.

조합(Combination)

순서에 상관없이 요소 N개 중에 M개를 뽑는 경우의 수

카드 뽑기

A, B, C, D, E로 이뤄진 5장의 카드

순서를 생각하지 않고 3장을 선택할 때의 모든 경우의 수

모든 경우의 수를 구할 때는 3장을 하나의 그룹으로 선택해야 한다.

순열로 구할 수 있는 경우를 찾는다.
순열로 구할 수 있는 경우에서 중복된 경우의 수를 나눈다.

순열에서는 A, B, C, A, C, B, B, A, C, B, C, A, C, A, B, C, B, A의 여섯 가지는 모두 다른 경우로 취급하지만, 조합에서는 이 여섯 가지를 하나의 경우로 취급한다.

3장의 카드를 순열 공식에 적용한 결과가 (3 X 2 X 1) / 1 = 6이므로

따라서 (5 X 4 X 3 X 2 X 1) / ((3 X 2 X 1) X (2 X 1)) = 10

5장에서 3장을 무작위로 선택하는 조합에서 모든 경우의 수 = 5C3 = 5! / (3! * 2!) = 10

일반식 nCr = n! / (r! * (n - r)!)

코드 예제

// 반복문 코드

public static ArrayList<String[]> combinationLoop() {
	// 조합 요소가 인자로 주어질 경우, 인자 그대로 사용하면 되지만, 인자가 주어지지 않고
	// 문제 안에 포함되어 있을 경우 이런 식으로 직접 적어서 사용한다.
  String[] lookup = new String[]{"A", "B", "C", "D", "E"};
  ArrayList<String[]> result = new ArrayList<>();

  for(int i = 0; i < lookup.length; i++) {
    for(int j = i + 1; j < lookup.length; j++) {
      for(int k = j + 1; k < lookup.length; k++) {
        String[] input = new String[]{lookup[i], lookup[j], lookup[k]};
				result.add(input);
      }
    }
  }

  return result;
}

/*
[
  [ 'A', 'B', 'C' ], [ 'A', 'B', 'D' ], [ 'A', 'B', 'E' ],
  [ 'A', 'C', 'D' ], [ 'A', 'C', 'E' ], [ 'A', 'D', 'E' ],
  [ 'B', 'C', 'D' ], [ 'B', 'C', 'E' ], [ 'B', 'D', 'E' ],
	[ 'C', 'D', 'E' ]
]
*/

순열과 조합은 반복문으로 만들어낼 수는 있지만 한계가 분명하다.

개수가 늘어나면 반복문의 수도 늘어난다.
뽑아야 되는 개수가 n개처럼 변수로 들어왔을 때 대응이 어렵다.

[Network] 네이티브 앱 (Native App) 과 웹 앱 (Web App) 개념 정리

pongic — Sun, 2 Oct 2022 18:11:46 +0900

네이티브 애플리케이션 (Native Application)이란?

네이티브 애플리케이션은 모바일 기기에 최적화된 언어로 개발된 앱을 의미한다. 특정 기기에 설치해서 사용하는 애플리케이션을 네이티브 애플리케이션이라고 부르는데 네이티브 앱이라고도 한다.

네이티브 애플리케이션은 Apple iOS, Android OS, Windows와 같은 특정 실행환경에 종속된다.

네이티브 앱의 장점

웹 앱보다 속도가 빠르다.
애플리케이션이 설치된 기기의 시스템, 기기의 리소스에 접근이 용이하다. GPS 기능이나 카메라가 그 예이다.
인터넷 없이 사용 가능하다.
웹 앱에 비해 안전하다.
네이티브 API를 호출하여 사용함으로 플랫폼과 밀착되어 있다.

네이티브 앱의 단점

웹 앱에 비해 개발비가 더 들어간다.
빠른 업데이트가 힘들다.
앱스토어에 승인받기가 힘들고 비용이 발생한다.
해당 플랫폼에서 요구하는 언어에 제약적이다.

웹 애플리케이션 (Web Application)이란?

소프트웨어 공학적 관점에서 인터넷이나 인트라넷을 통해 웹 브라우저에서 이용할 수 있는 응용 소프트웨어를 말한다.

웹 앱이라고도 부르며 웹 브라우저를 통해 접근이 가능한 애플리케이션이며 정적인 웹사이트의 한계를 벗어나 다양한 동적인 응답을 웹 브라우저라는 소프트웨어를 통해 가능하게 한 애플리케이션이다.

웹 앱의 장점

브라우저를 통해 실행되기 때문에 설치나 다운로드가 필요 없다.
애플리케이션 스토어 승인이 필요가 없다.
유지관리가 쉽다.
네이티브 앱에 비해 비교적 만들기 간편하다.

웹 앱의 단점

인터넷이 없으면 사용이 안된다.
질적으로나 보안상 위험에 노출되기가 쉽다.
네이티브 앱에 비해 속도가 느리다.
사용자 접근성이 떨어진다.

[Network] 회선 교환(Circuit Switching) 방식과 패킷 교환(Packet Switching) 방식

pongic — Sun, 2 Oct 2022 17:29:22 +0900

회선 교환(Circuit Switching) 방식이란?

2개의 컴퓨터 단말기 간에 정해진 통신로나 회선을 설정하여 정보를 교환하는 방식이다. 회선 교환 방식은 주로 음성전화 시스템에 사용된다. 전화는 일대일로 데이터를 교환하고, 전화 간 통화 중에는 다른 상대와 전화통화가 불가능하다.

회선 교환 방식 특징

일단 통신로가 설정되면 그 통신로는 전용 회선으로 사용될 수 있다.
회선 교환 방식은 주로 음성 전화 시스템에 사용된다.
통신로가 설정되면 부분망은 이 통신로를 통하는 정보를 간섭하지 않으므로 정보의 형태, 부호, 전송 제어 절차 등에 제약이 없다.
대량의 정보를 송신할 수 있는 팩스 전송, 통신 밀도가 높은 데이터 통신에 적합하다.

회선 교환 방식 장점

일단 설정된 통신은 안정적이다.
다른 요인에 의해 통신이 방해받지 않는다.
연속적이고 대용량 데이터 처리에 용이하다.

회선 교환 방식 단점

통신 연결이 늘 보장되지 않는다.
회선 이용 효율이 떨어진다. (대역폭 낭비)
통신 중 회선에 문제가 발생하면 연결이 끊어지고 회선 할당부터 다시 해야 한다.

패킷 교환(Packet Switching) 방식이란?

컴퓨터 네트워크와 통신의 방식 중 하나로 현재 가장 많은 사람들이 사용하는 통신 방식이다. 작은 블록의 패킷으로 데이터를 전송하며 데이터를 전송하는 동안만 네트워크 자원을 사용하도록 하는 방법을 말한다. 정보 전달의 단위인 패킷은 여러 통신 지점(Node)을 연결하는 데이터 연결 상의 모든 노드들 사이에 개별적으로 경로가 제어된다.

이 방식은 통신 기간 동안 독점적인 사용을 위해 짤막한 데이터 트래픽에 적합하다.

패킷 교환 방식 특징

패킷은 여러 경로를 이용 가능하면서 가장 효율적인 경로를 찾는다.
전송 속도 및 흐름 제어가 가능하다.
송신 패킷의 순서와, 수신 패킷의 순서가 다를 수 있다.
에러 탐지가 가능하다.
일반적인 인터넷 망에서 사용된다.

패킷 교환 방식 장점

회선 효율성이 높다.
Store-and-Forward 방식을 사용하기 때문에 각 스테이션에 맞도록 속도를 조절할 수 있다.
상황에 따라 교환기 및 회선 등의 장애가 발생하더라도 패킷 우회 전송이 가능하므로 전송의 신뢰성이 보장된다.
전송 지연이 줄어들고 안정성이 높아진다.

패킷 교환 방식 단점

데이터 단위 길이가 제한된다.
경로에서의 각 교환기에서 다소의 지연이 발생한다.
패킷 교환을 위한 소프트웨어 및 하드웨어가 복잡하다.
각 패킷마다 주소를 위한 오버헤드가 존재한다.

패킷 교환 2가지 방식

데이터 그램 방식

데이터 그램 방식은 비연결 지향적인 성격을 가진다. 데이터 그램 방식은 관련된 패킷이라도 따로 전송하는 방법이다. 그러므로 패킷마다 가는 경로가 다를 수 있고, 망이 상황에 따라 달라지며, 패킷의 도착 순서가 바뀔 수 있어 순서의 재조정이 가능해야 한다.

데이터 그램 방식 장점

Call Setup 과정이 필요 없어 소수 패킷만을 보낼 때 빠르고 오버헤드가 적다.
망 자원이 바쁠 경우 다른 경로로 보내기 때문에 망 운용에 융통성이 있다.
망이 고장 났을 때 최적의 경로를 찾아갈 수 있어 신뢰성이 높다.

가상 회선 방식

가상 회선 방식은 회선 교환 방식을 차용했다. 연결 지향적인 특성을 가지고 있으며 전송하기 전에 논리적으로 목적지와 연결시킨다. 각 패킷에 가상 회선 식별 번호가 존재하고 이 식별 번호를 통해서 전송된 순서대로 목적지에 도착하게 된다.

관련된 패킷을 전부 같은 경로를 통해 전송한다.

가상 회선 방식 장점

각 노드에서 처리시간이 적게 소요된다.
패킷이 출발한 순서대로 도착하기 때문에 오류 제어가 쉽다.
전송할 데이터가 많아도 Call Setup을 한 번만 하면 되기 때문에 효율적인 전송을 할 수 있다.
데이터를 전송하기 전에 Call Setup이 이루어져 라우팅 테이블이 등록된다. 회선을 전용하지 않기 때문에 각각의 패킷에 대해 각각의 경로를 지정할 필요가 없다.

가상 회선 방식 단점

Call Setup에 대한 오버헤드가 존재한다.

[Java] 배열 (Array) 개념 및 정리

pongic — Sat, 1 Oct 2022 23:03:51 +0900

배열(Array)이란?

동일한 타입의 값들을 하나의 묶음으로 묶은 자료 구조를 의미한다. 즉, 값들이 같은 의미를 지니면서 서로 연관성이 있을 때, 이들을 하나의 덩어리로 묶을 수 있으며, 이렇게 묶인 값들의 집합을 배열이라고 한다.

배열이 가진 각 값들을 배열의 요소라고 한다. 그리고 배열의 각 요소는 0에서부터 시작하는 번호를 부여받는데, 이처럼 각 요소가 부여받는 순번을 인덱스(index)라고 한다.

예를 들어 길이가 31인 배열을 생성하면 맨 첫 번째 요소의 인덱스는 0이며, 두 번째 인덱스는 1, 마지막 31번째 요소의 인덱스는 30이 된다.

배열을 선언했을 경우 요소들은 타입에 맞게 자동으로 초기화된다.

배열의 타입	초기값
char	'\u0000'
byte, short, int	0
long	0L
float	0.0F
double	0.0 또는 0.0D
boolean	false
배열, 인스턴스 등	null

1차원 배열

1차원 배열은 가장 일반적인 배열의 형태이다.

int[] result;     // 배열을 가리킬 참조 변수 result 를 선언
result = new int[31];

int[] result = new int[31];  // 선언과 동시에 초기화

int[] result = new int[31] { 1, 2, 3, 4, .... 31 };  // 실제 값을 넣어서 초기화
int[] result = { 1, 2, 3, 4, .... 31 }  // new int[] 생략 가능

값 접근하기

배열 내 특정 요소에 할당되어 있는 값에 접근하려면 배열 참조 변수의 이름과 배열의 인덱스를 활용한다.

double[] temperatureOfJuly = new double[31] { 27.4, 30.1, 31.1, 32.4, ..., 31.8 };

위와 같이 배열을 선언한 경우

첫 번째 요소는 temperatureOfJuly[0]으로 접근할 수 있으며 27.4이다.
두 번째 요소는 temperatureOfJuly[1]으로 접근할 수 있으며 30.1이다.
세 번째 요소는 temperatureOfJuly[2]으로 접근할 수 있으며 31.1이다.
마지막 요소는 temperatureOfJuly[30]으로 접근할 수 있으며 31.8이다.

배열의 길이

배열이 가진 요소의 개수를 배열의 길이 또는 크기라고 한다.

int[] result = new int[31];

배열참조변수이름.length

System.out.println(result.length); // 31

배열에서 인덱스는 0부터 시작하므로 배열의 길이가 31이라면 배열 마지막 요소의 인덱스는 30이 된다.

즉, 배열의 길이 -1이 배열 마지막 요소의 인덱스가 된다.

※ length 메서드 주의

int[] result = new int[31];
System.out.println(result.length);  // 31   배열 길이에서는 length

String result = "Hello!";
System.out.println(result.length());  // 6   문자열 길이에서는 length()

※ 빈 배열을 출력하는 방법

return new int[] {};

배열 메서드

Arrays.toString()

배열의 내용을 문자열 타입으로 반환해준다. String 타입으로 리턴한다.

// Arrays.toString("String으로 변환하고 싶은 배열")

int[] result = {1, 2, 3};
System.out.println(result.toString());  // 주소값 출력
System.out.println(Arrays.toString(result));  // [1, 2, 3] 출력

String.split()

어떤 문자 기준으로 문자열을 자르고 배열로 리턴한다.

// 문자열이름.split(" 기준 ", 배열의 길이)

String str = "Hi guys This is split example";
String[] result = str.split(" ");
String[] result2 = str.split(" ", 2);
String[] result3 = str.split(" ", 3);

System.out.println(Arrays.toString(result));  // [Hi, guys, This, is, split, example]
System.out.println(Arrays.toString(result2)); // [Hi, guys This is split example]
System.out.println(Arrays.toString(result3)); // [Hi, guys, This is split example]

// 일반 문자로 잘랐을 때
String str = "This island is beautiful";
String[] result = str.split("is");
System.out.println(Arrays.toString(result)); // [Th,  , land ,  beautiful]

System.arraycopy()

배열 복사하기

// System.arraycopy(arr1, 0, arr2, 0, arr.length);
// -> arr1의 0번 인덱스부터 arr.length개 만큼의 요소를 arr2의 0번 인덱스부터 붙여넣어라

int[] arr1 = {10, 20, 30, 40, 50};
int[] arr2= {1, 2, 3, 4, 5};

System.arraycopy(arr1, 0, arr2, 1, 3);   // result -> {1 10 20 30 5}

Arrays.copyOf()

배열 복사하기

// Arrays.copyOf(원본배열, 복사할 길이);

int[] arr1 = {1, 2, 3, 4, 5};
int[] arr2 = Arrays.copyOf(arr1, 3); // arr2 = {1, 2, 3}

Arrays.copyOfRange()

배열 복사하기

// Arrays.copyOfRange(원본 배열, 복사할 시작인덱스, 복사할 끝인덱스);

int[] arr1 = {1, 2, 3, 4, 5};
int[] arr2 = Arrays.copyOfRange(arr1, 3, 4);  // arr2 = {4}

2차원 배열

배열의 각 요소가 또 다른 배열인 구조일 뿐, 1차원 배열과 크게 다른 점은 없다.

int[][] result;
result = new int[31][3];

int[][] result = new int[31][3];

// 이 코드가 실행되면
{
	{ 0, 0, 0 },
	{ 0, 0, 0 },
	{ 0, 0, 0 },

	...

	{ 0, 0, 0 }
}

값을 넣어 초기화하는 경우

int[][] result = new int[][] {
	{ 1, 2, 3 },
	{ 4, 5, 6,},
	{ 7, 8, 9 },
	{ 10, 11, 12},
	...
	{ 29, 30, 31 }
}

// new int[][] 를 생략 가능
int[][] result = {
	{ 1, 2, 3 },
	{ 4, 5, 6,},
	{ 7, 8, 9 },
	{ 10, 11, 12},
	...
	{ 29, 30, 31 }
}

가변 배열

배열이 2차원 이상일 때, 마지막 차수에 해당하는 배열의 길이를 고정하지 않아도 되며, 이러한 배열을 가변 배열이라고 한다.

int[][] result = new int[5][];
System.out.println("Arrays.toString(result) = " + Arrays.toString(result));

// 결과 Arrays.toString(result) = [null, null, null, null, null]

선언과 동시에 초기화

int[][] ages = {
	{ 30, 32, 39, 59, 23 },
	{ 31, 41, 52, 56, 72, 13 },
	{ 45, 32, 84, 23, 13, 42, 55 },
	{ 23, 41, 62, 64, 23, 51, 67, 98 },
	{ 13, 14, 17, 84, 52, 37, 68, 66, 33 }
};

배열 탐색

반복문을 활용하여 배열을 탐색할 수 있으며, 기본적으로 인덱스와 배열의 크기(length)를 활용하여 탐색한다.

// for문

int[] result = { 1, 2, 3, 4 };
int sum = 0;

for (int index = 0; index < result.length; index ++) {
	sum += result[index];
}

// while문

int[] result = { 1, 2, 3, 4 };
int sum = 0;
int index = 0;

while (index < result.length) {
	sum += result[index++];
}

// for each문
int[] result = { 1, 2, 3, 4 };
int sum = 0;

for (int score: result) {
	sum += score;
}

※ for - each문은 배열을 순회하면서 배열의 값을 수정할 수 없고 탐색만 가능하다.

[Java] BufferedReader와 BufferedWriter 정리

pongic — Sat, 1 Oct 2022 16:44:13 +0900

BufferedReader와 BufferedWriter란?

BufferedReader와 BufferedWriter은 이름처럼 버퍼를 이용해서 읽고 쓰는 함수이다. 이 함수는 버퍼를 이용하기 때문에 입출력의 효율이 좋아진다. BufferedReader는 Scanner와 유사하고 BufferedWriter는 System.out.println( )과 유사하다.

두 기존에 쓰던 Scanner와 System.out.println( ) 보다 속도 측면에서 훨씬 빠르다.

하지만 BufferedReader는 Enter만 경계로 인식하고 받은 데이터가 String으로 고정되기 때문에 입력받은 데이터를 가공하는 작업이 필요하다.

// 사용하기 위해 import 선언

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

BufferedReader 사용법

// BufferedReader 사용법

BufferedReader bf = new BufferedReader(new InputStreamReader(System.in)); // 선언
String s = bf.readLine();  // String
int i = Integer.parseInt(bf.readLine()); // int

※ 입력은 readLine()이라는 메서드를 활용하는데 이때 반드시 주의할 점!!

readLine( ) 메서드 사용 시 리턴 값이 String으로 고정되기 때문에 String이 아닌 다른 타입으로 입력을 받으려면 반드시 형 변환을 꼭 해주어야 한다.
예외처리를 꼭 해주어야 한다. try & catch를 활용해도 되지만 주로 throws IOException을 사용한다.

throw 사용

// throw 이용시 1. 클래스를 import 2. main 클래스 옆에 throws IOException를 작성한다

import java.io.IOException;

public class Main {
	public static void main(String[] args) throws IOException {

    }
}

데이터 가공

// StringTokenizer 
import java.util.StringTokenizer;

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer(br.readLine()); // StringTokenizer인자값에 입력 문자열 넣음
int N = Integer.parseInt(st.nextToken());  // 첫번째 호출
int M = Integer.parseInt(st.nextToken());  // 두번째 호출

// String.split() 함수
String arr[] = s.split(" ");  // 공백마다 데이터 끊어서 배열에 넣음

BufferedReader를 통해 읽어온 데이터는 개행 문자 (Line 단위)로 나뉜다.

만약 이를 공백 단위로 데이터를 가공하고자 할 때 StringTokenizer 나 String.split( ) 함수이다.

StringTokenizer의 nextToken( ) 함수를 쓰면 readLine( )을 통해 입력받은 값을 공백 단위로 구분하여 순서대로 호출할 수 있다. String.split( ) 함수를 사용하면, 배열에 공백 단위로 끊어 데이터를 저장하여 사용할 수 있다.

BufferedWriter 사용법

BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out)); // 선언
String str = "abcdef"; // 출력할 문자열
bw.write(s); // 출력
bw.newLine(); // 줄바꿈
bw.flush(); // 남아있는 데이터 모두 출력
bw.close();

BufferedWriter는 System.out.println(" ")처럼 출력과 개행을 동시에 할 수 없다. 그래서 newLine( ); 혹은 bw.write("\n"); 을 사용해야 한다. BufferedWriter의 경우 버퍼를 잡아 놓았기 때문에 반드시 flush( ) / close( )를 해주어야 한다.

close( )는 출력 스트림을 아예 닫는 것이고 flush( )는 한번 출력 후 다른 것도 출력한다.

[Network] TCP/UDP 개념 및 정리

pongic — Sat, 1 Oct 2022 14:56:07 +0900

TCP / UDP란?

TCP / UDP는 OSI 표준모델과 TCP/IP 모델의 전송 계층에서 사용되는 프로토콜이다. TCP/IP 4계층 모델을 기준으로 IP 프로토콜의 계층인 인터넷 계층의 상위에서 동작을 한다. 또한 2계층에서 동작하는 IP와 4계층에서 동작하는 애플리케이션을 중개하는 역할을 한다.

TCP와 UDP는 포트 번호를 이용하여 주소를 지정하는것과 데이터 오류 검사를 위한 체크섬이 존재하는 두 가지 공통점이 있지만 TCP는 통신 신뢰성을 높이는 기능이 구현되어 있고 UDP는 신뢰성을 높이는 기능은 없지만 높은 속도와 효율성을 제공한다.

※ 자주 사용되는 포트 번호

Port No	Protocol Name	Transport Protocol	description
80	HTTP	TCP	웹서버 접속
443	HTTPS	TCP	웹서버 접속(SSL)
110	POP3	TCP	메일 읽기
25	SMTP	TCP	메일 서버간 메일 전송
22	SSH	TCP	컴퓨터 원격 로그인
53	DNS	UDP	DNS 질의
123	NTP	TCP	시간 동기화

이미 정해진 포트 번호라도, 필요에 따라 자유롭게 사용할 수 있다. 잘 알려진 포트의 경우 URI 등에 명시하지 않지만, 그 외의 잘 알려지지 않은 포트(:8080과 같은 임시 포트)는 반드시 포함해야 한다.

TCP란?

TCP((Transmission Control Protocol)는 전송 제어 프로토콜로 연결 지향적 프로토콜이다. 인터넷 프로토콜 스위트(IP)의 핵심 프로토콜 중 하나로 IP와 함께 TCP/IP라는 명칭으로도 불린다.

근거리 통신망이나 인트라넷, 인터넷에 연결된 컴퓨터에서 실행되는 프로그램 간에 일련의 옥텟을 안정적으로, 순서대로, 에러 없이 교환할 수 있게 한다. 웹 브라우저들이 월드 와이드 웹(WWW)에서 서버에 연결할 때 사용되며, 이메일 전송이나 파일 전송에도 사용된다. TCP는 3-way handshaking 방식을 통해 네트워크를 연결한다.

TCP의 특징

연결형 서비스로 연결이 성공해야 통신이 가능하다. 연결할 때는 3-way handshaking 방식으로 연결을 하고 4-way handshaking 방식으로 연결을 해제한다.
데이터의 전송 순서를 보장한다.
신뢰성있는 데이터를 전송한다.
데이터의 흐름 제어, 혼잡 제어
전이중(Full-Duplex), 점대점(Point to Point) 서비스

3-way handshake

3-way handshake 과정

SYN : 처음으로 Sender는 Receiver와 연결 설정을 위해서, segement를 랜덤으로 설정된 SYN(Synchronize Sequence Number)와 함께 보낸다. 이 요청은 Receiver에게 Sender가 통신을 시작하고 싶다고 알리는 것이다.
SYN / ASK: Receiver는 받은 요청을 바탕으로 SYN/ACK 신호 세트를 응답한다. Acknowledgement(ACK) 응답으로 보내는 segment가 유효한 SYN요청을 받았는지를 의미한다.
ACK : Sender는 받은 ACK를 Receiver에게 전송을 하면서, 신뢰성 있는 연결이 성립되었다는 사실을 Sender와 Receiver 양쪽에서 알 수 있고, 실제 데이터 전송이 시작되게 된다.

UDP란?

UDP(User Datagram Protocol)는 전송계층의 비연결 지향적 프로토콜이다. 비연결 지향적은 데이터를 주고받을 때 연결 절차를 거치지 않고 발신자가 일방적으로 데이터를 발신하는 방식을 의미한다. UDP 전송 방식은 너무 단순해서 신뢰성이 낮고, 데이터그램 도착 순서가 바뀌거나, 중복되거나, 심지어는 통보 없이 누락시키기도 한다. UDP를 사용하는 네트워크 애플리케이션에는 DNS, IPTV, 음성 인터넷 프로토콜(VoIP), TFTP, 온라인 게임 등이 있다.

UDP의 특징

비연결 지향적 서비스로 연결 없이 통신이 가능하다.
정보를 주고 받을 때 정보를 보내거나 받는다는 신호 절차를 거치지 않는다.
신뢰성 없는 데이터를 전송한다.

TCP와 UDP 공통점

포트 번호를 이용하여 주소를 지정한다.
데이터 오류 검사를 위한 체크섬이 존재한다.

TCP와 UDP의 차이점

	TCP((Transmission Control Protocol)	UDP(User Datagram Protocol)
서비스 타입	연결 지향적	비연결 지향적 (데이터그램 지향적)
신뢰성	높다.	낮다.
순서 보장	순서 보장된다.	순서가 보장되지 않는다. 패킷 순서를 보장하고 싶다면 애플리케이션 레이어에서 관리되어야 한다.
속도	UDP와 비교해 느리다.	TCP와 비교해 빠르고, 단순하며 더 효육적인 속도를 가지고 있다.
통신 방식	1:1 통신만 가능(Unicast)	1:1(Unicast) / 1:N(Broadcast) / N:N(Multicast) 통신 모두 가능

[Network] TCP/IP 4 계층 (TCP/IP 4 Layer) 개념 및 정리

pongic — Fri, 30 Sep 2022 19:22:22 +0900

TCP/IP 4 계층이란?

OSI 7 계층보다 먼저 나온 규격이지만 더 많이 활용된다.

계층 기능

1 계층 : 네트워크 액세스 계층(Network Access Layer)

컴퓨터를 물리적으로 네트워크에 연결해서 기기 간에 전송이 가능하게 한다.
물리적인 주소로 MAC을 사용한다.
에러 검출 기능(Detecting Errors), 패킷의 프레임화(Framing Packets)
LAN, 패킷망 등에 사용된다.
프로토콜 : Ethernet, wifi

2 계층 : 인터넷 계층(Internet Layer)

네트워크 주소를 기반으로 최종 목적지까지 정확하게 데이터를 전송한다.
통신 노드 간의 IP 패킷을 전송하는 기능과 라우팅 기능을 담당한다.
프로토콜 : IP, ICMP, ARP, RARP

3 계층 : 전송 계층(Transport Layer)

IP와 애플리케이션을 중개해 데이터를 확실하게 전송한다.
IP와 Port를 이용하여 프로세스와 통신한다.
통신 노드 간의 연결을 제어하고, 신뢰성 있는 데이터 전송을 담당한다.
프로토콜 : TCP, UDP

4 계층 : 응용 계층(Application Layer)

애플리케이션에 맞추어 통신한다.
다른 계층의 서비스에 접근할 수 있게 애플리케이션을 제공한다.
TCP/UDP 기반의 응용 프로그램을 구현할 때 사용한다.
프로토콜 : HTTP, DNS, FTP, SSH

[Network] OSI 7 계층 (OSI 7Layer) 개념 및 정리

pongic — Fri, 30 Sep 2022 19:00:21 +0900

OSI 7 계층이란?

네트워크에서 통신이 일어나는 과정을 7단계로 나눈 것을 의미하며 국제표준화기구(ISO)에서 네트워크 간의 호환을 위해 OSI 7 계층이라는 표준 네트워크 모델을 만들었다.

이렇게 정의하는 이유는 통신이 일어나는 과정을 단계별로 파악하기 위함과 통신 과정 중에 이상이 생겼을 때 다른 단계의 장비나 소프트웨어 등을 건드리지 않고 장애를 일으킨 단계에서 문제를 해결할 수 있기 때문이다.

계층 기능

1 계층 : 물리 계층(Phsical Layer)

주로 전기적, 기계적, 기능적인 특성을 이용해서 데이터를 전송한다.
단지 데이터를 전달하려고 할 뿐 데이터가 무엇인지 어떤 에러가 있는지 등에는 전혀 신경 쓰지 않고 단순히 전기적인 신호로 변환해서 주고받는 기능만 한다.
데이터의 전송 단위는 비트(bit)이다.
대표적인 장비 : 케이블, 무선 주파수 링크, 리피터, 허브

2 계층 : 데이터 링크 계층(DataLink Layer)

장치 간 신호를 전달하는 물리계층을 이용하여 네트워크 상의 주변 장치들 간의 데이터를 전송(Point-To-Point 전송)하는 역할을 한다.
물리 계층을 통해 송수신되는 정보의 오류와 흐름을 관리하여 안전한 정보의 전달을 도와주는 역할을 한다.
오류를 찾아주기도 하고 재전송하는 기능을 가지고 있다
MAC 주소를 통해서 통신한다.
데이터의 전송 단위는 프레임(Frame)이다.
대표적인 장비 : 브리지, 스위치
프로토콜 : 이더넷(Ethernet), PPP, HDLC, ALOHA

3 계층 : 네트워크 계층(Network Layer)

라우팅 기능을 맡고 있는 계층으로 목적지까지 가장 안전하고 빠르게 데이터를 보내는 기능을 가지고 있다. (최적의 경로를 설정 가능하다.)
다양한 길이의 데이터를 네트워크를 통해 전달하고, 그 과정에서 전송 계층이 요구하는 서비스 품질을 제공하기 위한 기능적, 절차적 수단을 제공한다.
데이터를 다른 네트워크를 통해 전달함으로써 인터넷이 가능하게 만드는 역할을 한다.
라우팅, 흐름 제어, 세그멘테이션, 오류 제어, 인터네트워킹 등을 수행한다.
논리적인 주소 구조(IP) 즉 네트워크 관리자가 직접 주소를 할당하는 구조이며 계층적이다.
데이터의 전송 단위는 패킷(Packet)이다.
대표적인 장비 : 라우터, L3, 스위치
프로토콜 : IP, RIP, ARP, ICMP

4 계층 : 전송 계층(Transport Layer)

양 끝단의 사용자들이 신뢰성 있고 정확한 데이터 전송을 할 수 있도록 해준다.
송신자와 수신자 간의 신뢰성 있고 효율적인 데이터를 전송하기 위해 오류 검출 및 복구, 흐름 제어, 중복검사 등을 수행한다.
데이터 전송을 위해서 Port 번호를 사용한다. 대표적인 프로토콜로 TCP와 UDP가 있다.
데이터의 전송 단위는 세그먼트(Segment)이다.
프로토콜 : TCP, UDP

5 계층 : 세션 계층(Session Layer)

양 끝단의 응용 프로세스가 통신을 관리하기 위한 방법을 제공한다. 즉 통신 장치 간 상호작용 및 동기화를 제공한다.
연결 과정에서 데이터 교환과 에러 발생 시의 복구를 관리하고 연결 시도 중 장시간 연결이 되지 않았다면 세션 계층의 프로토콜이 연결을 닫고 다시 연결을 시도한다.
동시 송수신 방식(duplex), 반이중 방식(half-duplex), 전이중 방식(Full Duplex)의 통신과 함께 체크 포인팅과 유휴, 종료, 다시 시작 과정 등을 수행한다.
데이터의 전송 단위는 메시지(message)이다.
프로토콜 : NetBIOS, SSH

6 계층 : 표현 계층(Presentation Layer)

데이터를 어떻게 표현할지 정하는 역할을 하는 계층이다.
송신자에서 온 데이터를 해석하기 위한 응용계층 데이터 부호화, 변화를 해주는 역할
수신자에서 데이터의 압축을 풀 수 있는 방식으로 된 데이터 압축을 해주는 역할
데이터의 암호화와 복호화 (EBCDI로 인코딩된 문서 파일을 ASCII로 인코딩된 파일로 바꿔 주는 역할)
데이터의 전송 단위는 메시지(message)이다.
프로토콜 : JPG, MPEG, AFP, PAP

7 계층 : 응용 프로그램 계층(Application Layer)

사용자와 가장 밀접한 계층으로 인터페이스 역할을 한다.
이 계층에서 작동하는 응용 프로그램은 사용자와 직접적으로 상호작용한다.
응용 프로세스 간의 정보 교환을 담당한다. Ex. 전자메일, 인터넷, 동영상 플레이어 등
프로토콜 : HTTP, FTP, HTTPS, SMTP, SSH, RDP, WebSocket

[Network] LAN과 WAN 정리

pongic — Fri, 30 Sep 2022 12:32:05 +0900

근거리 통신망 (LAN)

LAN은 Local Area Network의 약자로 사용자가 포함된 지역 네트워크를 의미한다.

근거리 통신망, 로컬 영역 네트워크 구내 정보 통신망은 네트워크 매체를 이용하여 집, 사무실, 학교 등의 건물과 가까운 지역을 한데 묶는 컴퓨터 네트워크이다.

이더넷과 와이파이는 근거리 통신망(LAN)에 사용하기 위해 흔히 쓰이는 기술이다.

이러한 LAN을 연결하는 선을 우리는 LAN 케이블이라고 부른다. 이렇게 수많은 LAN들이 모여 세계의 네트워크를 구성하는 WAN이 구성된다.

광역 통신망 (WAN)

WAN은 Wide Area Network의 약자로 LAN과 LAN 사이를 광범위한 지역 단위로 구성하는 네트워크를 의미한다.

광역 통신망은 지역, 국가, 세상 범위까지 구성된 컴퓨터 네트워크이다. 근거리 통신망 유저들이 다른 지역에 있는 근거리 통신망 사용자들과 데이터 통신을 할 수 있도록 해준다.

광역 통신망의 연결 기술

전용선 : 가장 안전하지만 가격이 비싸다. PPP, HDLC, SDLC, HNAS 프로토콜에 쓰인다.
회선 교환 : 가격이 싸지만 전화 설치로 문의해야 한다. PPP, ISDN 프로토콜에 쓰인다.
패킷 교환 : X.25 프레임 릴레이 프로토콜에 쓰인다.
셀 릴레이 : 데이터와 소리를 동시에 전달하는 데 가장 좋지만 오버헤드가 예상된다. ATM에 쓰인다.

광역 통신망 참고

https://ko.wikipedia.org/wiki/%EA%B4%91%EC%97%AD_%ED%86%B5%EC%8B%A0%EB%A7%9D

광역 통신망 - 위키백과, 우리 모두의 백과사전

위키백과, 우리 모두의 백과사전. 광역 통신망과 근거리 통신망 구조도 광역 통신망(영어: wide area network, WAN)은 드넓은 지리적 거리/장소를 넘나드는 통신 네트워크 또는 컴퓨터 네트워크이다.

ko.wikipedia.org

※ 인터넷 비용을 지불하는 이유

작은 네트워크 구성인 LAN이 WAN으로 확장하기 위해선 각 거점을 연결하는 통신회선 서비스를 이용해야 한다.

이러한 회선 서비스를 통신 사업자가 구성하고 고객에게 서비스를 제공한다. 우리는 이러한 통신 사업자의 설비를 빌려서 인터넷을 사용하기 때문에 비용을 지불하게 된다.

[Java] 열거형 (enum) 정리

pongic — Thu, 29 Sep 2022 19:46:51 +0900

열거형(enum)이란?

여러 상수들을 보다 편리하게 선언할 수 있도록 만들어졌다. 열거형은 서로 연관된 상수들의 집합을 의미한다.

상수란 변하지 않는 값을 의미하며 final 키워드를 사용하여 선언할 수 있다.

열거형은 여러 상수들을 보다 편리하게 선언하고 관리할 수 있으며, 상수 명의 중복을 피하고, 타입에 대한 안정성을 보장한다. 훨씬 더 간결하고 가독성이 좋은 코드를 작성할 수 있다.

열거형 사용

enum 열거형 이름 {상수1, 상수2, ...}

enum Seasons { SPRING, SUMMER, FALL, WINTER }

enum Seasons { 
SPRING, //정수값 0 할당
SUMMER,  //정수값 1 할당
FALL, //정수값 2 할당
WINTER //정수값 3 할당
}

public class EnumExample {
    public static void main(String[] args) {
        System.out.println(Seasons.SPRING); // SPRING
    }
}

상수는 관례적으로 대문자로 작성한다. 각각의 열거 상수들은 객체이기 때문에 Seasons라는 이름의 열거형은 SPRING, SUMMER, FALL, WINTER 총 네 개의 열거 객체를 포함하고 있다고 말할 수 있다.

마지막으로 각각의 상수들에는 자동적으로 0부터 시작하는 정수값이 할당되어 각각의 상수를 가리키게 된다.

선언된 상수에 접근하는 방법은 열거형이름.상수명 을 통해서 가능

enum Seasons {
SPRING, // 0
SUMMER, // 1
FALL,   // 2
WINTER  // 3
}

public class Main {
    public static void main(String[] args) {
        Seasons seasons = Seasons.SPRING;
        switch (seasons) {
            case SPRING:
                System.out.println("봄");
                break;
            case SUMMER:
                System.out.println("여름");
                break;
            case FALL:
                System.out.println("가을");
                break;
            case WINTER:
                System.out.println("겨울");
                break;
        }
    }
}

/* 출력
봄
*/

열거형 메서드

name()

열거 객체가 가지고 있는 문자열을 리턴하며 리턴되는 문자열은 열거 타입을 정의할 때 사용한 상수 이름과 동일하다. String 타입을 리턴한다.

ordinal()

열거 객체의 순번(0부터 시작)을 리턴한다. int 타입을 리턴한다.

compareTo(비교값)

주어진 매개값과 비교해서 순번 차이를 리턴한다. int 타입을 리턴한다.

valueOf(String name)

주어진 문자열의 열거 객체를 리턴한다.

values()

모든 열거 객체들을 배열로 리턴한다.

열거형 예제

enum Level {
  LOW, // 0
  MEDIUM, // 1
  HIGH // 2
}

public class EnumTest {
    public static void main(String[] args) {
        Level level = Level.MEDIUM;

        Level[] allLevels = Level.values();
        for(Level x : allLevels) {
            System.out.printf("%s=%d%n", x.name(), x.ordinal());
        }

        Level findLevel = Level.valueOf("LOW");
        System.out.println(findLevel);
        System.out.println(Level.LOW == Level.valueOf("LOW"));

        switch(level) {
            case LOW:
                System.out.println("낮은 레벨");
                break;
            case MEDIUM:
                System.out.println("중간 레벨");
                break;
            case HIGH:
                System.out.println("높은 레벨");
                break;
        }
    }
}

/* 출력
LOW=0
MEDIUM=1
HIGH=2
LOW
true
중간 레벨
*/

[Java] 재귀 함수 (Recursion Function) 정리

pongic — Thu, 29 Sep 2022 19:01:50 +0900

재귀 함수(Recursion)란?

특정 함수 내에서 자기 자신을 호출하는 함수이다. 재귀 함수를 잘 활용하면 반복적인 작업을 해야 하는 문제를 좀 더 간결하게 풀어낼 수 있다.

public void recursion() {
  System.out.println("This is");
  System.out.println("recursion!");
  recursion();
}

재귀 함수 사용 조건

문제의 크기를 점점 작은 단위로 쪼갤 수 있어야 한다.
재귀 호출이 종료되는 시점이 존재해야 한다.

재귀 함수의 장점

불필요하게 여러 개의 반복문을 사용하지 않기 때문에, 코드가 간결해지고, 수정이 용이하다.
변수를 여러 개 사용할 필요가 없다.

재귀 함수의 단점

코드의 흐름을 직관적으로 파악하기 어렵다.
반복하여 메서드를 호출하며 지역변수, 매개변수, 반환 값을 모두 process stack에 저장한다. 이러한 과정은 많은 메모리를 사용하게 된다.
메서드를 호출하고 메서드가 종료된 이후에 복귀를 위한 컨텍스트 스위칭 비용이 발생한다.

재귀 함수 예제

일반적인 재귀 함수의 템플릿

public type recursive(input1, input2, ...) {
  // Base Case : 문제를 더 이상 쪼갤 수 없는 경우
  if (문제를 더 이상 쪼갤 수 없을 경우) {
    return 단순한 문제의 해답;
  }
  // recursive Case
  // 그렇지 않은 경우
  return 더 작은 문제로 새롭게 정의된 문제
}

구구단 만들기

// 반복문으로 구현한 구구단 메서드
public void Gugudan(int level) {
  for(int count = 0; count < 9; count++) {
    System.out.printf("%d x %d = %d\n", level, count, level * count);
  }
}

// 재귀 호출로 구현한 구구단 메서드
public void Gugudan(int level, int count) {
  if(count > 9) {
    return;
  }
  System.out.printf("%d x %d = %d\n", level, count, level*count);
  Gugudan(level, ++count);
}

팩토리얼 (factorial) 만들기

// 반복문으로 구현한 팩토리얼 메서드
public int Factorial(int number) {
  int result = 1;
  for(int count = number; count > 0; count--) {
    result = result * count;
  }
  return result;
}

// 재귀 호출로 구현한 팩토리얼 메서드
public int Factorial(int number) {
  if(number <= 1) {
    return 1;
  }
  return number * Factorial(number - 1);
}

[Java / 자료구조] 이진 탐색 트리 (Binary Search Tree) 정리

pongic — Wed, 28 Sep 2022 21:07:36 +0900

이진 탐색 트리 (Binary Search Tree)란?

자식 노드가 최대 두 개인 노드들로 구성된 트리이다. 이 두 개의 자식 노드는 왼쪽 자식 노드와 오른쪽 자식 노드로 나눌 수 있다. 이진 트리는 자료의 삽입, 삭제 방법에 따라 정 이진 트리(Full binary tree), 완전 이진 트리(Complete binary tree), 포화 이진 트리(Perfect binary tree)로 나뉜다

정 이진 트리(Full binary tree) : 각 노드가 0개 혹은 2개의 자식 노드를 갖는다.
완전 이진 트리(Complete binary tree) : 정 이진 트리이면서 완전 이진 트리인 경우이다. 모든 리프 노드의 레벨이 동일하고, 모든 레벨이 가득 채워져 있는 트리이다.
포화 이진 트리(Perfect binary tree) : 마지막 레벨을 제외한 모든 노드가 가득 차 있어야 하고, 마지막 레벨의 노드는 전부 차 있지 않아도 되지만 왼쪽이 채워져야 한다.

이진 탐색 트리는 모든 왼쪽 자식의 값이 루트나 부모보다 작고, 모든 오른쪽 자식의 값이 루트나 부모보다 큰 값을 가지는 특징이 있다.

이진 트리 순회

전위 순회 (preorder traverse)

가장 먼저 방문할 노드는 루트이다. 루트에서 시작해 왼쪽의 노드들을 순차적으로 탐색한 뒤, 오른쪽 노드를 탐색한다.

전위 순회 결과 : A - B - D - E - C - F - G

중위 순회 (inorder traverse)

왼쪽의 노드들을 순차적으로 탐색한 뒤, 루트 노드를 방문한다. 그리고 오른쪽 노드를 탐색 한다.

중위 순회 결과 : D - B - E - A - F - C - G

후위 순회 (postorder traverse)

왼쪽 노드들을 순차적으로 탐색 한 뒤, 오른쪽 노드를 탐색한다. 그리고 루트 노드를 방문한다.

후위 순회 결괴 : D - E - B - F - G - C - A

이진트리 효율성

데이터의 탐색 속도를 올리기 위해 사용하는 구조이다.

데이터를 검색할 때 전체 데이터를 검색하지 않고, 해당 데이터 집합에서의 중간값을 찾아 크기를 비교하는 방식으로 데이터를 검색한다.

중간값을 구해서 중간값보다 크거나 작은 지를 판단해서 왼쪽, 오른쪽 노드 지정

노드의 개수가 N개이면 시간 복잡도는 O(logN)이다.

이진트리 구현

노드 클래스 만들기

// 트리를 구성하는 노드 클래스입니다.
public static class Node {
  private int data;
  private Node left;
  private Node right;

  /* 생성자 */
  public Node(int data) {
    this.setData(data);
    setLeft(null);
    setRight(null);
  }

  public int getData() {
    return data;
  }
  
  public Node getLeft() {
    return left;
  }

  public Node getRight() {
    return right;
  }

  public void setData(int data) {
    this.data = data;
  }
  
  public void setLeft(Node left) {
    this.left = left;
  }

  public void setRight(Node right) {
    this.right = right;
  } 
}

삽입 연산

삽입 연산에서 가장 먼저 하는 일은 root노드가 존재하는지 확인한다.

root 노드가 존재하지 않으면 해당 트리의 노드가 없다는 뜻이므로 새로운 newNode를 root노드로 만들어주고 return 한다.

public void insert(int data) {
  Node newNode = new Node(data); // 왼쪽, 오른쪽 자식 노드가 null 이며 data 의 값이 저장된 새 노드 생성
  if (root == null) {// 루트 노드가 없을때, 즉 트리가 비어있는 상태일 때,
    root = newNode;
    return;
  }
  if(root.data == data) return;   //중복일때 정지
  
  Node currentNode = root;
  Node parentNode = null;

  while (true) {
    parentNode = currentNode;

    if (data < currentNode.getData()) { // 해당 노드보다 작을 경우
      currentNode = currentNode.getLeft();
      if (currentNode == null) {  // 더 이상 자식 노드가 없을 떄, 즉 삽입 할 수 있는 때
        parentNode.setLeft(newNode);
        return;
      }else if(currentNode.data == newNode.data) return;
    } else { // 해당 노드보다 클 경우
      currentNode = currentNode.getRight();
      if (currentNode == null) {  // 더 이상 자식 노드가 없을 떄, 즉 삽입 할 수 있는 때
        parentNode.setRight(newNode);
        return;
      }else if(currentNode.data == newNode.data) return;
    }
  }
}

삭제 연산

케이스를 나누어서 연산을 한다.

자식 노드가 없는 경우
하나의 자식 노드를 갖는 경우
두 개의 자식 노드를 갖는 경우

public boolean delete(int data){
  Node parentNode = root;
  Node currentNode = root;
  boolean isLeftChild = false;

  while(currentNode.getData() != data) {
    parentNode = currentNode;
    if(currentNode.getData() > data) {
      isLeftChild = true;
      currentNode = currentNode.getLeft();
    }else {
      isLeftChild = false;
      currentNode = currentNode.getRight();
    }
    if(currentNode == null){
      return false;
    }
  }
  // 1. 자식 노드가 없는 경우
  if(currentNode.getLeft() == null && currentNode.getRight() == null) {
    if(currentNode == root) {
      root = null; // 해당 노드가 root node일 경우
    }
    if(isLeftChild) {
      parentNode.setLeft(null); // 삭제할 노드가 부모 노드의 왼쪽 자식일 경우
    }
    else {
      parentNode.setRight(null); // 삭제할 노드가 부모 노드의 오른쪽 자식일 경우
    }
  }
  // 2-1. 자식 노드가 하나인 경우(오른쪽 자식이 없을 때)
  else if(currentNode.getRight() == null){
    parentNode.setLeft(currentNode.getLeft());
  }
  // 2-2. 자식 노드가 하나인 경우(왼쪽 자식이 없을 떄)
  else if(currentNode.getLeft() == null) {
    parentNode.setRight(currentNode.getRight());
  }
  // 3. 자식이 둘인 경우
  else {
    Node minimum = getMinumun(currentNode);
    if(currentNode == root) {
      root = minimum;
    }else if (isLeftChild){
      parentNode.setLeft(minimum);
    }else {
      parentNode.setLeft(currentNode.getLeft());
    }
    minimum.setLeft(currentNode.getLeft());
  }
  return false;
}

탐색 연산

이진 탐색의 특성 왼쪽 자식 노드의 값은 현재 노드보다 항상 작아야 하고 오른쪽 자식 노드의 값은 현재 노드의 값 보다 항상 커야 한다라는 특징을 만족해야 한다.

public boolean contains(int data) {
  Node currentNode = root;
  while (currentNode != null) {
    // 찾는 value값이 노드의 value와 일치한다면, true를 리턴합니다.
    if (currentNode.data == data) {
      return true;
    }

    if (currentNode.data > data) {
      // 찾는 value값이 노드의 value 보다 작다면, 현재 노드를 left로 변경후 다시 반복합니다.
      currentNode = currentNode.left;
    }else {
      // 찾는 value값이 노드의 value 보다 크다면, 현재 노드를 right로 변경후 다시 반복합니다.
      currentNode = currentNode.right;
    }
  }
  return false;
}

전체 코드

public class Main {
  // 트리를 구성하는 노드 클래스입니다.
  public static class Node {
    private int data;
    private Node left;
    private Node right;

    /* 생성자 */
    public Node(int data) {
      this.setData(data);
      setLeft(null);
      setRight(null);
    }

    public int getData() {
      return data;
    }

    public Node getLeft() {
      return left;
    }

    public Node getRight() {
      return right;
    }

    public void setData(int data) {
      this.data = data;
    }

    public void setLeft(Node left) {
      this.left = left;
    }

    public void setRight(Node right) {
      this.right = right;
    }
  }

  //이진 탐색 트리의 클래스입니다.
  public static class binarySearchTree {
    public Node root;

    public binarySearchTree(){
      root = null;
    }

    // 삽입 연산
    public void insert(int data) {
      Node newNode = new Node(data); // 왼쪽, 오른쪽 자식 노드가 null 이며 data 의 값이 저장된 새 노드 생성
      if (root == null) {// 루트 노드가 없을때, 즉 트리가 비어있는 상태일 때,
        root = newNode;
        return;
      }
      if(root.data == data) return;   //중복일때 정지

      Node currentNode = root;
      Node parentNode = null;

      while (true) {
        parentNode = currentNode;

        if (data < currentNode.getData()) { // 해당 노드보다 작을 경우
          currentNode = currentNode.getLeft();
          if (currentNode == null) {  // 더 이상 자식 노드가 없을 떄, 즉 삽입 할 수 있는 때
            parentNode.setLeft(newNode);
            return;
          }else if(currentNode.data == newNode.data) return;
        } else { // 해당 노드보다 클 경우
          currentNode = currentNode.getRight();
          if (currentNode == null) {  // 더 이상 자식 노드가 없을 떄, 즉 삽입 할 수 있는 때
            parentNode.setRight(newNode);
            return;
          }else if(currentNode.data == newNode.data) return;
        }
      }
    }

    // 탐색 연산
    public boolean contains(int data) {
      Node currentNode = root;
      while (currentNode != null) {
        // 찾는 value값이 노드의 value와 일치한다면, true를 리턴합니다.
        if (currentNode.data == data) {
          return true;
        }

        if (currentNode.data > data) {
          // 찾는 value값이 노드의 value 보다 작다면, 현재 노드를 left로 변경후 다시 반복합니다.
          currentNode = currentNode.left;
        }else {
          // 찾는 value값이 노드의 value 보다 크다면, 현재 노드를 right로 변경후 다시 반복합니다.
          currentNode = currentNode.right;
        }
      }
      return false;
    }

    // 삭제 연산
    public boolean delete(int data){
      Node parentNode = root;
      Node currentNode = root;
      boolean isLeftChild = false;

      while(currentNode.getData() != data) {
        parentNode = currentNode;
        if(currentNode.getData() > data) {
          isLeftChild = true;
          currentNode = currentNode.getLeft();
        }else {
          isLeftChild = false;
          currentNode = currentNode.getRight();
        }
        if(currentNode == null){
          return false;
        }
      }
      // 1. 자식 노드가 없는 경우
      if(currentNode.getLeft() == null && currentNode.getRight() == null) {
        if(currentNode == root) {
          root = null; // 해당 노드가 root node일 경우
        }
        if(isLeftChild) {
          parentNode.setLeft(null); // 삭제할 노드가 부모 노드의 왼쪽 자식일 경우
        }
        else {
          parentNode.setRight(null); // 삭제할 노드가 부모 노드의 오른쪽 자식일 경우
        }
      }
      // 2-1. 자식 노드가 하나인 경우(오른쪽 자식이 없을 때)
      else if(currentNode.getRight() == null){
        parentNode.setLeft(currentNode.getLeft());
      }
      // 2-2. 자식 노드가 하나인 경우(왼쪽 자식이 없을 떄)
      else if(currentNode.getLeft() == null) {
        parentNode.setRight(currentNode.getRight());
      }
      // 3. 자식이 둘인 경우
      else {
        Node minimum = getMinumun(currentNode);
        if(currentNode == root) {
          root = minimum;
        }else if (isLeftChild){
          parentNode.setLeft(minimum);
        }else {
          parentNode.setLeft(currentNode.getLeft());
        }
        minimum.setLeft(currentNode.getLeft());
      }
      return false;
    }

    Node getMinumun(Node deleteNode) {
      Node minimum = null;
      Node minimumParent = null;
      Node currentNode = deleteNode.getRight();
      while(currentNode != null) {
        minimumParent = minimum;
        minimum = minimumParent;
        currentNode = currentNode.getLeft();
      }
      if(minimum != deleteNode.getRight()){
        minimumParent.setLeft(minimum.getRight());
        minimum.setRight(deleteNode.getRight());
      }
      return minimum;
    }

    //전위 순회
    public ArrayList<Integer> preorderTree(Node root, int depth, ArrayList<Integer> list) {   
      if (root != null) {
        list.add(root.getData());
        preorderTree(root.getLeft(), depth + 1, list);
        preorderTree(root.getRight(), depth + 1, list);
      }
      return list;
    }
    //중위 순회
    public ArrayList<Integer> inorderTree(Node root, int depth, ArrayList<Integer> list) {  
      if (root != null) {
        inorderTree(root.getLeft(), depth + 1, list);
        list.add(root.getData());
        inorderTree(root.getRight(), depth + 1, list);
      }
      return list;
    }
    //후위 순회
    public ArrayList<Integer> postorderTree(Node root, int depth, ArrayList<Integer> list) {  
      if (root != null) {
        postorderTree(root.getLeft(), depth + 1, list);
        postorderTree(root.getRight(), depth + 1, list);
        list.add(root.getData());
      }
      return list;
    }
  }
}

[Java] Map 정리

pongic — Wed, 28 Sep 2022 18:42:20 +0900

Map이란?

Map 인터페이스는 키(Key)와 값(Value)으로 구성된 객체를 저장하는 구조를 가지고 있다. 여기서 이 객체를 Entry 객체라고 하는데, 이 Entry 객체는 키와 값을 각각 Key 객체와 Value 객체로 저장한다. Map 인터페이스를 구현한 클래스에는 HashMap, HashTable, TreeMap, SortedMap 등이 있다.

Map은 키는 중복 저장될 수 없지만, 값은 중복 저장이 가능하다. 키의 역할이 값을 식별하는 것이다.

만약 저장된 키와 동일한 키로 값을 저장하면, 기존의 값이 새로운 값으로 대치된다.

Map 인터페이스를 구현한 클래스에서 공통적으로 사용 가능한 메서드

put(Object key, Object value)

주어진 키로 값을 저장한다. 해당 키가 새로운 키일 경우 null을 리턴 하지만, 동일한 키가 있을 경우에는 기존의 값을 대체하고 대체되기 이전의 값을 리턴한다. Object 타입을 리턴한다.

containsKey(Object key)

주어진 키가 있으면 true 없으면 false를 리턴한다. boolean 타입을 리턴한다.

containsValue(Object value)

주어진 값이 있으면 true 없으면 false를 리턴한다. boolean 타입을 리턴한다.

entrySet()

키와 값의 쌍으로 구성된 모든 Map.Entry 객체를 Set에 담아서 리턴한다. Set 타입을 리턴한다.

get(Object key)

주어진 키에 해당하는 값을 리턴한다. Object 타입을 리턴한다.

isEmpty()

컬렉션이 비어 있는지 확인한다. boolean 타입을 리턴한다.

keySet()

모든 키를 Set 객체에 담아서 리턴한다. Set 타입을 리턴한다.

size()

저장된 Entry 객체의 총 갯수를 리턴한다. int 타입을 리턴한다.

values()

저장된 모든 값을 Collection에 담아서 리턴한다. Collection 타입을 리턴한다.

clear()

모든 Map.Entry(키와 값)을 삭제한다.

remove(Object key)

주어진 키와 일치하는 Map.Entry를 삭제하고 값을 리턴한다. Object 타입을 리턴한다.

HashMap

HashMap은 Map 인터페이스를 구현한 대표적인 클래스이다.

해시 함수를 통해 키와 값이 저장되는 위치를 결정하므로, 사용자는 그 위치를 알 수 없고, 삽입되는 순서와 위치 또한 관계가 없다. 많은 양의 데이터를 검색하는 데 있어서 뛰어난 성능을 보인다.

Map.Entry 인터페이스에서 사용가능한 메서드

equals(Object o)

동일한 Entry 객체인지 비교합니다. boolean 타입을 리턴한다.

getKey()

Entry 객체의 Key 객체를 반환합니다. Object 타입을 리턴한다.

getValue()

Entry 객체의 Value 객체를 반환합니다. Object 타입을 리턴한다.

hashCode()

Entry 객체의 해시코드를 반환합니다. int 타입을 리턴한다.

setValue(Object value)

Entry 객체의 Value 객체를 인자로 전달한 value 객체로 바꿉니다. Object 타입을 리턴한다.

HashMap 예제

import java.util.*;

public class HashMapExample {
    public static void main(String[] args) {

	    // HashMap 생성
        HashMap<String, Integer> map = new HashMap<>();

        // Entry 객체 저장
        map.put("피카츄", 85);
        map.put("꼬부기", 95);
        map.put("야도란", 75);
        map.put("파이리", 65);
        map.put("피존투", 15);

        // 저장된 총 Entry 수 얻기
        System.out.println("총 entry 수: " + map.size());

        // 객체 찾기
        System.out.println("파이리 : " + map.get("파이리"));
				
        // key를 요소로 가지는 Set을 생성 -> 아래에서 순회하기 위해 필요하다
        Set<String> keySet = map.keySet();

        // keySet을 순회하면서 value를 읽어온다.
        Iterator<String> keyIterator = keySet.iterator();
        while(keyIterator.hasNext()) {
            String key = keyIterator.next();
            Integer value = map.get(key);
            System.out.println(key + " : " + value);
        }

        // 객체 삭제
        map.remove("피존투");

        System.out.println("총 entry 수: " + map.size());

        // Entry 객체를 요소로 가지는 Set을 생성 -> 아래에서 순회하기 위해 필요하다.
        Set<Map.Entry<String, Integer>> entrySet = map.entrySet();

        // entrySet을 순회하면서 value를 읽어온다. 
        Iterator<Map.Entry<String, Integer>> entryIterator = entrySet.iterator();
        while(entryIterator.hasNext()) {
            Map.Entry<String, Integer> entry = entryIterator.next();
            // Map.Entry 인터페이스의 메서드
            String key = entry.getKey(); 
            // Map.Entry 인터페이스의 메서드
            Integer value = entry.getValue(); 
            System.out.println(key + " : " + value);
        }

        // 객체 전체 삭제
        map.clear();
    }
}

/* 출력
총 entry 수: 5
파이리 : 65
야도란 : 75
꼬부기 : 95
파이리 : 65
피카츄 : 85
피존투 : 15
총 entry 수: 4
야도란 : 75
꼬부기 : 95
파이리 : 65
피카츄 : 85
*/

Map은 키와 값을 쌍으로 저장하기 때문에 iterator()를 직접 호출할 수 없다. 대신 keySet()이나 entrySet()메서드를 이용해 Set 형태로 반환된 컬렉션에 iterator()를 호출하여 반복자를 만든 후 순회할 수 있다.

HashTable

HashMap과 내부 구조가 동일하며 사용 방법 또한 매우 유사하다.

HashTable 예제

import java.util.*;

public class HashTableExample {
    public static void main(String[] args){

        HashTable<String, String> map = new Hashtable<String, String>();

        map.put("Spring", "345");
        map.put("Summer", "678");
        map.put("Fall", "91011");
        map.put("Winter", "1212");

        System.out.println(map);

        Scanner scanner = new Scanner(System.in);

        while (true) {
            System.out.println("아이디와 비밀번호를 입력해 주세요");
            System.out.println("아이디");
            String id = scanner.nextLine();

            System.out.println("비밀번호");
            String password = scanner.nextLine();

            if (map.containsKey(id)) {
                if (map.get(id).equals(password)) {
                    System.out.println("로그인 되었습니다.");
                    break;
                } 
                else System.out.println("비밀번호가 일치하지 않습니다. ");
            } 
            else System.out.println("입력하신 아이디가 존재하지 않습니다.");
        }
    }
}

[알고리즘] 탐욕 (Greedy) 알고리즘

pongic — Tue, 27 Sep 2022 19:35:23 +0900

탐욕 알고리즘(Greedy Algorithm)이란?

말 그대로 선택의 순간마다 당장 눈앞에 보이는 최적의 상황만을 쫓아 최종적인 해답에 도달하는 방법이다. 탐욕 알고리즘은 최적해를 구하는 데에 사용되는 근사적인 방법이다.

탐욕 알고리즘은 여러 경우 중 하나를 결정해야 할 때마다 그 순간에 최적이라고 생각되는 것을 선택해 나가는 방식으로 진행하여 최종적인 해답에 도달한다.

탐욕 알고리즘으로 문제를 해결하는 방법

선택 절차 (Selection Procedure) : 현재 상태에서의 최적의 해답을 선택한다.
적절성 검사(Feasibility Check): 선택된 해가 문제의 조건을 만족하는지 검사한다.
해답 검사(Solution Check): 원래의 문제가 해결되었는지 검사하고, 해결되지 않았다면 선택 절차로 돌아가 위의 과정을 반복한다.

탐욕 알고리즘을 적용하기 위해 필요한 조건

탐욕적 선택 속성(Greedy Choice Property) : 앞의 선택이 이후의 선택에 영향을 주지 않는다.
최적 부분 구조(Optimal Substructure) : 문제에 대한 최종 해결 방법은 부분 문제에 대한 최적 문제 해결 방법으로 구성된다.

A에서 B를 거쳐 C까지 가는 최단 경로를 찾는다고 가정해보자. A에서 B까지 가는 경로는 3가지가 있으며 C까지도 마찬가지로 3가지 경로가 있다 A에서 C까지 가는 최단 경로는 20km + 80km이다. 이 경로는 A에서 B까지 가는 최단 경로와 B에서 C까지 가는 최단 경로로 구성된다. 즉, A에서 C까지 가는 최단 경로는 각각의 부분 문제인 1) A에서 B까지 가는 최단 경로 2) B에서 C까지 가는 최단 경로의 문제의 해결 방법의 합이다.

문제의 최적 해결 방법은 부분 문제에 대한 최적 해결 방법으로 구성된다.

탐욕 알고리즘은 항상 최적의 결과를 도출하는 것은 아니지만, 어느 정도 최적에 근사한 값을 빠르게 도출할 수 있는 장점이 있다. 이 장점으로 탐욕 알고리즘은 근사 알고리즘으로 사용할 수 있다.

근사 알고리즘

그리디 알고리즘은 100% 최적해를 보장해주지 않는다. 다만, 어느 정도 적합한 수준의 해답을 알려준다. 따라서, 최적이 아닌 "되는가" 또는 "적당히 괜찮은 방법"을 찾을 때에는 사용할 수 있다. 특히, 계산속도가 정확한 알고리즘에 비해서 빠른 경우가 많기 때문에 실용적으로 사용이 가능하다. 하지만 이게 정말로 "적당히" 괜찮은지에 대해서 알려면 정확한 증명이 수반될 수 있다. 또한, 해답을 찾아가는 과정에 있어서 그리디로 구한 값을 비교값으로 설정할 수가 있다.

탐욕 알고리즘 사용 예시

돈 거슬러 주기

물견 가격이 총 4040원이 나왔고 계산을 하기 위해 5000원을 내밀며 거스름돈은 동전의 개수를 최소한으로 하여 거슬러야 한다. 탐욕 알고리즘에서 동전의 개수를 헤아리는 일은 우리가 일반적으로 거스름돈으로 동전을 선택하는 방법과 동일하다.

거스름돈 5000 - 4040 = 960원을 채우기 위해서 먼저, 500원짜리 동전 한 개를 선택한다. 그리고 100원짜리 동전 네 개를 선택하고 그다음엔 50원짜리, 10원짜리 각각 하나씩 선택한다.

탐욕 알고리즘의 문제 해결 과정에 적용시키면

선택 절차 : 거스름돈의 동전 개수를 줄이기 위해 현재 가장 가치가 높은 동전을 우선 선택한다.
적절성 검사 : 1번 과정을 통해 선택된 동전들의 합이 거슬러줄 금액을 초과하는지 검사한다. 초과하면 가장 마지막에 선택한 동전을 선택하고, 1번으로 돌아가 한 단계 작은 동전을 선택한다.
해답 검사 : 선택된 동전들의 합이 거슬러줄 금액과 일치하는지 검사한다. 액수가 부족하면 1번 과정부터 다시 반복

public static int coinBack(int money) {
  int[] coin = {500, 100, 50, 10, 5, 1}; // 가지고 있는 동전
  int result = 0;   // 반환할 값
  int count = 0;    // 동전 개수

  for (int el : coin) {  // coin 배열 안에 있는 원소로 순회
    if (money > 0) {
      count = money / el;
      result += count;
      money = money - (el * count);
    }
  }
  return result;
}

[알고리즘] 시간복잡도 (Time Complexity) 개념 정리

pongic — Tue, 27 Sep 2022 13:11:10 +0900

시간 복잡도

문제를 해결하기 위해 알고리즘의 로직을 코드로 구현할 때 입력값의 변화에 따라 연산을 실행할 때, 연산 횟수에 비해 시간이 얼마만큼 걸리는가를 의미한다.

시간 복잡도 표기법

Big - O (빅 - 오)
Big - Ω (빅 - 오메가)
Big - θ (빅 - 세타)

위 세 가지 표기법은 각각 최악, 최선, 평균의 경우에 대하여 나타내는 방법이다. 이 중 Big - O 표기법이 가장 자주 사용된다. Big - O 표기법은 최악의 경우를 고려하기 때문에 프로그램이 실행되는 과정에서 소요되는 최악의 시간까지 고려할 수 있다.

O(1)

Constant complexity라고 하며, 입력값이 증가하더라도 시간이 늘어나지 않는다.

입력값의 크기와 상관없이, 즉시 출력값을 얻어낼 수 있다는 의미이다.

public int algorithm(int[] arr, int index) {
  return arr[index];
}

int[] arr = new int[]{1,2,3,4,5};
int index = 1;
int results = algorithm(arr, index);
System.out.println(results); 

/* 출력
2
*/

이 알고리즘에선 입력값의 크기가 아무리 커져도 즉시 출력값을 얻어낼 수 있다. arr의 길이가 아무리 커져도 해당 index에 접근해 값을 반환할 수 있다.

O(log n)

logarithmic complexity라고 부르며 O(1)다음으로 빠른 시간 복잡도를 가진다. 이진 탐색 트리(Binary Search Tree)가 그 예이다. up & down을 예시로 들면 매번 숫자를 제시할 때마다 경우의 수가 절반이 줄어들기 때문에 O(log n)의 시간 복잡도를 가진 알고리즘이다.

O(n)

linear complexity라고 부르며, 입력값이 증가함에 따라 시간 또한 같은 비율로 증가하는 것을 의미한다.

입력값이 1일 때 1초의 시간이 걸리고, 입력값을 10배로 증가시켰을 때 10초가 걸리는 알고리즘은 O(n)의 시간 복잡도를 가진다고 말할 수 있다.

public void algorithm1(int n) {
	for(int i = 0; i < n; i++) {
	// do something for 1 second
	}
}

public void algorithm2(int n) {
	for(int i = 0; i < n * 2; i++) {
	// do something for 1 second
	}
}

algorithm1 함수에선 입력값(n)이 1 증가할 때마다 코드 실행 시간이 1초씩 증가한다. 입력값이 증가하면 같은 비율로 시간이 증가하고 있다. algorithm2 함수에선 입력값이 1 증가할 때마다 코드의 실행 시간이 2초씩 증가한다. 그러면 O(2n)이라고 생각할 수 있지만 Big - O 표기법으로는 O(n)으로 표시한다.5배 10배로 증가하더라도 O(n) 으로 표시한다.

O(n^2)

quadratic complexity라고 부르며, 입력값이 증가함에 따라 시간이 n의 제곱수의 비율로 증가하는 것을 의미한다.

public void algorithm1(int n) {
	for(int i = 0; i < n; i++) {
		for(int j = 0; j < n; j++) {
			// do something for 1 second
		}
	}
}

public void algorithm2(int n) {
	for(int i = 0; i < n; i++) {
		for(int j = 0; j < n; j++) {
			for(int k = 0; k < n; k++) {
				// do something for 1 second
			}
		}
	}
}

n^3과 n^5 모두 O(n^2)로 표기한다.

O(2^n)

exponential complexity라고 부르며 Big - O 표기법 중 가장 느린 시간 복잡도를 가진다.

public int fibonacci(int n) {
	if(n <= 1) {
		return 1;
	}
	return fibonacci(n - 1) + fibonacci (n - 2);
}

재귀로 구현하는 피보나치 수열은 O(2^n)의 시간 복잡도를 가진 대표적인 알고리즘이다.

[Java / 자료구조] 그래프 (Graph) 정리

pongic — Mon, 26 Sep 2022 19:47:14 +0900

그래프(Graph)

그래프는 여러 개의 점들이 서로 복잡하게 연결되어 있는 관계를 표현한 자료구조이다.

그래프의 구조

직접적인 관계가 있는 경우 두 점 사이를 이어주는 선이 있다.
간접적인 관계라면 몇 개의 점과 선에 걸쳐 이어진다.
하나의 점을 그래프에서는 정점(vertex)라고 표현하고 하나의 선은 간선(edge)라고 한다.

그래프의 표현 방식

인접 행렬

두 정점을 바로 이어주는 간선이 있다면 두 정점은 인접하다고 이야기한다. 인접 행렬을 서로 다른 정점들이 인접한 상태인지를 표시한 행렬로 2차원 배열의 형태로 나타낸다. 만약 A라는 정점과 B라는 정점이 이어져 있다면 1(true), 이어져 있지 않다면 0(false)으로 표시한 일종의 표이다.

1 2 3 4 5 6

1 0 1 0 0 1 0

2 1 0 1 1 1 0

from 3 0 1 0 1 0 0

4 0 1 1 0 1 1

5 1 1 0 1 0 0

6 0 0 0 1 0 0

인접 행렬 사용

한 개의 큰 표와 같은 모습을 한 인접 행렬은 두 정점 사이에 관계가 있는지, 없는지 확인하기에 용이하다.
- A에서 B로 진출하는 간선이 있는지 파악하기 위해선 0번째 줄의 1번째 열에 어떤 값이 저장되어 있는지 바로 확인할 수 있다.
가장 빠른 경로를 찾고자 할 때 주로 사용된다.

인접 리스트

각 정점이 어떤 정점과 인접하는지를 리스트의 형태로 표현한다. 각 정점마다 하나의 리스트를 가지고 있으며, 이 리스트는 자신과 인접한 다른 정점을 담고 있다.

A[i] = i와 연결된 정점이 링크드 리스트(Linked List)의 형태로 들어가 있다.

*주의 : 정점이 아닌 간선임*

A[1] = 2 5

A[2] = 1 3 4 5

A[3] = 2 4

A[4] = 3 5 2 6

A[5] = 1 2 4

A[6] = 4

인접 리스트 사용

메모리를 효율적으로 사용하고 싶을 때 사용한다

그래프 용어들

정점 (vertex)

노드(node)라고도 하며 데이터가 저장되는 그래프의 기본 원소이다.

간선 (edge)

정점 간의 관계를 나타낸다. (정점을 이어주는 선)

인접 정점 (adjacent vertex)

하나의 정점에서 간선에 의해 직접 연결되어 있는 정점을 뜻한다.

가중치 그래프 (weighted Graph)

연결의 강도(추가적인 정보)가 얼마나 되는지 적혀 있는 그래프를 뜻한다.

비가중치 그래프 (unweighted Graph)

연결의 강도가 적혀 있지 않은 그래프를 뜻한다.

무(방)향 그래프 (undirected graph)

A에서 B로 갈 수 있듯, 반대로 B에서 A로 가는 것도 가능하다. 하지만 단방향(directed) 그래프로 구현되면 A에서 B로 갈 수 있지만 B에서 A로 가는 것은 불가능하다.

진입 차수 (in-degree) / 진출 차수(out-degree)

한 정점에 진입(들어오는 간선)하고 진출(나가는 간선)하는 간선이 몇 개인지를 나타낸다.

인접 (adjacency)

두 정점 간에 간선이 직접 이어져 있다면 이 두 정점은 인접한 정점이다.

자기 루프 (self loop)

정점에서 진출하는 간선이 곧바로 자기 자신에게 진입하는 경우 자기 루프를 가졌다라고 표현한다. 다른 정점을 거치지 않는다는 것이 특징이다.

사이클(cycle)

한 정점에서 출발하여 다시 해당 정점으로 돌아갈 수 있다면 사이클이 있다고 표현한다.

[Java] StringBuilder와 StringBuffer 정리

pongic — Mon, 26 Sep 2022 14:10:55 +0900

StringBuilder

한번 생성된 String 클래스의 인스턴스는 여러 개의 문자열을 더할 때 매번 새로운 인스턴스를 생성해야 한다. 만약 100만개의 문자열이 있는데 모두 더하는 작업이 필요하다면 인스턴스 생성과정이 100만번 이루어져야 하기 때문에 매우 비효율적이다. 그래서 StringBuilder를 사용한다.

StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append("문자열 ").append("연결");
String str = stringBuilder.toString();
System.out.println(stringBuilder);
System.out.println(str);

/* 출력
문자열 연결
문자열 연결
*/

먼저 StringBuilder의 객체를 생성한 후 append()의 인자로 연결하고자 하는 문자열을 넣어서 StringBuilder의 객체를 통해 호출한다. 변수에 문자열을 할당할 때에는 toString()메서드를 사용한다

StringBuffer

StringBuffer 클래스의 인스턴스는 그 값을 변경할 수도 있고 추가할 수도 있다. StringBuffer 클래스는 내부적으로 버퍼(buffer)라고 하는 독립적인 공간을 가진다. 버퍼 크기의 기본값은 16개의 문자를 저장할 수 있는 크기이다. 또한 생성자를 통해 그 크기를 별도로 설정할 수 있다.

덧셈 연산자를 이용해 String 인스턴스의 문자열을 결합하면, 내용이 합쳐진 새로운 String 인스턴스를 생성한다.

참고로 덧셈 연산자를 문자열과 함께 사용하면 자동으로 문자열로 형변환이 이뤄지고 문자열이 결합된다. 따라서 문자열을 많이 결합할수록 공간이 낭비되고 속도 또한 느려진다. 하지만 StrinBuffer인스턴스를 사용하면 문자열을 바로 추가할 수 있으므로 공간의 낭비도 없고 속도도 빨라진다.

StringBuffer에서 사용가능한 메서드

append()

인수로 전달된 값을 문자열로 변환한 후, 해당 문자열의 마지막에 추가한다. String 클래스의 concat()과 같은 결과이지만 속도가 훨씬 빠르다.

StringBuffer str = new StringBuffer("Java");
System.out.println("문자열 : " + str);
System.out.println(str.append(" programming"));
System.out.println("append() 메서드 호출 후 문자열 : " + str);

/* 출력
문자열 : Java
Java programming
append() 메서드 호출 후 문자열 : Java programming
*/

capacity()

StringBuffer 인스턴스의 현재 버퍼 크기를 반환한다. int 타입을 리턴한다.

StringBuffer str1 = new StringBuffer();
StringBuffer str2 = new StringBuffer("Java");
System.out.println(str1.capacity());
System.out.println(str2.capacity());

/* 출력
16
20
*/

delete(int start, int end) / deleteCharAt(int index)

전달된 인덱스에 해당하는 부분 문자열을 해당 문자열에서 제거한다. 또한 deleteCharAt() 사용하면 특정 위치의 문자 한 개만 제거할 수도 있다.

StringBuffer str = new StringBuffer("Java Oracle");
System.out.println("문자열 : " + str);
System.out.println(str.delete(4, 8));
System.out.println(str.deleteCharAt(1));
System.out.println("deleteCharAt() 메소드 호출 후 문자열 : " + str);

/* 출력
문자열 : Java Oracle
Javacle
Jvacle
deleteCharAt() 메소드 호출 후 문자열 : Jvacle
*/

delete()메서드를 사용하여 해당 문자열에서 인덱스가 4인 위치의 문자부터 7인 위치의 문자까지를 삭제한다.

insert()

인수로 전달된 값을 문자열로 변환한 후, 해당 문자열의 지정된 인덱스 위치에 추가한다.

StringBuffer str = new StringBuffer("Java Programming!!");
System.out.println("문자열 : " + str);
System.out.println(str.insert(4, "Script"));
System.out.println("insert() 메서드 호출 후 문자열 : " + str);

/* 출력
문자열 : Java Programming!!
JavaScript Programming!!
insert() 메서드 호출 후 문자열 : JavaScript Programming!!
*/

[Java / 자료구조] 트리 (Tree) 정리

pongic — Mon, 26 Sep 2022 12:34:55 +0900

트리(Tree)란?

Tree는 이름 그대로 나무를 거꾸로 뒤집어 놓은 형태를 가지고 있다. 그래프의 여러 구조 중 단방향 그래프의 한 구조로, 하나의 뿌리로부터 가지가 사방으로 뻗은 형태이다.

데이터가 바로 아래에 있는 하나 이상의 데이터에 무방향으로 연결된 계층적 자료구조이다. 데이터를 순차적으로 나열시킨 선형 구조가 아니라, 하나의 데이터 아래에 여러 개의 데이터가 존재할 수 있는 비선형 구조이다.

아래로만 뻗어나가기 때문에 사이클이 없다.

트리 구조는 루트(root)라는 하나의 꼭짓점 데이터를 시작으로 여러 개의 데이터를 간선(edge)으로 연결한다. 각 데이터를 노드(Node)라고 하며, 두 개의 노드가 상하 계층으로 연결되면 부모/자식 관계를 가진다. A는 B와 C의 부모 노드(Parent Node)이고, B와 C는 A의 자식 노드(Childe Node)이다. 자식이 없는 노드는 리프 노드(Leaf Node)라고 부른다.

깊이(depth)

루트로부터 하위 계층의 특정 노드까지의 깊이(depth)를 표현할 수 있다. 루트 노드는 깊이가 0이고 B와 C의 깊이는 1, D, E, F, G의 깊이는 2이다.

레벨(Level)

같은 깊이를 가지고 있는 노드를 묶어서 레벨(level)로 표현할 수 있다. A의 Level은 1이다. B와 C의 Level은 2이다. D, E, F, G의 레벨은 3이다. 같은 레벨에 나란히 있는 노드를 형제 노드(Sibling Node)라고 한다.

높이(Height)

리프 노드(Leaf Node)를 기준으로 루트까지의 높이(Height)를 표현할 수 있다. 부모 노드는 자식 노드의 가장 높은 height값+1 한 값을 높이로 가진다. 각 리프 노드의 높이를 0으로 놓는다. H, I, E, F, J의 높이는 0이다. D와 G의 높이는 1이다. B와 C의 높이는 2이다. 이때, B는 D의 height + 1을 C는 G의 height + 1을 높이로 가진다. 루트 A의 높이는 3이다.

서브 트리(Sub Tree)

root에서 뻗어 나오는 큰 트리의 내부에 트리 구조를 갖춘 작은 트리를 서브 트리라고 한다. (D, H, I)로 이루어진 작은 트리도 서브 트리이고, (B, D, E) (C, F, G, J)도 서브 트리이다.

용어 정리

노드(Node) : 트리 구조를 이루는 모든 개별 데이터
루트(Root) : 트리 구조의 시작점이 되는 노드
부모 노드(Parent Node) : 두 노드가 상하관계로 연결되어 있을 때 상대적으로 루트에서 가까운 노드
자식 노드(Child Node) : 두 노드가 상하관계로 연결되어 있을 때 상대적으로 루트에서 먼 노드
리프 노드(Leaf Node) : 트리 구조의 끝 지점이고, 자식 노드가 없는 노드

트리의 실사용 예제

컴퓨터의 디렉터리 구조, 월드컵 토너먼트 대진표, 가계도, 조직도 등

[Java] StringTokenizer 클래스 정리

pongic — Mon, 26 Sep 2022 00:29:18 +0900

StringTokenizer

StringTokenizer 클래스는 문자열을 우리가 지정한 구분자로 문자열을 쪼개 주는 클래스이다. 그렇게 쪼개어진 문자열을 토큰(token)이라고 부른다. 이 클래스를 사용하기 위해서는 java.util.StringTokenizer를 import 해야 한다.

import java.util.StringTokenizer;

public class Main {
  public static void main(String[] args) {
    String str = "This is a string example using StringTokenizer";
    StringTokenizer tokenizer = new StringTokenizer(str);
    System.out.println(str);
    System.out.println();

    System.out.println("total tokens: " + tokenizer.countTokens());

    while(tokenizer.hasMoreTokens()) {
      System.out.println(tokenizer.nextToken());
    }
    System.out.println("total tokens: " + tokenizer.countTokens());
  }
}

/* 출력
This is a string example using StringTokenizer

total tokens: 7
This
is
a
string
example
using
StringTokenizer
total tokens: 0
*/

자주 사용하는 메서드

countTokens()

남아있는 token의 개수를 반환한다. 전체 token의 개수가 아닌 현재 남아있는 token 개수 int 타입을 리턴한다.

hasMoreElements() / hasMoreTokens()

두 메서드의 성능적인 차이 X, 둘 다 동일한 값을 반환한다. 현재 위치 뒤에 있는 문자열에서 하나 이상의 토큰을 사용할 수 있는 경우 true 그렇지 않으면 false를 반환한다. boolean 타입을 리턴한다.

nextElement() / nextToken()

다음의 토큰을 반환한다. nextElement는 Object 타입, nextToken은 String 타입을 리턴한다.

[Java] String 문자열 정리

pongic — Mon, 26 Sep 2022 00:28:12 +0900

String 문자열 이란?

기본적으로 String 타입은 큰따옴표(" ")로 감싸진 문자열을 의미한다. 자바는 String 클래스 타입을 사용하여 문자열을 다룬다. 다시 말해 문자열은 String 클래스를 통해 다루어지고 그 안에 있는 메서드들을 통해 여러 문자열 관련 메서드들을 사용할 수 있다.

String 타입의 변수 선언과 할당

// 문자열 리터럴을 String 타입의 변수 name에 할당하는 방법
String name1 = "Kim Coding";

// String 클래스의 인스턴스를 생성하는 방법
String name2 = new String("Kim Coding");

String 타입의 변수는 String 변수명; 으로 선언한다.
선언한 변수에 문자열을 할당하는 방법에는 두 가지가 있다.
- 문자열 리터럴을 할당하는 방법 : 변수 = "문자열";
- String 클래스의 인스턴스를 생성하여 할당하는 방법 : 변수 = new String("문자열");

위의 두 가지 방법은 공통적으로 참조 타입의 변수에 할당된다는 것이다. 즉, 실제 문자열의 내용을 값으로 가지고 있는 것이 아니라, 문자열이 존재하는 메모리 공간 상의 주소값을 저장하고 있다.

※ 문자열이 같은지 비교할 때에는 == 보다는 equals() 메서드를 사용해야 한다.

String 클래스의 메서드이다. 이 외에도 많은 메서드들이 있다.

charAt(int index)

해당 문자열의 특정 인덱스에 해당하는 문자를 반환한다. 해당 문자열의 길이보다 큰 인덱스나 음수를 전달하면 오류가 발생한다. char 타입을 리턴한다.

compareTo(String str) / compareToIgnoreCase(String str)

해당 문자열을 인수로 전달된 문자열과 사전 편찬 순으로 비교한다. 비교할 때 대소문자를 구분하여 비교한다. 두 문자열이 같다면 0, 해당 문자열이 인수로 전달된 문자열보다 작으면 음수, 크면 양수를 반환한다. int 타입을 리턴한다.

만약 비교할 때 대소문자를 구분하지 않기를 원한다면 compareToIgnoreCase(String str) 사용

concat(String str)

해당 문자열의 뒤에 인수로 전달된 문자열을 추가한 새로운 문자열을 반환한다. 만약 인수로 전달된 문자열의 길이가 0이면 해당 문자열을 그대로 반환한다. String 타입을 리턴한다.

indexOf(int ch or String str)

해당 문자열에서 특정 문자나 문자열이 처음으로 등장하는 위치의 인덱스를 반환한다. 만약 해당 문자열에 전달된 문자나 문자열이 포함되어 있지 않으면 -1을 반환한다. int 타입을 리턴한다.

trim()

해당 문자열의 맨 앞과 맨 뒤에 포함된 모든 공백 문자를 제거해 준다. String 타입을 리턴한다.

toLowerCase() / toUpperCase()

해당 문자열의 모든 문자를 소문자, 대문자로 변환시켜 준다. String 타입을 리턴한다.

[백준] 4673번 : 셀프 넘버

pongic — Sun, 25 Sep 2022 19:38:04 +0900

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

4673번: 셀프 넘버

셀프 넘버는 1949년 인도 수학자 D.R. Kaprekar가 이름 붙였다. 양의 정수 n에 대해서 d(n)을 n과 n의 각 자리수를 더하는 함수라고 정의하자. 예를 들어, d(75) = 75+7+5 = 87이다. 양의 정수 n이 주어졌을 때,

www.acmicpc.net

셀프 넘버는 1부터 10000까지 검사한 뒤, 생성자로 하는 수가 있으면 그 수를 출력하지 않는 것이다.

셀프넘버를 찾기위한 반복문 구성 Ex. d(75) = 75 + 7 + 5 = 87이 나오도록 구성해야한다.

각 자리수를 더해주기 위해서 나눗셈 단위로 number을 줄여 갈 것이기 때문에 number가 0보다 클 때까지 반복한다.

첫 째 자리수를 구하기 위해 % 연산자를 사용하여 sum에 다시 더해주고 이후 / 10만큼 줄인다.

이 때 return되는 sum은 생성자가 있는 수이기 때문에 출력되면 안된다. 그래서 boolean타입의 배열을 만들어 true를 받도록 하고 false만 출력하게끔 만든다.

완성 코드

[Java / 자료구조] 큐 (Queue) 정리

pongic — Sun, 25 Sep 2022 16:30:55 +0900

큐(Queue)란?

사전적 의미로는 무엇을 기다리는 사람, 혹은 줄을 서서 기다리는 것을 의미하는데 이처럼 줄을 지어 순서대로 처리되는 것이 큐라는 자료구조이다. 이 자료구조에서는 앞(front)과 뒤(back)가 존재한다. 가장 먼저 진입한 데이터가 가장 먼저 나가고 마지막에 진입한 데이터는 먼저 들어온 데이터가 모두 빠져나가기 전까지는 빠져나갈 수 없다.

큐 사용 사례

프린터 인쇄

※ 프린터 인쇄 과정

문서를 작성하고 출력 버튼을 누르면 해당 문서는 인쇄 작업(임시 기억 장치의) Queue에 들어간다.
프린터는 인쇄 작업 Queue에 들어온 문서를 순서대로 인쇄한다.

예시처럼 컴퓨터 장치들 사이에서 데이터를 주고받을 때, 각 장치 사이에 존재하는 속도의 차이나 시간 차이를 극복하기 위해 임시 기억 장치의 자료구조로 Queue를 사용한다. 이것을 통틀어 버퍼(buffer)라고 한다.

컴퓨터와 프린터 사이의 데이터 통신을 정리하면

일반적으로 프린터는 속도가 느리다.
CPU는 프린터와 비교하여 데이터를 처리하는 속도가 빠르다.
CPU는 빠른 속도로 인쇄에 필요한 데이터(Data)를 만든 다음, 인쇄 작업 Queue에 저장하고 다른 작업을 수행한다.
프린터는 인쇄 작업 Queue에서 데이터(Data)를 받아 일정한 속도로 인쇄한다.

큐의 특징

두 개의 입출력 방향을 가지고 있다. 입력, 출력 방향이 다르다.
FIFO(First In First Out) 혹은 LILO(Last In Last Out)이라고 부른다.
데이터는 하나씩 넣고 뺄 수 있다.

큐 클래스 메서드

offer(E e)

주어진 객체 삽입(enqueue) boolean 타입을 리턴한다.

add(E e)

주어진 객체 삽입(enqueue) boolean 타입을 리턴한다.

peek()

head에 위치한 객체를 리턴한다. 큐가 비었다면 null 리턴한다.

element()

큐의 head 리턴한다. 큐가 비었다면 Exception

poll()

front에 위치한 객체 리턴 후 제거(dequeue) 큐가 비었다면 null 리턴한다.

remove(E e)

특정 객체 E 제거한다. 큐가 비었다면 null

FIFO(First In First Out)

Ex.1 1, 2, 3, 4를 큐에 차례대로 넣는다.

Queue<Integer> queue = new LinkedList<>(); // int형 queue 선언

queue.add(1);     // queue에 값 1 추가
queue.add(2);     // queue에 값 2 추가
queue.add(3);     // queue에 값 3 추가
queue.add(4);     // queue에 값 4 추가

               queue.add(데이터)
출력 방향 <---------------------------< 입력 방향
             1 <- 2 <- 3 <- 4
         <---------------------------<
들어간 순서대로, 1번이 제일 먼저 들어가고 4번이 마지막으로 들어가게 된다.

Ex.2 큐가 빌 때까지 데이터를 전부 빼낸다.

queue.poll();       // queue에 첫번째 값을 반환하고 제거
queue.poll();
queue.poll();
queue.poll();

               queue.poll()
출력 방향 <---------------------------< 입력 방향

          <---------------------------<
1, 2, 3, 4
제일 첫 번째 있는 데이터부터 차례대로 나오게 된다.

[Java / 자료구조] 스택 (Stack) 정리

pongic — Sun, 25 Sep 2022 13:42:01 +0900

스택(Stack)이란?

Stack은 쌓다, 쌓이다, 포개지다 와 같은 뜻을 가지고 있다. 마치 접시를 쌓아 놓은 형태와 비슷한 이 자료구조는 직역 그대로, 데이터(data)를 순서대로 쌓는 자료구조이다. 다시 말해 가장 먼저 들어간 데이터는 가장 나중에 나올 수 있고 마지막에 들어간 데이터가 가장 먼저 나올 수 있는 구조이다.

스택의 사용 사례

음료수 진열대 (먼저 들어간 것이 나중에 나옴)
인터넷 브라우저 창 (뒤로 가기, 앞으로 가기 기능)

스택의 특징

입력과 출력이 하나의 방향으로 이루어지는 제한적인 접근에 있다.
LIFO(Last In First Out) 혹은 FILO(First In Last Out)이라고 부른다.
데이터는 하나씩 넣고 뺄 수 있다.

스택 클래스 메서드

empty()

해당 스택이 비어 있는지 확인한다. boolean 타입을 리턴한다.

peek()

해당 스택의 제일 상단에 있는(제일 마지막에 저장된) 요소를 반환한다.

pop()

해당 스택의 제일 상단에 있는 요소를 반환하고, 해당 요소를 스택에서 제거한다.

push(E item)

해당 스택의 제일 상단에 전달된 요소를 삽입한다.

search(Object o)

해당 스택에서 전달된 객체가 존재하는 위치의 인덱스를 반환한다. int 타입을 리턴한다.

이때 인덱스는 제일 상단에 있는 요소의 위치부터 0이 아닌 1부터 시작한다.

// search()

Stack<Integer> stack = new Stack<>();
stack.push(1);
stack.push(2);
stack.push(3);

System.out.println(stack.search(1));
System.out.println(stack.search("hello"));

/* 출력
3
-1
*/

search(1)은 1이라는 데이터가 stack에 있는지를 찾아서 인덱스 3으로 반환했다. 가장 먼저 삽입된 데이터 1이 마지막 인덱스 3을 갖게 된 것이다. Stack에 없는 데이터인 hello에 대한 결과는 -1을 반환했다.

LIFO(Last In First Out)

Ex1. 1, 2, 3, 4를 스택에 차례대로 넣는다.

Stack<Integer> stack = new Stack<>(); // Integer형 스택 선언

stack.push(1);
stack.push(2);
stack.push(3);
stack.push(4);
---------------------------
1 <- 2 <- 3 <- 4
---------------------------
들어간 순서대로, 1번이 제일 먼저 들어가고 4번이 마지막으로 들어가게 된다.

Ex2. 스택이 빌 때까지 데이터를 전부 빼낸다.

stack.pop();
stack.pop();
stack.pop();
stack.pop();
---------------------------

---------------------------
4, 3, 2, 1
제일 마지막에 있는 데이터부터 차례대로 나오게 된다.

[Java] next()와 nextLine()의 차이

pongic — Sun, 25 Sep 2022 12:48:23 +0900

Scanner클래스에는 String을 입력받는 메서드 next()와 nextLine()이 있다.

공통점은 둘 다 문자열로 반환시켜준다는 것이다.

next() 메서드는 공백(space)전까지 입력받은 문자열을 반환한다는 것이다.

nextLine() 메서드는 Enter를 치기 전까지 쓴 문자열 모두를 반환한다는 것이다.

Scanner.next()

Scanner in = new Scanner(System.in);

String str = in.next();
// next()는 공백 문자를 받아들이지 않는다.
// "a a"를 입력해봤을때를 가정해보자
System.out.println(str);

// 입력 
a a

/* 출력
a
*/

출력결과를 보면 a a 를 입력을 받았지만 처음에 a만 저장되어 출력되는 것을 확인할 수 있다. 다시 말해 next는 토큰의 개념으로 문자열을 입력받는데 해당 토큰에서 공백 문자는 구분자로 인식해 앞에 있는 a만 저장되는 것이다.

즉, 쉽게 말하면 Enter키는 물론 Space키도 구분자로 인식하여 저장되지 않는다.

Scanner.nextLine()

Scanner in = new Scanner(System.in);

String str = in.nextLine();
// nextLine()은 공백문자도 모두 저장하여 출력한다.
// "a a"를 입력해봤을때를 가정해보자.
System.out.println(str);

// 입력 
a a

/* 출력
a a
*/

공백 문자와 상관없이 콘솔 창 한 줄(Line)에 있으면 모두 문자열로 인식해 String변수로 리턴한다. a a 를 입력값으로 넣어주면 공백 문자와 상관없이 모두 저장된 것을 확인할 수 있다.

next()와 nextLine() 동시에 사용하면?

Scanner in = new Scanner(System.in);
String str1 = in.next();
System.out.println("str1 : " + str1);
String str2 = in.nextLine();
System.out.println("str2 : " + str2);

// 입력
a a

/* 출력 결과
str1 : a
str2 :  a
*/

위와 같이 나오는 이유는 next()로 받고 남은 " a"가 In.nextLine()으로 넘어가기 때문이다. " a" 라는 버려진 문자열은 지금 버퍼에 남겨져 있는 상태인데 버퍼를 처리하지 않고 다시 str2를 입력받으려고 하면 버퍼 측에서는 이미 저장되어 있는 " a"를 출력하는 것이다.

해결방법 : 버퍼 처리방법

Scanner in = new Scanner(System.in);
String str1 = in.next();
System.out.println("str1 : " + str1);
in.nextLine(); 		 //  nextLine() 메서드 호출
String str2 = in.nextLine();
System.out.println("str2 : " + str2);

// 입력
a a
b b

/* 출력 결과
str1 : a
str2 : b b
*/

위와 같이 nextLine()으로 변수에 담기 전에 메서드만 호출해 버퍼를 지워주면 문제가 해결된다.

[Java] Set 정리

pongic — Sun, 25 Sep 2022 00:43:36 +0900

Set이란?

Set은 요소의 중복을 허용하지 않고, 저장 순서를 유지하지 않는 컬렉션이다.

대표적인 Set 클래스에는 HashSet, TreeSet이 있다.

이외에 LinkedHashSet이 있는데 다른 Set과는 다르게 입력 순서를 보장해준다.

Set 인터페이스 정의된 메서드

add(Object o)

주어진 객체를 추가하고, 성공하면 true를 중복 객체면 false를 리턴한다. boolean 타입을 리턴한다.

contains(Object o)

주어진 객체가 Set에 존재하는지 확인한다. boolean 타입을 리턴한다.

isEmpty()

Set이 비어있는지 확인한다. boolean 타입을 리턴한다.

iterator()

저장된 객체를 하나씩 읽어오는 반복자를 리턴한다. Iterator 타입을 리턴한다.

size()

저장되어 있는 전체 객체의 수를 리턴합니다. int 타입을 리턴한다.

clear()

Set에 저장되어 있는 모든 객체를 삭제합니다.

remove(Object o)

주어진 객체를 삭제합니다. boolean 타입을 리턴한다.

HashSet

Set 인터페이스를 구현한 가장 대표적인 컬렉션 클래스이다. Set 인터페이스의 특성을 그대로 물려받으므로 중복된 값을 허용하지 않으며, 저장 순서를 유지하지 않는다.

HashSet 예제

// HashSet 생성
HashSet<String > example = new HashSet<String>();

// HashSet에 객체 추가
example.add("Java");
example.add("Python");
example.add("C++");
example.add("Ruby");
example.add("Java");  // 위에 5번 코드와 중복

// 반복자 생성하여 it에 할당
Iterator it = example.iterator();

// 반복자를 통해 HashSet을 순회하여 각 요소들을 출력
while(it.hasNext()) {
	System.out.println(it.next());
}

/* 출력
Python
Java
Ruby
C++
*/

입력한 순서대로 출력되지 않고, Java를 두 번 추가했지만 한 번만 저장된 것을 확인할 수 있다.

TreeSet

이진 탐색 트리 형태로 데이터를 저장한다. 데이터의 중복 저장을 허용하지 않고 저장 순서를 유지하지 않는 Set 인터페이스의 특징을 그대로 유지한다.

이진 탐색 트리(Binary Search Tree)란 하나의 부모 노드가 최대 두 개의 자식 노드와 연결되는 이진 트리의 일종으로, 정렬과 검색에 특화된 자료 구조이다. 이때 최상위 노드를 루트라고 한다.

이진 탐색 트리는 모든 왼쪽 자식의 값이 루트나 부모보다 작고, 모든 오른쪽 자식의 값이 루트나 부모보다 큰 값을 가지는 특징이 있다.

위 그림의 각 노드들은 아래 Node 클래스를 인스턴스화한 인스턴스에 해당한다.

class Node {
	Object element; // 객체의 주소값을 저장하는 참조변수이다.
	Node left;      // 왼쪽 자식 노드의 주소값을 저장하는 참조변수이다.
	Node right;     // 오른쪽 자식 노드의 주소값을 저장하는 참조변수이다.
}

TreeSet 메서드

first()

정렬된 순서에서 첫번째 객체를 반환한다. Object 타입을 리턴한다.

last()

정렬된 순서에서 마지막 객체를 반환한다. Object 타입을 리턴한다.

higher(Object o)

지정된 객체중에서 큰 값중 제일 가까운값 반환한다. 없으면 null Object 타입을 리턴한다.

lower(Object o)

지정된 객체중에서 작은값중 제일 가까운값 반환한다. 없으면 null Object 타입을 리턴한다.

subSet(Object fromElement, Object toElement)

fromElement부터 toElement까지의 객체들을 반환한다. toElement는 미포함한다. SortedSet 타입을 리턴한다.

TreeSet 예제

// TreeSet 생성
TreeSet<String> example = new TreeSet<>();

// TreeSet에 요소 추가
workers.add("Lee Java");
workers.add("Park Hacker");
workers.add("Kim Coding");

System.out.println(workers);
System.out.println(workers.first());
System.out.println(workers.last());
System.out.println(workers.higher("Lee"));
System.out.println(workers.subSet("Kim", "Park"));

/* 출력
[Kim Coding, Lee Java, Park Hacker]
Kim Coding
Park Hacker
Lee Java
[Kim Coding, Lee Java]
*/

자동으로 사전 편찬 순에 따라 오름차순으로 정렬된 것을 확인할 수 있다. 이는 TreeSet의 기본 정렬 방식이 오름차순이기 때문이다.

[Java] 리스트 (List) 정리

pongic — Sat, 24 Sep 2022 23:20:53 +0900

리스트 (List) 란?

배열과 같이 객체를 일렬로 늘어놓은 구조를 가지고 있다. 객체를 인덱스(index)로 관리하기 때문에 객체를 저장하면 자동으로 인덱스가 부여되고, 인덱스로 객체를 검색, 추가, 삭제할 수 있는 등의 기능을 제공한다.

List 인터페이스를 구현한 클래스로는 ArrayList, Vector, LinkedList, Stack 등이 있다. 가장 많이 사용되는 것은 ArrayList와 LinkedList이다.

리스트의 특징

순서가 있고 중복을 허용한다.
인덱스로 관리하기 때문에 인덱스로 접근이 가능하다.
크기가 가변적이다.

List 인터페이스

리스트 인터페이스에서 공통적으로 사용 가능한 메서드

add(int index, Object element)

주어진 인덱스에 객체를 추가한다.

addAll(int index, Collection c)

주어진 인덱스에 컬렉션을 추가한다. boolean 타입을 리턴한다.

set(int index, Object element)

주어진 인덱스에 객체를 저장. Object 타입을 리턴한다.

indexOf(Object o) / lastIndex(Object o)

순방향 / 역방향으로 탐색하여 주어진 객체의 위치를 반환한다. int 타입을 리턴한다.

listIterator() / listIterator(int index)

List의 객체를 탐색할 수 있는 ListIterator 반환 / 주어진 index부터 탐색할 수 있는 ListIterator 타입을 리턴한다.

subList(int fromIndex, int toIndex)

fromIndex부터 toIndex에 있는 객체를 반환한다. List 타입을 리턴한다.

remove(int index)

주어진 인덱스에 저장된 객체를 삭제하고 삭제된 객체를 반환한다. Object 타입을 리턴한다.

remove(Object o)

주어진 객체를 삭제한다. boolean 타입을 리턴한다.

sort(Comparator c)

주어진 비교자(comparator)로 List를 정렬한다.

List 예제

// list 생성
List<String> list = new ArrayList<>();

// 일반적으로 리스트를 만든 뒤, add메서드를 사용하여 객체를 하나씩 저장한다.

// 객체 추가
list.add("a");
list.add("b");
list.add("c");

// 조회
for(String ele : list) {
	System.out.println(ele);
}

/* 출력
a
b
c
*/

// 선언과 동시에 값을 할당하려면 asList 사용
List<String> list = Arrays.asList(new String[]{"a","b","c"});

// 조회
for(String ele : list) {
	System.out.println(ele);
}

/* 출력
a
b
c
*/

ArrayList란?

List 인터페이스를 구현한 클래스로 컬렉션 프레임워크에서 가장 많이 사용된다. 기능적으로는 Vector와 동일하지만 Vector를 개선한 것이므로 Vector 보다 많이 사용된다.

객체가 인덱스로 관리된다는 점에서 배열과 유사하다. 그러나 배열은 생성될 때 크기가 고정되며, 크기를 변경할 수 없지만 ArrayList는 저장 용량을 초과하여 객체들이 추가되면, 자동으로 저장용량이 늘어나게 된다. 또한 데이터가 연속적으로 존재하여 데이터의 순서가 유지된다,

ArrayList<타입 매개변수> 객체명 = new ArrayList<타입 매개변수>(초기 저장 용량);

ArrayList<String> example = new ArrayList<String>();
// String 타입의 객체를 저장하는 ArrayList 생성
// 초기 용량이 인자로 전달되지 않으면 기본적으로 10으로 지정된다.

ArrayList에 객체를 추가하게 되면 인덱스(index) 0부터 차례대로 저장된다.

특정 인덱스의 객체를 제거하면, 바로 뒤 인덱스부터 마지막 인덱스까지 모두 앞으로 1씩 당겨진다.

ArrayList에 객체를 순차적으로 저장할 때에는 데이터를 이동하지 않아도 되므로, 작업 속도가 빠르지만, 중간에 위치한 객체를 추가, 삭제할 때에는 데이터 이동이 많이 일어나므로 속도가 저하된다.

반면 인덱스가 n인 요소인 데이터에 빠르게 접근이 가능하기 때문에 검색(읽기) 측면에서는 유리하다.

ArrayList 예제

// ArrayList를 생성하여 list에 할당
ArrayList<String> list = new ArrayList<String>();

// String 타입의 데이터를 ArrayList에 추가
list.add("Java");
list.add("egg");
list.add("tree");

// 저장된 총 객체 수 얻기
int size = list.size();

// 0번 인덱스의 객체 얻기
String skill = list.get(0);

// 저장된 총 객체 수 만큼 조회
for(int i = 0; i < list.size(); i++) {
	String str = list.get(i);
    System.out.println(i + ":" + str);
}

// for - each문으로 순회
for(String str : list) {
	System.out.println(str);
}

// 0번 인덱스 객체 삭제
list.remove(0);

LinkedList란?

ArrayList와 배열은 모든 데이터가 연속적으로 존재하지만, LinkedList에는 불연속적으로 존재하며, 이 데이터는 서로 연결되어 있다. LinkedList 컬렉션은 데이터를 효율적으로 추가, 삭제, 변경하기 위해 사용한다.

LinkedList의 각 요소(node)들은 자신과 연결된 이전 및 다음 요소의 주소값과 데이터로 구성되어 있다.

LinkedList에서 데이터를 삭제하려면, 삭제하고자 하는 요소의 이전 요소가 삭제하고자 하는 요소의 다음 요소를 참조하도록 변경한다. 링크를 끊어주는 방식이다. 배열처럼 데이터를 이동하기 위해 복사할 필요가 없기 때문에 처리 속도가 훨씬 빠르다. 데이터를 추가할 때에도 마찬가지이다.

※ 위 그림의 Apple과 Orange사이에 Mango라는 데이터를 추가하는 상황

Mango 객체가 생성된다.
Apple의 Next에 Mango의 주소값이 저장된다. 이때, Mango의 Prev에 Apple의 주소값이 저장된다.
Mango의 Next에 Orange의 주소값이 저장된다. 이때, Orange의 Prev에 Mango의 주소값이 저장된다

이처럼 LinkedList의 중간에 데이터를 추가하면 Next와 Prev에 저장되어 있는 주소값만 변경해주면 되므로, 각 요소들을 ArrayList처럼 뒤로 밀어내지 않아도 된다. 마찬가지로, 삭제한 경우에도 삭제한 데이터의 뒤에 위치하는 요소들을 앞으로 당기지 않아도 된다.

LinkedList 예제

// Linked List를 생성하여 list에 할당
ArrayList<String> list = new LinkedList<>();

// String 타입의 데이터를 LinkedList에 추가
list.add("Java");
list.add("egg");
list.add("tree");

// 저장된 총 객체 수 얻기
int size = list.size(); 

// 0번 인덱스의 객체 얻기
String skill = list.get(0);

// 저장된 총 객체 수 만큼 조회
for(int i = 0; i < list.size(); i++){
    String str = list.get(i);
    System.out.println(i + ":" + str);
}

// for-each문으로 순회
for (String str: list) {
    System.out.println(str);
}		

// 0번 인덱스 객체 삭제
list.remove(0);

ArrayList VS LinkedList

ArrayList는 다음과 같은 상황에 강점을 지닌다.

데이터를 순차적으로 추가하거나 삭제하는 경우
- 순차적으로 추가한다는 것은 0번 인덱스에서부터 데이터를 추가하는 것을 의미한다.
- 순차적으로 삭제한다는 것은 마지막 인덱스에서부터 데이터를 삭제하는 것을 의미한다.
데이터를 읽어들이는 경우
- 인덱스를 통해 바로 데이터에 접근할 수 있으므로 검색이 빠르다.

다음과 같은 상황에서 효율적이지 못하다.

중간에 데이터를 추가하거나, 삭제하는 경우
- 추가 또는 삭제 시, 해당 데이터의 뒤에 위치한 값들을 뒤로 밀어주거나 앞으로 당겨주어야 한다.

LinkedList는 다음과 같은 상황에 강점을 가진다.

중간에 위치하는 데이터를 추가하거나, 삭제하는 경우
- 데이터를 중간에 추가, 삭제하는 경우 Prev와 Next의 주소값만 변경하면 되므로, 다른 요소들을 이동시킬 필요가 없다.

따라서 데이터를 중간에 추가, 삭제하는 경우, LinkedList는 ArrayList보다 빠른 속도를 보여준다.

데이터의 잦은 변경이 예상될 땐 LinkedList, 데이터의 개수가 변하지 않는다면 ArrayList를 사용하는 것이 좋다.

2024.09.11 - [Language/Python] - [Python] 리스트 (List) 정리

[Python] 리스트 (List) 정리

개요 Python에서 가장 많이 사용되는 자료형 중 하나로, 여러 개의 값을 순서대로 저장할 수 있는 가변적인 시퀀스(sequence)이다. 리스트는 대괄호([])로 감싸고, 값들은 쉼표(,)로 구분한다. 리스트

pongic.tistory.com

[Java] 자바 컬렉션 프레임워크(Collection Framework) 정리

pongic — Sat, 24 Sep 2022 20:51:25 +0900

컬렉션 프레임워크란? ( Collection Framework )

자바에서는 다수의 데이터를 저장하기 위해 널리 알려져 있는 자료 구조를 바탕으로 객체들을 효율적으로 추가, 삭제, 검색할 수 있도록 컬렉션을 만들고, 관련된 인터페이스와 클래스를 포함시켜 두었다.

즉, 데이터를 저장하는 자료 구조와 데이터를 처리하는 알고리즘을 구조화하여 클래스로 구현해 놓은 것이다.

컬렉션 프레임워크가 제공하는 다양한 인터페이스와 구현 클래스를 활용하면, 보다 객체 지향적이고 재사용성 높은 코드를 작성할 수 있다.

컬렉션 프레임워크는 특정 자료 구조에 데이터를 추가, 삭제, 수정, 검색하는 등의 동작을 수행하는데 편리한 메서드들을 제공한다.

컬렉션 프레임워크 구조

컬렉션 프레임워크는 주요 인터페이스로 List, Set, Map을 제공한다.

List

List는 데이터의 순서가 유지되며, 중복 저장이 가능하다.

Ex. ArrayList, Vector, Stack, LinkedList 등

Set

Set은 데이터의 순서가 유지되지 않으며, 중복 저장이 불가능하다.

Ex. HashSet, TreeSet 등

Map

Map은 키와 값의 쌍으로 데이터를 저장한다. 데이터의 순서가 유지되지 않는다.

키는 식별하기 위해 사용되므로 중복 저장이 불가능하지만, 값은 중복 저장이 가능하다.

Ex. HashMap, LinkedHashMap, HashTable, TreeMap, Properties 등

List와 Set은 서로 공통점이 많아 위 그림과 같이 Collection 인터페이스로 묶인다.

Collection 인터페이스

collection 인터페이스에는 아래와 같은 메서드들이 정의되어있다.

add(Object o) / addAll(Collection c)

주어진 객체 및 컬렉션의 객체들을 컬렉션에 추가한다. boolean 타입을 리턴한다.

contains(Object o) / containsAll(Collection c)

주어진 객체 및 컬렉션이 저장되어 있는지 여부를 리턴한다. boolean 타입을 리턴한다.

iterator()

컬렉션의 iterator를 리턴한다.

equals(Object o)

컬렉션이 동일한지 여부를 확인한다. boolean 타입을 리턴한다.

isEmpty()

컬렉션이 비어있는지 여부를 확인한다. boolean 타입을 리턴한다.

size()

저장되어 있는 전체 객체 수를 리턴한다. int 타입을 리턴한다.

clear()

컬렉션에 저장된 모든 객체를 삭제한다.

remove(Object o) / removeAll(Collection c)

주어진 객체 및 컬렉션을 삭제하고 성공 여부를 리턴한다. boolean 타입을 리턴한다.

retainAll(Collection c)

주어진 컬렉션을 제외한 모든 객체를 컬렉션에서 삭제하고, 컬렉션에 변화가 있는지의 여부를 리턴합니다. boolean 타입을 리턴한다.

toArray()

컬렉션에 저장된 객체를 객체 배열(Object [])로 반환합니다.

toArray(Object[] a)

주어진 배열에 컬렉션의 객체를 저장해서 반환합니다.