알고리즘 문제를 풀다보면 대부분 처음 고민하게 되는 것은 어떻게 데이터를 받아오고, 정렬하할 것이다. 자바에서 데이터를 어떻게 저장하고, 어떻게 꺼내고, 어떻게 정렬할 것인가'는 거의 항상 컬렉션 프레임워크로 귀결된다.

자료구조(Data Structure)

• 데이터를 효율적으로 접근하기 위해 선택되는 데이터의 조직 및 저장 형식
• 데이터 값들의 모음, 값들 간의 관계, 그리고 적용 가능한 연산(검색/삽입/삭제 등)의 집합

자료구조의 분류

• 정적 자료구조(Static Data Structure): 크기가 고정된 자료 구조
  예) 배열(Array)
• 동적 자료구조(Dynamic Data Structure): 크기가 변할 수 있는 자료구조
  예) 리스트(List), 스택(Stack), 큐(Queue)

자료구조 선택 기준

• 데이터 접근 속도
• 메모리 사용 효율성
• 삽입/삭제의 효율성
• 순서 유지 여부
• 중복 데이터 허용 여부

컬렉션 프레임워크

• 표준화된 데이터 구조(자료구조)와 이를 처리하기 위한 클래스 / 인터페이스의 집합
• 데이터를 동적 크기로 관리하고, 삽입 / 삭제 / 검색 / 정렬 등을 효율적으로 처리할 수 있음
• 제네릭을 지원하여 타입 안정성(Type Safety) 보장
• 표준화된 메서드 제공

위의 표처럼 다양한 컬렉션 프레임 워크가 있다. 오늘은 그중에서 가장 근간이 되는 List 계열, Set 계열, Map 계열에 대해서 알아보고자 한다.

List 계열

List 계열 컬렉션 특징

• 순서가 있는 데이터 집합
• 중복 허용
• 저장된 순서를 유지
• 배열과 달리 크기가 동적으로 변함

대표 구현 클래스

• ArrayList
• LinkedList
• Vector

주요 메서드

1) 추가(Add)

2) 삭제/비우기(Remove/Clear)

3) 포함 여부(Contains)

4) 주요 메서드: 복사(Copy)

5) 비교 / 동등성(Equals / Hash)

6) 조회(Get)

7) 검색(Search)

8) 상태 확인

ArrayList

• 배열 기반 구현
• 인덱스를 통한 접근이 빠름(조회 유리)
• 중간 삽입/삭제 시 요소 이동 비용 때문에 성능 저하 가능
• 데이터 조회가 많고, 삽입/삭제가 적을 때

LinkedList

• 노드 기반 구현(각 노드가 이전 / 다음 노드 참조를 가짐)
• 삽입 / 삭제가 빠른 편(노드 연결만 변경)
• 인덱스 접근은 상대적으로 불리할 수 있음
• 데이터 삽입 / 삭제가 많고, 조회가 상대적으로 적을 때

Set 계열

Set 계열 컬렉션 특징

• 중복 허용하지 않음
• 순서 보장하지 않음(구현체에 따라 예외 있음)
• null 허용(보통 1개)
• “고유성”이 중요한 데이터에 유용

대표 구현 클래스

• HashSet
• LinkedHashSet
• TreeSet

HashSet

• 저장 순서 유지 X
• 내부적으로 HashMap 기반
• 추가/삭제/검색이 빠름(해시 기반)
• null 1개 저장 가능

  여기서 쓰이는 Hash라는 용어는 '데이터를 빠르게 저장하고 검색하기 위해서 사용하는 특별한 값 또는 기법'을 말하는데, 이는 데이터를 '고유한 숫자 값'으로 변환하는 과정을 말한다. => 여기서 고유한 숫자 = hashCode() 값

LinkedHashSet

• 저장 순서 유지 O
• 내부적으로 LinkedHashMap 기반(해시 + 연결 리스트)
• HashSet보다 약간 느릴 수 있음(연결 리스트 관리 비용)
• null 1개 저장 가능

TreeSet

• 데이터가 정렬된 상태로 유지(기본 오름차순)
• 사용자 정의 정렬이 필요하면 Comparator 사용 가능
• 내부적으로 레드-블랙 트리(균형 이진 탐색 트리) 기반
• null 저장 불가(정렬/비교 불가능)

Set 주요 메서드

1) 추가(Add)

2) 삭제 / 비우기(Remove / Clear)

3) 포함 여부(Contains)

4) 복사(Copy)

5) 비교 / 동등성(Equals / Hash)

6) 상태 확인

7) 순회(Iteration)

Iterator는 한마디로 컬렉션(Set/List 등)을 "하나씩 꺼내서 순회할 수 있게 해주는 도구(반복자)"로 Set은 인덱스가 없어서(get 메서드 같은 게 없음) 내부 요소를 하나씩 보려면 순회 방법이 필요하고, 그 표준 방식이 iterator()이다.

Set<String> set = new HashSet<>();
set.add("A");
set.add("B");

Iterator<String> it = set.iterator();

while (it.hasNext()) {
    String v = it.next();
    System.out.println(v);
}

for each 구문 또한 iterator 기반의 방법이다.

Map 계열

Map 계열 컬렉션 특징

• 키(Key)와 값(Value) 의 쌍으로 저장
• 키는 중복 불가, 값은 중복 가능
• 키를 통해 빠른 검색 가능
• null 허용 여부는 구현체에 따라 다름(TreeMap은 null key 불가)

대표 구현 클래스

• HashMap
• LinkedHashMap
• TreeMap

HashMap

• 저장 순서 유지 X
• 내부적으로 해시 테이블 사용
• null 키 1개 허용, null 값 여러 개 허용
• 빠른 검색/삽입/삭제

LinkedHashMap

• 저장 순서 유지 O
• 내부적으로 해시 테이블 + 연결 리스트
• null 키 1개 허용, null 값 여러 개 허용
• HashMap과 유사한 성능이지만 순서 관리 비용이 약간 추가될 수 있음

TreeMap

• 키 기준으로 정렬된 상태 유지(기본 오름차순)
• Comparator로 사용자 정의 정렬 가능
• 내부적으로 레드-블랙 트리 기반
• null 키 허용하지 않음

Map 주요 메서드

1) 추가/수정(Put & Compute)

2) 조회(Get)

3) 삭제(Remove)

4) 포함 여부(Contains)

5) 키/값/엔트리 뷰(View)

6) 복사(Copy)

7) 상태 확인

8) 반복/순회(Iteration)

9) 동등성(Equals / Hash)

자료구조를 이용한 정렬(Sort)

• 요소들을 특정 기준에 맞춰 오름차순 / 내림차순으로 배치하는 것
• 일반적으로 순서를 가지는 컬렉션(List) 이 정렬 대상이 된다.
• 배열 정렬: Arrays.sort()
• 컬렉션 정렬: Collections.sort()

// 배열 정렬
Arrays.sort(arr);

// 리스트 정렬
Collections.sort(list);

=> 실제 정렬은 모두 오름차순이 된다. 따라서 다른 정렬 기준으로 만들기 위해서 '정렬기준'가 필요하다.

정렬기준

자바에서는 객체 정렬 기준을 정의하는 방법은 두가지로 아래와 같다.

• Comparable : 객체가 '기본 정렬 기준'을 스스로 가짐
• Comparator : 객체 외부에서 '별도의 정렬 기준'을 만듬

Comparable 인터페이스

• 객체의 기본정렬 기준을 정의
• 클래스가 직접 implemets Comparable<T>로 구현
• compareTo(T o) 메서드를 구현하여 정렬 기준을 정의 예) 이름 순, 나이 순 등

  public interface Comparable<T> {
    public int compareTo(T o);
  }

반환값의 의미

• 0 : 현재 객체와 비교 대상 객체가 같음
• 양수 : 현재 객체가 비교 대상 객체보다 큼
• 음수 : 현재 객체가 비교대상 객체보다 작음

구현예시

// 구현예시 
import java.util.Objects;

class Student implements Comparable<Student> {
    private final String name;
    private final int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 기본 정렬 기준: age 오름차순
    @Override
    public int compareTo(Student other) {
        return Integer.compare(this.age, other.age);
    }

    @Override
    public String toString() {
        return name + "(" + age + ")";
    }
}


import java.util.*;

public class Main {
    public static void main(String[] args) {
        List<Student> students = new ArrayList<>();
        students.add(new Student("Min", 23));
        students.add(new Student("Yonu", 20));
        students.add(new Student("Soo", 21));

        Collections.sort(students); // compareTo 기준으로 정렬
        System.out.println(students);
        // 출력 예: [Yonu(20), Soo(21), Min(23)]
    }
}

Comparator 인터페이스

• 별도의 정렬 기준을 정의
• 정렬 기준이 여러개 필요할 때 유용
• 클래스 외부에서 정렬 기준을 정의하며, 특정 필드 / 사용자 정의 기준으로 정렬 할 수 있음
• compar(T o1, T o2) 메서드를 구현

  public interface Comparator<T> {
    int compare(T o1, T o2);
  }

  반환값의 의미

• 0 : 두 객체가 같음
• 양수 : 첫 번째 객체가 두 번째 객체보다 큼
• 음수 : 첫 번째 객체가 두 번째 객체보다 작음

구현예시

// 별도 클래스로 만들기
Collections.sort(names, new StringLengthComparator());
// 익명 내부 클래스로 만들기
Collections.sort(names, new Comparator<String>() {
    @Override
    public int compare(String o1, String o2) {
        return Integer.compare(o1.length(), o2.length());
    }
});
//람다로 만들기
Collections.sort(names, (o1, o2) -> {
    return Integer.compare(o1.length(), o2.length());
});

class Student {
    private final String name;
    private final int age;
    private final double gpa;

    public Student(String name, int age, double gpa) {
        this.name = name;
        this.age = age;
        this.gpa = gpa;
    }

    public String getName() { return name; }
    public int getAge() { return age; }
    public double getGpa() { return gpa; }

    @Override
    public String toString() {
        return name + "(age=" + age + ", gpa=" + gpa + ")";
    }
}
// 별도 클래스로 만들기

import java.util.Comparator;

class AgeAscComparator implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        // o1이 앞이면 음수, o2가 앞이면 양수, 같으면 0
        return Integer.compare(o1.getAge(), o2.getAge());
    }
}

// 익명 클래스
import java.util.*;

Comparator<Student> nameAsc = new Comparator<Student>() {
    @Override
    public int compare(Student o1, Student o2) {
        return o1.getName().compareTo(o2.getName()); // 이름 오름차순
    }
};
//람다 
import java.util.*;

Comparator<Student> ageAsc = (o1, o2) -> Integer.compare(o1.getAge(), o2.getAge());
Comparator<Student> gpaDesc = (o1, o2) -> Double.compare(o2.getGpa(), o1.getGpa());

Comparable vs Comparator

제네릭(Generic)의 정의

다양한 데이터 타입을 처리할 수 있는 클래스, 인터페이스, 메서드를 작성하는 기법이다.

제네릭의 장점

1. 컴파일 시점에 타입을 지정할 수 있어 타입 안정성(type safety) 을 제공함
2. 하나의 코드로 여러 타입에 대해 동작하도록 설계할 수 있어 코드 재사용성이 증가
3. 타입이 명확하므로 불필요한 형 변환(casting) 을 줄일 수 있음

제네릭 클래스(Generic Class)

클래스(또는 인터페이스) 정의에 타입 매개변수를 넣는 방식으로 해당 클래스 전체 범위에서 타입을 사용할 수 있다.

java
class Holder<T> {
    private T data;

    public Holder(T data) {
        this.data = data;
    }

    public T get() { return data; }
    public void set(T data) { this.data = data; }
}

• 제네릭 클래스의 선언

  • 클래스 또는 인터페이스 선언 시 <>에 타입 파라미터를 표시한다.
  • 타입 파라미터는 특별한 의미의 알파벳이라기보다, 임의의 참조형 타입을 의미한다.

  관례적으로 자주 쓰는 이름

  • T: Type
  • E: Element
  • K: Key
  • V: Value

• 제네릭 클래스의 객체 생성

  • 변수 선언 쪽과 생성자 쪽의 타입은 반드시 일치해야 한다.

    Holder<String> h1 = new Holder<String>("hello");
    System.out.println(h1.get()); // hello

  • 타입이 추론 가능한 경우, 생성자 쪽 타입은 생략할 수 있다. (Java 7+ 다이아몬드 연산자 <>)

    Holder<Integer> h2 = new Holder<>(100);
    System.out.println(h2.get()); // 100

  • 제네릭 타입을 지정하지 않는 raw type으로도 생성할 수 있지만 권장하지 않는다.
    → 타입 안정성이 깨지고, 타입 파라미터 T가 사실상 Object처럼 취급된다.

제네릭 메서드(Generic Method)

제네릭 메서드는 메서드 내부에서 사용할 타입 파라미터를 메서드가 직접 선언하는 방식이다.
즉, 클래스에 제네릭이 있든 없든 상관없이, 특정 메서드만 제네릭하게 만들 수 있다.

• 타입 파라미터를 사용하는 메서드
• 클래스의 타입 파라미터와는 별개로, 메서드 레벨에서 제네릭 타입을 정의하고 사용할 수 있음
• 제네릭 메서드를 정의하려면 반환 타입 앞에 타입 파라미터를 선언한다.
  • 형태: public static <T> T methodName(...)
• 호출할 때 타입 파라미터는 보통 컴파일러가 추론하므로 생략 가능
• 필요하면 타입을 명시적으로 지정할 수도 있음
  • 형태: 클래스명.<타입>메서드명(...)
  • 예시

    String s = Utils.<String>first("A", "B");
    Integer n = Utils.<Integer>first(1, 2);

한정된 타입 매개변수(Bounded Type Parameter)

한정된 타입 매개변수는 제네릭을 정의할 때, 아무 타입이나 다 받는 것이 아니라 특정 범위의 타입만 허용하고 싶을 때 사용한다.

• 제네릭 클래스 / 메서드를 정의할 때 "특정한 종류의 타입만" 받도록 제한할 수 있다.
• 구체적인 타입 제한이 필요하면 extends 키워드를 사용한다.
  • 여기서 extends는 상속뿐 아니라 인터페이스 제한에도 사용된다.
• 타입 파라미터에 대한 제한은 상한 경계(extends) 만 가능하다.
  • super(하한 경계)는 와일드카드에서 사용한다.

와일드 카드

• 제네릭 클래스 인스턴스 변수의 참조 타입을 작성할 때
• 와일드 카드로서 문자 ?를 사용
• 불특정 타입을 나타내기 위해 사용하는 특수한 타입 매개변수
• 제네릭 클래스에 다형성 적용가능

제네릭 끝.!

같은 자료형의 데이터를 연속된 메모리 공간에 저장하는 선형 자료구조

** 배열의 생성(초기화) ** int[] arr = new int[5];

** 선언과 동시에 값 지정 ** int[] array = {1, 2, 3, 4, 5};

** 시간 복잡도 **

• 접근 및 수정 O(1) : 인덱스를 통해 즉시 접근 가능 Ex) arr[2]
• 검색 O(N) : 원하는 값을 찾기 위해 처음부터 끝까지 확인 가능
• 삽입/삭제 O(N) : 중간에 데이터를 넣거나 뺄 때 나머지 요소 이동

*cf) 배열과 연결 리스트의 차이 *

정렬(Sort)

• 데이터(숫자, 문자, 객체 등)들을 일정한 규칙(오름차순, 내림차순 등)에 따라 순서대로 재배열 하는것을 말함
• 다양한 알고리즘에서 선행 작업으로 활용되기도 함(데이터 처리 속도 향상)
• 자바에서는 Arrays 클래스와 Collections 클래스에서 sort()메서드를 지원함

버블 정렬(Bubble Sort)

• 인접한 두 개의 원소를 비교하여 크기가 순서에 맞지 않는다면 서로 교환(Swap)하는 과정을 반복하여 정렬하는 알고리즘
• 한번의 사이클이 끝날 때 마다 가장 큰(또는 작은) 원소가 끝에 위치하게 되는 모습이 거품이 올라오는 것과 유사하다고 하여 '버블 정렬(Bubble Sort)라고 부름
• 시간 복잡도 : O(N²)

버블 정렬 과정

• 배열의 처음부터 끝까지 인접 원소를 짝지어 비교
• 비교한 두 원소의 순서가 잘못되어 있자다면 교환(Swap)-> 오름차순, 내림차순
• 한 사이클이 끝나면 배열의 마지막 인덱스에 가장 큰(작은) 원소가 위치
• 범위를 줄여 나가며 N-1번 정도 반복 수행하면 정렬 완료Í‹››

  

구현예시 : Java

import java.util.Arrays;

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = { 1, 16, 2, 20, 97, 99 };

        int N = arr.length; 
        // array의 길이를 저장

        for (int i = N - 1; i > 0; i--) {
            for (int j = 0; j < i; j++) {
                // 오름차순 정렬
                if (arr[j] > arr[j + 1]) {
                    int tmp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = tmp;
                }
            } 
            System.out.println(Arrays.toString(arr));
        } 

    }

}

선택 정렬(Selection Sort)

• 정렬되어 있지 않은 배열 혹은 리스트에서 가장 작은(또는 가장 큰) 원소를 찾아 맨 앞(또는 맨 뒤)으로 옮기는 과정을 반복하여 전체를 정렬하는 과정
• 시간 복잡도 : O(N²)

선택 정렬 과정

• 주어진 리스트 중에서 최솟값을 찾는다
• 맨 앞의 원소와 가장 작은 값을 swap한다
• 맨 앞의 원소를 제외한 나머지 구간에 반복 수행한다

구현예시 : Java

import java.util.Arrays;

public class SelectionSort {
    public static void main(String[] args) {
        int[] arr = { 1, 16, 2, 20, 97, 99 };

        int N = arr.length;

        for (int i = 0; i < N - 1; i++) {
            int minIdx = i; 
            for (int j = i + 1; j < N; j++) {
                if (arr[minIdx] > arr[j]) {
                    minIdx = j; 
                }
            }
//            if(minIdx == i) continue;
            int tmp = arr[i];
            arr[i] = arr[minIdx];
            arr[minIdx] = tmp;

        } 

        System.out.println(Arrays.toString(arr));
    }

}

안정 vs 불안정 정렬 차이 : 중복된 값이 있을 때, 입력된 순서가 정렬 후에도 유지되는 가? 버블 정렬 : 인접한 수만 바꾸고 값이 같으면 바꾸지 않고 지나감 선택 정렬 : 수에 따라 변경이 될 수 있음 ex) 2 (a), 2(b), 1 -> 1, 2 (b), 2 (a) : 맨 앞에 있는 2(A)와 1을 바꾸면서 순서 역전

카운팅 정렬(Counting Sort)

각 항목이 몇 번 등장했는지(빈도)를 세서, 그 정보를 이용해 정렬 결과를 만든다. → 비교 기반 정렬이 아니라 카운트 기반 정렬이라 선형 시간에 가깝게 가능

특징 (1) 안정 정렬(Stable)로 구현 가능: 같은 값의 원래 순서 유지 (2) 정수(또는 정수로 매핑 가능한 값)에 대해서만 적용하기 쉬움 (값 자체를 인덱스로 쓰는 count 배열을 만들기 때문) (3) 비 비교 정렬

** 조건 / 제약 **

(1) count[value] 형태로 쓰려면 값의 범위(최대값)를 알아야 한다. (2) 값의 최대가 크면 count 배열이 커져서 공간 사용량이 증가한다.

** 시간 복잡도 **

O(n + k)

• n : 입력 데이터(배열) 길이

• 배열을 돌면서 각 숫자가 몇 번 나왔나 세기 : O(n) (1단계)

• 2단계 수행후 원래 배열을 한 번 더 탐색 : O(n) (3단계)

• k : 값의 범위(최대값 규모)

• 0부터 k까지 돌면서 누적합 계산 : O(k)(2단계)

따라서, O(2n+k) = O(n+k)

카운팅 정렬의 과정

(1) 데이터가 들어갈 수 있는 범위 확인 cf) 데이터 범위가 항상 0부터 시작한다는 보장은 없음

(2) 0~k (데이터 범위)까지의 배열 생성

(3) 데이터를 순회하면서 해당 인덱스의 값을 증가시킴

(4) 카운트 배열의 누적합을 구하여 정렬된 결과를 어느 위치에 배치해야하는 지 알 수 있음

(5) 원본 배열의 뒤에서부터 순회하며 원소를 배치

구현예시 : Java

public static int[] countingSort(int[] arr) {
int N = arr.length;

// 1. 가장 큰 값 찾기

int K = -1;
for (int i = 0; i < N; i++) {
if (arr[i] > K) K = arr[i];
}

// 2. Counting 하기
// 등장 횟수를 저장할 count 배열 생성
int[] count = new int[K + 1];
// 각 숫자 등장 횟수 세기
for (int i = 0; i < N; i++) {
count[arr[i]]++;
}

// 3. 누적합 구하기
for (int i = 1; i < K + 1; i++) {
count[i] += count[i - 1]; // count[i] → i 이하의 숫자가 총 몇 개인지
}

// 4. 역방향으로 원본을 순회하면서 정렬 시작
int[] sortedArr = new int[N]; // 원본 배열과 동일한 크기의 배열
for (int i = N - 1; i >= 0; i--) // 뒤에서부터 순회
{
int num = arr[i]; // 현재 정렬 대상 값
int idx = count[num] - 1; // 누적합 정보로 실제 들어갈 인덱스 계산
sortedArr[idx] = num; // 계산된 위치에 값 저장
count[num]--; // 다음 동일 숫자가 앞에 올 수 있도록 위치 한 칸 전진
}
return sortedArr;
}
}                      

기수 정렬(Radix Sort)

원소끼리 a < b 비교를 반복하는 대신, 자릿수(digit) 를 기준으로 여러 번 분류/정렬을 반복해 전체를 정렬하는 알고리즘 -> 보통 각 자릿수 정렬 단계에서 카운팅 정렬 같은 안정 정렬을 사용함

** 정렬 방식 (LSD 방식) **

1의 자리 → 10의 자리 → 100의 자리 → … 순서로 정렬(Least Significant Digit)

** 특징 **

(1) 안정 정렬(Stable) 로 구현 가능(자릿수별 정렬이 안정적이면 전체도 안정적)

(2) 주로 0 이상의 정수 정렬에 많이 사용 (3) 정수뿐 아니라 자릿수 개념으로 표현 가능한 문자열에도 응용 가능

** 시간 복잡도**

O(d × (n + k))

• n: 데이터 개수(배열 길이)
• d: 자릿수 개수
• k: 한 자릿수의 값 범위(10진수면 0~9라서 보통 k=10)

-> 카운팅 정렬 O(n+k)를 자릿수 d번 반복하는 것과 같음 -> d가 커질수록(자릿수 많을수록) 느려짐

** 제약/주의 **

(1) 자릿수가 늘면 비용 증가 (2) 음수 / 소수는 그대로 적용하기 어렵고, 처리하려면 추가 변환/전처리가 필요함

구현예시 : Java

// 기수정렬(LSD방식)
public static void radixSort(int[] arr) {

// 최댓값 찾기(자릿수 계산)
int max = arr[0];
for (int v : arr) {
if (v > max) max = v;
}

// 1의 자리, 10의자리, 100의자리.... 정렬
// 가장 큰수의 자릿수까지만 정렬 ( ex 123 /1000 = 0 되어서 종료)
for (int exp = 1; max / exp > 0; exp *= 10) {
countingSort(arr, exp); } }

public static void countingSort(int[] arr, int exp) {
int n = arr.length;
int[] output = new int[n]; // 자릿수 정렬이 완료된 데이터 임시 보관
int[] count = new int[10]; // 자릿수별로 비교, 올 수 있는 숫자는 0-9

// 1. 개수 세기
for (int i = 0; i < n; i++) {
int digit = (arr[i] / exp) % 10; // 전체값이 아니라 특정 자릿수만 추출
count[digit]++; }

// 2. 누적합
for (int i = 1; i < 10; i++) {
count[i] += count[i - 1]; }

// 3. 역방향으로
for (int i = n - 1; i >= 0; i--) {
int digit = (arr[i] / exp) % 10; //자릿수 추출
output[count[digit] - 1] = arr[i]; //자릿수 기준 위치에 저장
count[digit]--; }

// 4. output arr에 덮기
// 새 배열에 반환하는 카운팅과 달리 다음 자릿수 정렬을 위해 원본 배열 업데이트
for (int i = 0; i < n; i++) {
arr[i] = output[i]; } } }

열심히 이 글을 읽으시고, 코딩체력이 높으신 분들은 당연하게

Arrays.sort() 쓰면 되는 거 아님? 이라는 생각을 하셨을 것이다.

cf) Arrays.sort() java.util.Arrays의 sort()는 배열을 정렬하는 표준 메서드

• 대표형태

  Arrays.sort(int[] a);                 // 기본형(primitive) 배열
  Arrays.sort(Integer[] a);             // 객체 배열(Wrapper)
  Arrays.sort(T[] a, Comparator<? super T> c);  // 비교기(정렬 기준) 지정
  Arrays.sort(a, from, to);             // 부분 정렬

  (1) 기본형 배열 Ex) int[], double[]

• Dual-Pivot Quicksort 계열을 사용

• 평균적으로 빠르고 상수항이 작음

• 안정 정렬(stable) X

• 시간복잡도: 평균 O(n log n)

int[] a = {5, 2, 9, 1};
Arrays.sort(a);

(2) 객체 배열

Ex) Integer[], String[] etc

• TimSort(MergeSort 계열, “runs” 활용) 사용
• 안정 정렬(stable) → 같은 값(비교 결과 0)이면 원래 순서가 유지됨
• 시간복잡도: O(nlogn)
• 부분적으로 이미 정렬된 데이터에 강함

  String[] s = {"b", "a", "a"};
  Arrays.sort(s); // stable: 같은 "a"의 상대 순서 유지

대부분의 코테/실무 정렬은 Arrays.sort()로 충분..! 샤라웃 투 ㅅㅇ 땡스 투 ㅅㅎ

하지만, 오늘날 많은 연구자들에게 '문헌'은 보통 선행연구를 알아 볼 수 있는 '논문'을 많이 말한다. 대학생, 대학원생, 직장인들까지 많은 사람들은 정보라는 것을 찾아보는 삶을 살아가고 있다. 하지만, 요즘은 참 거짓 정보가 넘치고 신뢰성있는 자료를 찾는 과정이 점점 더 어려워지고 있다. 오늘은 '비교적' 신뢰 할 만 (비.교.적. 강조.) 논문을 찾아보고자 한다.

이 글은 “논문을 찾는 방법”을 넘어서, 연구 질문을 검색 가능한 형태로 바꾸고, -> 재현 가능한 검색식을 만들고, 체계적으로 스크리닝/정리하는 과정까지 다룬다.
-> (전공/분야 상관없이 적용 가능한 프레임워크 + 보건/의생명 쪽 예시 포함)

문헌 검색

문헌 검색에서 가장 큰 실수는 '일단 검색창에 넣고 많이 읽자'이다. 실제 연구에서는 검색의 목표가 명확해야 한다. 쉽게 생각하면 구글, 네이버 창을 열어 그저 '검색'을 하면 되는 것 같지만, 학술적인 검색을 위해서는 핵심질문을 설정하고, 검색전략 수립, 검색원 선정, 검색어의 선택과 조합 등 일련의 과정이 필요하다.

• 핵심 질문 설정

• 검색 전략 수립
• 데이터베이스(DB) 선택
• 검색어/검색식 설계
• 스크리닝 및 기록(로그)

그렇다면, 검색은 어떻게 하면 좋을까? 이또한 검색의 목표에 따라 다르다.

• 탐색적 검색: 주제 감 잡기, 키워드/연구흐름 파악
• 논문 작성용 검색: 서론/배경/근거를 탄탄하게 만들기
• 체계적 문헌고찰(SR/MA)용 검색: 재현 가능한 검색식 + 누락 최소화

같은 '문헌 검색'이라도 목표가 다르면

• 어디서 검색하는지(DB)
• 얼마나 넓게 찾는지(민감도)
• 무엇을 남기는지(스크리닝 로그)

가 완전히 달라진다.

검색에서도 민감도(Sensitivity)와 특이도(Specificity)를 생각해볼수 있다.

• 민감도 : 검색에 의해 적절한 연구/문헌을 찾을 가능성 -> 민감도가 높은 검색전략은 포괄적(comprehensive)인 검색
• 특이도 : 부적절한 연구/문헌을 배제할 가능성 -> 특이도가 높은 검색전략은 특정 문제에 대한 중요한 연구를 집중해서 포함하는 것을 목적으로 함

cf) 민감도와 특이도는 상쇄 관계라 목적에 따라 균형이 달라진다(예: SR/MA는 민감도 우선)

검색 전 확인 사항

당장 무언가를 검색엔진에서 검색하기 이전에 아래에 정리되는 것을 정리하면 효율이 확 올라간다.

1. 핵심 질문(Research Question)

• 내가 진짜 알고 싶은 것은 무엇인가?

*2. 범위(Scope) *

• 기간 : 예) 2015-2026
• 대상 : 예) 인간 / 동물 / 세포, 연령대, 지역 등
• 연구유형 : 예) RCT, cohort, cross-sectional, qualitative 등
• 언어 : 예) 한국어 / 영어 등

검색어 선정

검색어는 핵심 질문에 잠재적으로 관련된 문헌을 최대한 포함하기 위해, 보통은 폭넓게(민감도 높게) 설계한다.

(사실 이 글의 기반은 나중에 소개할 체계적 문헌고찰 / 메타분석의 기반이 되는 개념들이 많다)

(1) 핵심 질문 분해 핵심질문을 분해하여 개별요소 형태로 정리 각 개별요소에서 주요 개념어를 도출한다.

• 민감도를 높이기 위해 의학주제어, 유의어, 대안어 등을 활용할 수 있음
• 포괄적이고 정확한 검색을 위해 논리연산자 혹은 절단 검색 기능을 활용함

ex1) PICO (임상/중재)

• Population (대상)
• Intervention (중재)
• Comparator (비교)
• Outcome (결과)

예) 청소년 비만 예방을 위한 모바일 앱 중재가 BMI를 낮추는가?

• 참고 : 일반적으로 특정 의료 결과로만 분석할 경우를 제외하고 PICO중 결과/성과(O)에 해당하는 검색어는 검색식에 포함하지 않는 것을 권장

ex2) PECO (노출/역학)

• Population
• Exposure (노출)
• Comparator
• Outcome

예) “청소년에서 패스트푸드 섭취(노출)가 비만(결과)과 관련 있는가?”

ex3) SPIDER (질적 연구)

• Sample / Phenomenon of Interest / Design / Evaluation / Research type

각각을 질문을 검색식으로 바꾸는 프레임워크라고 한다. 프레임워크는 '모든 요소를 다 넣는 게 정답이 아니라, 내가 검색에서 반드시 걸어야 하는 핵심 요소만 뽑는 도구이다.

(2) 키워드의 표현 방식

연구질문 중 청소년 비만에 대해 생각해보자. 검색을 진행한다고했을때, 비단 한가지 방법과 검색어로 적용할 수 있는 것이 아니다. 검색어는 아래와 같이 여러가지 종류로 나눠질 수 있다.

1) 자연어(Free text)
일상적으로 우리가 사용하는 자연어를 기반으로 작성할 수 있는 검색어를 말한다.

예) adolescent obesity, teen obesity, youth obesity

2) 통제어(Controlled vocabulary)

• PubMed: MeSH
• Embase: Emtree
  예) obesity[MeSH], adolescent[MeSH]

MeSH : 의학주제어 혹은 의학주제표목(Medical Subjects Headings)

• 미국의학도서관에서 색인을 위해 구축한 계층적인 용어구조
• Medline, Cocharne library, PsyclNFO 등 DB에서 제공

3) 유의어 / 대안어

• 약어, 유의어, 미국식 / 영국식 용어 차이

예1) overweight, body mass index, BMI 예2) 암 : cancer, carcinoma, tumor, neoplasm

• adolescen* (truncation)

(3) 검색식 조합

1) 불리언 연산자

• OR : 주로 비슷한 개념을 포함시킬 떄 사용. 합집합 개념(AUB) ex) (adolescent OR teen OR youth)
• AND : 주로 서로 다른 개념을 합칠 때 사용. 교집합 개념(A∩B) ex) (adolescent OR teen OR youth) AND (obesity OR overweight)
• NOT : 차집합(A-B) 개념. 필요한 단어가 제거되지 않도록 주의하여 사용 (obesity) NOT (mouse OR mice)

2) 절단 검색

• $ 또는 *

  • 어미에 붙이는 검색어로 제한 없이 검색됨
    • 예) Cardio* → Cardiology (심장내과, 진료과), Cardiovascular disease (심혈관 질환, CVD), Cardiomyopathy (심근병증, 세부 질환), Cardiologist (심장전문의, 전문가)

• #

  • 단어 내 혹은 어미에 붙이는 검색어로 정확히 한 문자만 치환하여 검색됨
    • 예) wom#n -> woman, women

• ?

  • 단어 내 혹은 어미에 붙이는 검색어로 한 글자 이하로(0 또는 1) 치환하여 검색됨
  • 예) tum?r : tumor, tumour

참고 : 절단 / 와일드카드는 DB마다 문법이 다르므로, 검색 시작 전에 해당 DB의 wildcard 규칙(*, ?, # 등)을 먼저 확인하는 것이 안전하다.

데이터 베이스 선택

• PubMed/MEDLINE: 의생명 기본, MeSH 강력, 무료
• Embase: 약물/임상/유럽 커버리지 강함, Emtree 강력(유료)
• Scopus: 광범위(공학/사회과학 포함), 인용분석 편함(유료)
• Web of Science: 인용 네트워크/핵심 저널 중심(유료)
• Google Scholar: 넓게 잡히지만 노이즈 많음, 재현성 약함
• Cochrane Library: SR/RCT 중심

현실적으로 보통 모든 데이터 베이스를 보지는 않고, 논문 작성용은 성향이 적절한 1개만 선택하여 주로 보고, 체계적 문헌 고찰 같은 방법론적인 탐색을 할때는 3개 이상을 보게된다.

검색결과 정리

검색이 끝났다면, 이제부터는 ‘읽기’가 아니라 ‘정리’의 단계이다. 이 과정을 체계적으로 하지 않으면, 같은 논문을 여러 번 읽거나, 중요한 논문을 놓치는 일이 발생한다.

보통은 EndNote, Zotero 같은 서지관리 프로그램을 이용해 문헌을 정리한다. (해당 프로그램 사용법은 차후에 별도로 다루도록 하자.) 정리를 하는 방법은 연구자 마다 다르지만, 간단하게 내가 하는 방식을 소개해보자면 아래와 같다.

** 기본정리 단계**

1. 검색 결과 전체 다운로드 → 가능하면 RIS / BibTeX 형식으로 저장
   2. 중복 제거(Deduplication) → 여러 DB에서 검색했다면 중복 문헌이 반드시 발생 → 프로그램의 자동 중복 제거 기능 + 수동 확인 병행
   3. 폴더 / 컬렉션 분류

** 추가 정리**

체계적 접근을 위해 아래를 기록해두면 좋다.

1. 검색 DB (예: PubMed, Embase)
2. 검색 날짜
3. 사용한 검색식
4. 검색 결과 건수
5. 포함/제외 기준

이 기록은 재현 가능성(reproducibility)을 보장하는 핵심 요소이고, 특히 연구적으로 검색을 사용하는 SR/MA를 진행할 경우 필수적이다.

오늘은 연구자들이 문헌을 검색하는 전략에 대해서 다뤄 보았다. 실질적으로 학부연구생과 석사과정 총 4년의 기간에서 크게 느꼈던 어려움 중에 하나는 바로 '논문'읽기였다. 결국 연구라는 것은 '거인의 어깨(Standing on the shoulders of giants)'위에 올라타서 지식의 지평을 넓히는 과정이다. 그러한 연구의 시작인 논문 읽기를 이 글을 통해 조금은 친숙해지셨으면 한다.

인터페이스의 개념

인터페이스(Interface)는 원래 다양한 분야에서 쓰이는 용어로, 두 개체가 상호작용 하는 방식을 정의하는 경계를 의미한다. 예시) 개체 : 시스템/장치/프로그램 등 즉, 서로 다른 두 대상이 같이 동작하기 위해 필요한 언어와 규칙(표준)을 정해주는 역할이다. 이 규칙을 통해 내부가 복잡하더라도 사용자는 단순한 방식으로 기능을 활용가능하고, 다른 구성요소들도 동일한 규칙을 따라 일관되게 확장될 수 있다.

*예시1) * 두 개체: 노트북(시스템) ↔ USB 메모리/키보드/마우스(장치) 인터페이스(경계): USB 규격(포트 모양, 전압/신호, 통신 방식)

*예시2) * 두 개체: 쇼핑몰 서버(프로그램) ↔ 결제대행사 API(다른 프로그램) 인터페이스(경계): “결제 요청/응답” API 규격(필드명, 요청 방식, 응답 코드)

자바에서의 인터페이스

자바에서의 인터페이스는 이러한 개념을 코드로 옮긴 것으로, 한마디로 완전히 추상화된 설계도(규격)이다.

• 클래스와 문법적으로 비슷하지만 class 대신 interface 키워드를 사용

• 기본적으로 인터페이스의 메서드는 추상 메서드로 취급 (Java 8부터 default 메서드와 static 메서드가 추가되어 예외가 생김)

• 인터페이스에 선언된 메서드는 기본적으로 public abstract 이며 생략 가능

• 인터페이스에 선언된 변수는 자동으로 public static final(상수)로 간주되며 생략 가능

인터페이스의 구현

• 인터페이스는 인스턴스를 직접 생성할 수 없음
• 따라서 인터페이스를 사용하려면, 클래스가 implements 키워드로 구현(implements) 해야 함

예시 코드)

interface Basic {}
class Advanced extends Basic{}
=> 불가능
class Advanced implements Basic{}
=> 가능

• 하나의 클래스는 여러 개의 인터페이스를 다중 구현할 수 있음

• 구현 클래스는 인터페이스에 선언된 모든 추상 메서드를 반드시 구현(override) 해야 객체를 생성할 수 있음

• 만약 일부만 구현한다면, 그 클래스는 추상 클래스(abstract class) 로 선언되어야함

인터페이스의 상속

• 인터페이스는 extends 키워드를 사용해 다른 인터페이스를 상속

• 클래스와 달리 인터페이스는 다중 상속이 가능 (일반적으로 구현부 없이 규격(메서드 선언)만 정의하므로 충돌 위험이 상대적으로 적기 때문)

default 메서드 (Java 8+)

• 인터페이스에도 구현부가 있는 메서드를 정의할 수 있음 → 선언 시 메서드 앞에 default 키워드를 반드시 붙임

• 접근 제한자는 public만 가능하며, public은 생략 가능

• 구현 클래스는 필요하면 default 메서드를 재정의(override) 할 수 있음

• 기존 인터페이스에 메서드를 추가해야 할 때, 모든 구현 클래스가 한꺼번에 깨지는 문제를 줄이기 위해 사용 → 기본 구현을 인터페이스에 제공하므로, 구현체가 반드시 구현할 필요는 없음

cf) default method 충돌 해결

• 여러 인터페이스의 디폴트 메서드 간의 충돌 → 구현 클래스에서 오버라이딩
• 디폴트 메서드와 조상 클래스의 메서드 간의 충돌 → 자동으로 조상 클래스 상속

정적(static) 메서드 (Java 8+)

• 인터페이스에도 static 메서드를 선언할 수 있으며, 사용 방식은 클래스의 static 메서드와 동일

• 호출은 인터페이스명.메서드() 형태로 함 (구현 클래스의 객체로 호출하지 않음)

• 해당 인터페이스와 관련된 유틸리티/헬퍼 기능을 제공할 때 유용

• static 메서드는 구현 클래스에 상속되지 않으며, 구현 클래스에서 재정의(override) 할 수도 없음

private 메서드(Java 9+)

• 인터페이스 내부에서만 사용되는 헬퍼 메서드
• 디폴트 메서드, 정적 메서드에서 반복되는 로직 분리 후 작성
• 외부에서 접근하지 못하도록 숨김
• 재사용성 증가
• static 키워드를 사용할 수 있음

인터페이스와 다형성

• 인터페이스를 구현한 클래스로 만든 객체는 해당 인터페이스 타입으로 참조할 수 있음
• 동적 바인딩 : 런타임 시점에서는 실제 객체의 메서드가 호출

인터페이스의 필요성

클래스 vs 인터페이스

추상클래스 vs 인터페이스

슬슬 복잡해지는 Java의 구조 복잡과 익숙해짐의 사이

추상클래스에 대해서 생각해보자. 예를 들어 백엔드 개발자, 프론트엔드 개발자는 모두 develop()이라는 동작이 필요하다. 이 공통 동작을 조상 클래스 Developer에 선언하고, 각 자손 클래스가 자기 방식대로 override 하도록 만들고 싶다.

그런데, 여기서 문제가 생긴다.

• Developer 자체는 실제로 “개발”을 수행하는 구체 객체로 쓰이지 않는다. (실제로는 백엔드/프론트엔드처럼 구체적인 개발자가 일을 한다.)

• develop()은 자식 클래스에서 반드시 재정의해서 사용될 메서드라, 조상 Developer에서 구현을 만들어도 의미가 없다.

• 따라서 Developer에서는 메서드의 선언부만 남기고 구현부를 비워두는 방식이 더 적절하다

• 추상 메서드(abstract method) : 구현부가 없는 메서드

  • 구현부가 없으므로 ;로 끝남
  • 추상 메서드에는 abstract 키워드를 붙임

• 추상 클래스(abstract class) : 추상 메서드를 가진 클래스

  • 추상 메서드를 가진 클래스는 객체 생성이 불가능하다는 의미로 클래스에도 abstract를 붙임

예시)

abstract class Developer {
    protected String name;
    protected int years;

    public Developer(String name, int years) {
        this.name = name;
        this.years = years;
    }

    // 공통 동작(재사용 가능)
    public void attendStandup() {
        System.out.println(name + " : 데일리 스탠드업 참여");
    }

    public void reviewCode() {
        System.out.println(name + " : 코드 리뷰 진행");
    }

    // 자식 클래스가 반드시 구현해야 하는 핵심 동작
    public abstract void develop();
}

class BackendDeveloper extends Developer {
    public BackendDeveloper(String name, int years) {
        super(name, years);
    }

    @Override
    public void develop() {
        System.out.println(name + " : API 개발 / DB 설계");
    }
}

class FrontendDeveloper extends Developer {
    public FrontendDeveloper(String name, int years) {
        super(name, years);
    }

    @Override
    public void develop() {
        System.out.println(name + " : UI 구현 / 상태 관리");
    }
}

추상 클래스 특징

abstract class는 상속 전용 클래스로 사용된다. 따라서 추상 메서드(구현부가 없는 메스드)가 존재할 수 있으므로, 객체 생성이 불가능하다. 대신, 상위 클래스 타입으로 자식 객체를 참조 가능

Developer dev = new BackendDeveloper("Yonu", 2); // O
dev.develop(); // BackendDeveloper의 develop() 실행

*** 자식 클래스가 상속받은 추상 메서드를 재정의 하지 않으면 그 자식 클래스도 추상 클래스가 되어야함

abstract class LazyDeveloper extends Developer {
    public LazyDeveloper(String name, int years) {
        super(name, years);
    }
    // develop()을 구현하지 않았으므로 추상 클래스여야 함
}

추상 클래스 사용 목적

(1) 공통 설계 강제

하위 클래스가 반드시 구현해야 하는 메서드를 추상 메서드로 제공하여 구현을 강제한다.

(2) 코드 재사용성 향상

공통 필드/공통 메서드를 상위 클래스에 두고 하위 클래스가 재사용할 수 있다.

(3) 일관성 유지

같은 이름/형태의 메서드를 반드시 갖도록 하여, 하위 클래스들이 동일한 규격으로 동작하게 만든다.

(4) 다형성 지원

상위 타입으로 묶어 처리할 수 있어 유연한 설계가 가능하다.

클래스 vs 추상 클래스

• 하나의 객체를 여러 타입의 참조 변수로 다룰 수 있는 성질

• 즉, 서로 다른 여러 객체를 공통된 타입(상위 클래스/인터페이스) 으로 묶어 동일한 방식으로 처리할 수 있음

• 상속 관계에서는 부모(조상) 타입 참조 변수로 자식(자손) 객체를 참조할 수 있음

• 참조 타입이 바뀌어도 실제 객체는 그대로이며, 실행되는 동작(메서드)은 실제 객체 기준으로 결정(동적 바인딩)

  참조 타입 = “무엇으로 보느냐” 실제 객체 = “진짜 누구냐” 실행 결과는 진짜 누구냐(실제 객체) 를 따른다.

예시)

Animal a = new Dog();   // Dog 객체를 Animal 타입으로 참조
a.sound();              // 호출은 Dog의 sound()가 실행됨

다형성의 장점

• 유연성 상위 클래스 또는 인터페이스 타입 하나로 다양한 구현 객체를 처리할 수 있어, 객체를 쉽게 교체할 수 있다.

• *재사용성 * 공통 로직은 상위 클래스(또는 공통 인터페이스 기반의 공통 처리 코드)에 모으고, 각 클래스는 필요한 부분만 구현해 중복을 줄일 수 있다.

• 확장성 새로운 클래스(새 구현체)를 추가해도, 기존 코드는 상위 타입(인터페이스)에만 의존하므로 클라이언트 코드 변경 없이 확장이 가능하다.

• 유지보수성 변경이 생겼을 때 영향 범위를 줄일 수 있다. 구현이 바뀌어도 인터페이스(규격)는 유지하면 되고, 필요하면 구현체만 수정/교체하면 되므로 수정 범위가 작아진다.

다형성의 특징

• 상속 관계에 있을 때 조상 클래스 타입으로 자손 클래스 객체 참조 가능

JVM 메모리(힙 영역)

실제 인터페이스 기반으로 객체를 생성할 때, JVM 메모리(힙 영역)에서 실제로 일아나는 일은 다음과 같다.

1) new KakaoPay()는 힙에 객체 1개를 만듬

new KakaoPay()

실행되면 Heap에 KakaoPay 인스턴스(객체) 1개가 생성된다. 이 표현식의 결과는 “객체 자체”가 아니라, 힙에 있는 객체를 가리키는 참조값(주소) 이다. 즉, 힙에는 KakaoPay 객체가 생기고, 그 주소를 다른 변수가 들고 있게 된다.

2) 아래 세 줄은 힙 객체 3개를 만듬

object obj = new KakaoPay() ;
Payment p = new KakaoPay() ;
Kakaopay kp = new KakaoPay() ;

• 위 코드는 new가 3번이므로, 힙에 KakaoPay 객체가 3개 생김
• 각각의 참조 변수(obj, p, kp)는 서로 다른 객체의 주소를 들고 있음

3) 같은 힙 객체 1개를 여러 타입으로 참조하려면 아래와 같음

KakaoPay real = new KakaoPay(); // Heap: 객체 1개

Object  obj = real;            // Stack: obj는 그 주소를 들고 있음
Payment p   = real;            // Stack: p도 같은 주소
KakaoPay kp = real;            // Stack: kp도 같은 주소

• Heap에는 객체 1개
• Stack에는 참조 변수 3개가 생기고,
• 세 변수는 전부 같은 주소(같은 객체) 를 가리킴

4) 참조 타입이 다르면 '보이는 범위'가 달라짐 (1) Object obj

obj.toString(); // O (Object에 있는 메서드)

• Object 타입이라 Object가 가진 기능만 보임

(2) Payment p

p.pay(1000);   // O (Payment 규격에 있는 메서드)

• Payment 타입이라 인터페이스에 선언된 메서드만 보임

(3) KakaoPay kp

kp.pay(1000);      // O
kp.kakaoOnly();    // O (KakaoPay 전용 메서드가 있다면)

• 구체 타입이라 KakaoPay 전용 기능까지 보임

참조변수의 형 변환

예시) KakaoPay implements Payment CardPay implements Payment 그리고 모든 클래스는 Object를 상속

Object ↳ KakaoPay (그리고 Payment를 구현) ↳ CardPay (그리고 Payment를 구현)

• 인터페이스는 상속이 아니라 구현이지만, 캐스팅 방향(위로/아래로) 개념은 똑같이 적용

(1) 업캐스팅 : 자손 -> 조상

• 묵시적 형 변환 가능
• 안전함 (무조건 성립)

  KakaoPay kp = new KakaoPay();
  Payment p = kp;        // 업캐스팅 (생략 가능)
  Object obj = kp;       // 업캐스팅 (생략 가능)
  

p.pay(10000); // O (Payment에 있음) p.kakaoOnly(); // X (Payment에는 없음)

(2) 다운캐스팅 : 조상 -> 자손

* 명시적 형 변환 필요: (KakaoPay) p

* 항상 가능한 게 아님 (진짜 객체가 KakaoPay일 때만 가능)

잘못된 예시 1)

Payment p = new CardPay(); // 실제 객체는 CardPay KakaoPay kp = (KakaoPay) p; // X (런타임 ClassCastException)

p의 “타입”은 Payment지만 p가 가리키는 “실제 객체”가 CardPay라서 KakaoPay로 못바꿈


#### instanceof 연산자

instanceof는 '참조 변수가 가리키는 실제 객체가 어떤 타입인지' 확인할 때 쓴다.
-> 결과를 boolean으로 반환
-> true가 반환이 되면 해당 타입으로 형 변환 가능

Payment p = new KakaoPay();

p instanceof Payment // true p instanceof KakaoPay // true p instanceof CardPay // false p instanceof Object // true

사용 이유 : 다운캐스팅은 위험할 수 있어서

Payment p = new CardPay();

// 아래는 위험: 실제 객체가 CardPay인데 KakaoPay로 바꾸려 하면 런타임 에러 KakaoPay kp = (KakaoPay) p; // ClassCastException

사용 예시

Payment p = new KakaoPay();

if (p instanceof KakaoPay) { KakaoPay kp = (KakaoPay) p; kp.kakaoOnly(); // KakaoPay 전용 기능 사용 }

cf) Java 16+ 패턴 매칭

* instanceof KakaoPay가 true면, kp 변수가 자동으로 KakaoPay 타입으로 선언된 것처럼 사용 가능

Payment p = new KakaoPay();

if (p instanceof KakaoPay kp) { kp.kakaoOnly(); }

```

참조 변수와 인스턴스 멤버의 관계

• 상속관계에서 멤버변수가 중복이 되면 참조 변수 타입에 따라 연결이 달라짐
• 메서드가 중복될 때(오버라이딩), 참조 변수의 타입에 상관없이 항상 실제 인스턴스의 자식 클래스 메서드가 호출 -> 동적 바인딩
• static 메서드는 참조변수 타입의 영향을 받기 때문에 이를 방지하고자 클래스 이름으로 메서드 호출(권장)

객체 지향 프로그래밍에서 특성 중 하나인 '다형성'에 대한 설명

SWEA 1984 : 중간 평균값 구하기 SWEA 1984 : 중간 평균값 구하기

[문제 분석]

10개의 수를 입력 받아, 최대 수와 최소 수를 제외한 나머지의 평균값을 출력하는 프로그램을 작성하라.

(소수점 첫째 자리에서 반올림한 정수를 출력한다.)

[제약 사항]

각 수는 0 이상 10000 이하의 정수이다.

[입력]

가장 첫 줄에는 테스트 케이스의 개수 T가 주어지고, 그 아래로 각 테스트 케이스가 주어진다. 각 테스트 케이스의 첫 번째 줄에는 10개의 수가 주어진다.

[출력]

출력의 각 줄은 '#t'로 시작하고, 공백을 한 칸 둔 다음 정답을 출력한다. (t는 테스트 케이스의 번호를 의미하며 1부터 시작한다.)

[풀이 전략]

처음 생각했을 때, 생각했던 로직은 다음과 같다 (1) 정수를 배열로 받는다. (2) 조건문을 이용해서 (3) 맥스값 프린트

[구현코드]

import java.util.Scanner;

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

        int T = sc.nextInt();  // 테스트 케이스 수

        for (int t = 1; t <= T; t++) {
            int max = 0;

            for (int i = 0; i < 10; i++) {
                int num = sc.nextInt();
                if (num > max) {
                    max = num;
                }
            }

            System.out.println("#" + t + " " + max);
        }

        sc.close();
    }
}

[개선사항]

1. max 함수 활용 if (num > max) {

                max = num;
            }

   이 과정을 기반으로 Math 함수인 max를 이용해서 작성할 수 있다.

2. 개선 코드

   package test;
   

import java.util.Scanner;

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

    int T = sc.nextInt();  // 테스트 케이스 수

    for (int t = 1; t <= T; t++) {
        int max = 0;

        for (int i = 0; i < 10; i++) {
            int num = sc.nextInt();
            max = Math.max(max, num);

        }

        System.out.println("#" + t + " " + max);
    }

    sc.close();
}

}

---
※ SW Expert 아카데미의 문제를 무단 복제하는 것을 금지합니다.
해당 문제는 개인 학습을 위한 비상업적 용도로 사용한 글입니다.

문제 : 백준 13458 : 시험 감독 백준 13458 : 시험 감독

[문제 분석]

총 N개의 시험장이 있고, 각각의 시험장마다 응시자들이 있다. i번 시험장에 있는 응시자의 수는 Ai명이다.

감독관은 총감독관과 부감독관으로 두 종류가 있다. 총감독관은 한 시험장에서 감시할 수 있는 응시자의 수가 B명이고, 부감독관은 한 시험장에서 감시할 수 있는 응시자의 수가 C명이다.

각각의 시험장에 총감독관은 오직 1명만 있어야 하고, 부감독관은 여러 명 있어도 된다.

각 시험장마다 응시생들을 모두 감시해야 한다. 이때, 필요한 감독관 수의 최솟값을 구하는 프로그램을 작성하시오.

[입력]

첫째 줄에 시험장의 개수 N(1 ≤ N ≤ 1,000,000)이 주어진다.

둘째 줄에는 각 시험장에 있는 응시자의 수 Ai (1 ≤ Ai ≤ 1,000,000)가 주어진다.

셋째 줄에는 B와 C가 주어진다. (1 ≤ B, C ≤ 1,000,000)

[출력]

각 시험장마다 응시생을 모두 감독하기 위해 필요한 감독관의 최소 수를 출력한다.

[풀이 전략]

풀이 전에 문제를 정리를 해보자.

1. N개 시험장에 A[i]에 해당하는 사람들이 있으니까 그렇게 수열을 만들어줘서 받자
2. 총시험관은 꼭 한명씩 있어야하고 따라서 A[i] -B 만큼을 부시험관들로 해결해야한다. (A[i]-B)/C를 구하고 (A[i]-B)%C 남는 사람들은 +1을 해서 부 시험관 수를 구해야한다.

[구현코드]

package test;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int N = sc.nextInt();
    int[] student = new int[N];
    for(int i = 0; i<N ; i++) student[i] = sc.nextInt();
    int B = sc.nextInt();
    int C = sc.nextInt();
    long sum = 0;
    for(int i = 0; i<N ; i++) {
        sum++;
        if(student[i] > B) {
        int remain = student[i]-B;
        sum += remain/C;
        if (remain%C >0)
            sum++;
        }



    }
    System.out.println(sum);
}
}

오늘은 1+1 야미 끝

문제 : 백준 10815 : 숫자 카드 백준 10815 : 숫자 카드

[문제 분석]

숫자 카드는 정수 하나가 적혀져 있는 카드이다. 상근이는 숫자 카드 N개를 가지고 있다. 정수 M개가 주어졌을 때, 이 수가 적혀있는 숫자 카드를 상근이가 가지고 있는지 아닌지를 구하는 프로그램을 작성하시오.

[입력]

첫째 줄에 상근이가 가지고 있는 숫자 카드의 개수 N(1 ≤ N ≤ 500,000)이 주어진다. 둘째 줄에는 숫자 카드에 적혀있는 정수가 주어진다. 숫자 카드에 적혀있는 수는 -10,000,000보다 크거나 같고, 10,000,000보다 작거나 같다. 두 숫자 카드에 같은 수가 적혀있는 경우는 없다.

셋째 줄에는 M(1 ≤ M ≤ 500,000)이 주어진다. 넷째 줄에는 상근이가 가지고 있는 숫자 카드인지 아닌지를 구해야 할 M개의 정수가 주어지며, 이 수는 공백으로 구분되어져 있다. 이 수도 -10,000,000보다 크거나 같고, 10,000,000보다 작거나 같다

[출력]

첫째 줄에 입력으로 주어진 M개의 수에 대해서, 각 수가 적힌 숫자 카드를 상근이가 가지고 있으면 1을, 아니면 0을 공백으로 구분해 출력한다.

[풀이 전략]

풀이 전에 문제를 정리를 해보자.

1. 첫번째 접근 : Brute force

• 쉽게 생각할 수 있는 N에 대한 M의 1대1 전체 탐색(Brute force)

• 문제점 시간 복잡도가 N*M이라 구현 시 시간제한에 걸림

2. 두번째 접근 : 이진 탐색

• 시간 복잡도를 낮추기 위해 이진 탐색을 적용해서 풀이 할 수 있다.(nlogn)

[구현코드]

package test;

import java.util.Arrays;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int N = sc.nextInt();
    int[] Narr = new int[N];
    for(int i = 0; i<N; i++) 
        Narr[i] =  sc.nextInt();
    int M = sc.nextInt();
    int[] Marr = new int[M];
    int[] test = new int[M];
    Arrays.sort(Narr);

    for (int j = 0 ; j < M ; j ++) {
        int L = 0;
        int R = Narr.length-1;  
        Marr[j] = sc.nextInt(); 
        while (L <= R ) {
        int mid = (L+R)/2;
        if(Narr[mid] == Marr[j]) {
            test[j] = 1;
            break;}
        else if(Narr[mid] > Marr[j]) 
             R = mid - 1;
        else {
            L = mid + 1;
        }


        }

    }

    for (int result : test)
    System.out.print(result+" ");
}

}

[개선사항]

1. Set을 이용한 방법 Set을 이용해서 검색할 때 배열을 확인하지 않기 때문에 가장 적절한 방법이라고 생각이 든다. (시간 복잡도 : O(1))

2. 구현 코드

   import java.util.HashSet;
   import java.util.Scanner;
   import java.util.Set;
   

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

    // 1. N 입력
    int N = sc.nextInt();

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

    for(int i = 0; i < N; i++) {
        nSet.add(sc.nextInt());
    }

    int M = sc.nextInt();
    StringBuilder sb = new     StringBuilder();

    for(int i = 0; i < M; i++) {
        int target = sc.nextInt();

        if (nSet.contains(target)) {
            sb.append("1 ");
        } else {
            sb.append("0 ");
        }
    }

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

}

--- 
오늘은 맛있었던 런치야미 끝 

문제 : 백준 1015. 수열 정렬 백준 9076 : 점수 집계

[문제 분석]

한국 체조협회에서는 심판의 오심을 막기 위하여 점수 집계 시스템을 고치기로 하였다. 이전에는 5명의 심판이 1점부터 10점까지 정수의 점수를 주면 최고점과 최저점을 하나씩 제외한 점수의 합을 총점으로 하였다. 이를 보완하기 위해서 최고점과 최저점을 뺀 나머지 3명 점수의 최고점과 최저점의 차이가 4점 이상 나게 되면 점수 조정을 거쳐서 다시 점수를 매기려고 한다. 점수를 집계하여 총점을 계산하거나, 점수 조정을 거쳐서 다시 점수를 매기려고 하는 경우에는 총점 대신 KIN(Keep In Negotiation)을 출력하는 프로그램을 작성하시오.

[입력]

입력의 첫 줄에는 테스트 케이스의 개수 T(1 ≤ T ≤ 10)가 주어진다. 각 테스트 케이스는 한 줄에 다섯 심판이 준 점수 다섯 개의 정수 Ni(1 ≤ Ni ≤ 10, i = 1, 2, ..., 5)가 하나의 공백을 사이에 두고 주어진다.

[출력]

각 테스트 케이스에 대해서 총점을 한 줄씩 출력한다. 만일 점수 조정을 거쳐서 다시 점수를 매기려고 하는 경우에는 총점 대신 KIN을 출력한다.

[풀이 전략]

풀이 전에 문제를 정리를 해보자.

1. 테스트 케이스 별로 크기 5인 수열을 만들엇 ㅓ받는다.
2. 수열을 정렬한다.
3. 인덱스 0, 4를 제외 하고 sum을 만든다.
4. 인덱스 1, 3의 차이의 절대값에 4를 기준으로 조건문을 줘서 KIN처리를 해준다.

[구현코드]

package test;

import java.util.Arrays;
import java.util.Scanner;

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

    for (int test_case = 0; test_case<T; test_case++) {
    for(int i = 0; i<5 ; i++) arr[i]=sc.nextInt(); // testcase별 점수 5개 받기
    Arrays.sort(arr); // 정렬
    int sum = arr[1]+arr[2]+arr[3];
    if (Math.abs(arr[1]-arr[3])>=4) // 차이가 4점이상 나면 점수조정
        System.out.println("KIN");
    else { 
        System.out.println(sum);

    }

    }// testcase for문 

    }
}

[개선사항]

1. BufferedReader를 이용한 속도 향상
2. 구현 코드

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

public class Main { public static void main(String[] args) throws Exception { BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); StringBuilder sb = new StringBuilder();

    int T = Integer.parseInt(br.readLine().trim());
    for (int tc = 0; tc < T; tc++) {
        StringTokenizer st = new StringTokenizer(br.readLine());
        int[] a = new int[5];
        for (int i = 0; i < 5; i++) a[i] = Integer.parseInt(st.nextToken());

        Arrays.sort(a);

        if (a[3] - a[1] >= 4) sb.append("KIN\n");
        else sb.append(a[1] + a[2] + a[3]).append('\n');
    }

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

}

--- 
오늘은 달콤했던 런치야미 끝 

문제 : 백준 1015. 수열 정렬 백준 1015 : 수열 정렬

[문제 분석]

P[0], P[1], ...., P[N-1]은 0부터 N-1까지(포함)의 수를 한 번씩 포함하고 있는 수열이다. 수열 P를 길이가 N인 배열 A에 적용하면 길이가 N인 배열 B가 된다. 적용하는 방법은 B[P[i]] = A[i]이다.

배열 A가 주어졌을 때, 수열 P를 적용한 결과가 비내림차순이 되는 수열을 찾는 프로그램을 작성하시오. 비내림차순이란, 각각의 원소가 바로 앞에 있는 원소보다 크거나 같을 경우를 말한다. 만약 그러한 수열이 여러개라면 사전순으로 앞서는 것을 출력한다.

[입력]

첫째 줄에 배열 A의 크기 N이 주어진다. 둘째 줄에는 배열 A의 원소가 0번부터 차례대로 주어진다. N은 50보다 작거나 같은 자연수이고, 배열의 원소는 1,000보다 작거나 같은 자연수이다.

[출력]

첫째 줄에 비내림차순으로 만드는 수열 P를 출력한다.

[풀이 전략]

일단, 문제를 읽었을 때, 이해가 잘 안간다. 내 한국어 능력이 문제인지, 문제가 이상한 건지 모르겠다. 풀이 전에 문제를 정리를 해보자.

1. A라는 수열이 있고
2. 그에 대한 B라는 비내림차순(단조증가)로 정렬된 수열이 있다.
3. P는 B에 적용했을때, A가 되는 Index의 수열이다. 즉, B[P[i]] = A[i] 여기서 P[i] 는 두값이 같아지는 Index 이다 .

예시) N = 3 , A = [2, 3, 1]인 경우 B = [1, 2, 3] 일것이다. B[P[i]] = A[i] 이여야한다 . A[0]=2 B[P[0]]= 2 => P[0] = 1 이런 식으로 유추된다.

따라서, 해당 예시에서 P[i] = [1, 2, 0] 으로 구할 수 있다.

처음 생각했을 때, 생각했던 로직은 다음과 같다 (1) A, B, P 수열을 생성하고 A의 수열을 입력받는다. (2) B는 A에서 깊은 복사를 받은 후 정렬을 해준다. (3) 조건문과 반복문을 통해 P[i]의 값을 추정하여 수열을 만든다.

[구현코드]

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int N = sc.nextInt();   
    int[] A = new int[N];

    int[] P = new int[N];
    for (int i = 0 ; i<N ; i++) {
        A[i] = sc.nextInt();
    }

    int[] B = A.clone();

    for (int i = 0 ; i< N-1; i++) 
        for (int j = 0 ; j< N-1; j++) {
            if(B[j] > B[j+1]) {
                int tmp = B[j];
                B[j] = B[j+1];
                B[j+1] =tmp;
            }
    }
    for (int i =0 ; i<N ; i++) 
    for (int j = 0 ; j< N; j++) {
         if (A[i]== B[j]) {
             P[i] = j;
             B[j] = -1;
             break;
         }


     }

    for (int i = 0 ; i<N ; i++)
        System.out.print(P[i]+" ");
    }
}

[다른풀이]

1. Arrays.sort() 사용 원래 본래 풀이에서는 실제 그냥 버블 정렬을 통해서 정렬을 했다. 하지만, Arrays.sort()라는 Java에서 배열을 정렬할 때 사용하는 표준 메서드가 있다. cf) .clone() : 그냥 '='할당을 하게되면 얕은복사가 되서 해당 문제풀이에서 이슈가 발생한다. 따라서 깊은 복사를 통해서 만들어야지 적절한 문제해결이 가능하다.

2. 풀이적용

import java.util.Arrays;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int N = sc.nextInt();   
    int[] A = new int[N];

    int[] P = new int[N];
    for (int i = 0 ; i<N ; i++) {
        A[i] = sc.nextInt();
    }

    int[] B = A.clone();
    Arrays.sort(B);

    for (int i =0 ; i<N ; i++) 
    for (int j = 0 ; j< N; j++) {
         if (A[i]== B[j]) {
             P[i] = j;
             B[j] = -1;
             break;
         }


     }

    for (int i = 0 ; i<N ; i++)
        System.out.print(P[i]+" ");
    }
}

오늘은 머리가 아팠던 런치야미 끝

문제 : 백준 1181. 단어 정렬 백준 1181 : 단어 정렬

[문제 분석]

알파벳 소문자로 이루어진 N개의 단어가 들어오면 아래와 같은 조건에 따라 정렬하는 프로그램을 작성하시오.

길이가 짧은 것부터 길이가 같으면 사전 순으로 단, 중복된 단어는 하나만 남기고 제거해야 한다.

[입력]

첫째 줄에 단어의 개수 N이 주어진다. (1 ≤ N ≤ 20,000) 둘째 줄부터 N개의 줄에 걸쳐 알파벳 소문자로 이루어진 단어가 한 줄에 하나씩 주어진다. 주어지는 문자열의 길이는 50을 넘지 않는다.

[출력]

조건에 따라 정렬하여 단어들을 출력한다.

[풀이 전략]

처음 생각했을 때, 생각했던 로직은 다음과 같다 (1) 중복된 단어를 없애기 위해 set을 이용한다. (2) sort를 이용해서 오름차순 정렬을 하면서 (3) compare to를 이용해서 length에 따른 비교 구현

[구현코드]

import java.util.*;

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

        int N = sc.nextInt();

        Set<String> set = new HashSet<>();
        for (int i = 0; i < N; i++) {
            set.add(sc.next());
        }

        List<String> list = new ArrayList<>(set);

        Collections.sort(list, new Comparator<String>() {
            @Override
            public int compare(String a, String b) {
                // 1. 길이 짧은 순
                if (a.length() != b.length()) {
                    return a.length() - b.length();
                }
                // 2. 사전 순
                return a.compareTo(b);
            }
        });

        // 출력
        for (String s : list) {
            System.out.println(s);
        }
    }
}

오늘은 체했던 모닝야미 끝

데이터 베이스는 옛날에 미군에서 컴퓨터 도서관을 만들면서 데이터 기지라는 뜻으로 처음 사용했고 지금까지 용어가 내려오고 있는 단어이다. 오늘은 멀고도 가까운 데이터 베이스에 대해 알아보고자 한다.

데이터 베이스의 정의

데이터 베이스, DB를 생각하면 생각나는 것이 아주 많다. '데이터의 저장소'가 생각날 수도 있을 거 같고, '데이터 웨어하우스'나 '데이터 마트'같은게 익숙하거나 완전 처음 들어볼 수 도 있다.

근데, 이걸 글로 나타낸 것을 보면

• 동시에 복수의 적용 업무를 지원할 수 있도록 복수 이용자의 요구에 대응해서 데이터를 받아들이고 저장, 공급하기 위하여 일정한 구조에 따라서 편성된 데이터의 집합 또는 관련된 레코드의 집합

아주 어렵다.

그렇기에 우리는 조금 나눠서 생각해보자! 도대체 왜? 데이터 베이스라는 것을 쓰는걸까?

아까 정의에서 나타난 개념 중 가장 중요한 것은 두가지로 '공용(Shared)'와 '통합(Integrated) 이다.

데이터는 단순히 데이터가 모래처럼 쌓여있는것을 말하지 않는다.

쉽게 예시를 들면, 각자 PC에 흔어져 있는 엑셀파일이 아니라 조직 자체가 실시간으로 공유하여 중복 없이 관리하는 데이터의 총체라고 할 수 있다.

A업무 - 유(기획) B업무 - 문(디자인) C업무 - 박(인사)

를 각각 특정 제품 데이터를 사용한다고 했을때, 이를 각각 다 다른 데이터 형식, 디자인으로 가지고 있을 수 있다. 그렇다면 불필요한 중복이 생기게 되고 무결성이 깨지게 된다. 따라서 이를 줄이기 위해 실질적으로 '데이터 베이스'를 만들어 '통합'적으로 '공유'하는 것이다. 업로드중..

데이터 베이스의 특성

데이터 베이스의 특성은 정형화해서 말하기 어려운 부분이 물론 있지만 보통 총 4가지로 말한다.

• 통합된 데이터(Integrated Data) : 동일한 내용의 데이터가 중복되어 있지 않다는 것을 의미
• • 데이터 중복은 관리상의 복잡한 부작용을 초래함
• 저장된 데이터(Stored Data) : 컴퓨터가 접근 가능한 저장매체에 저장되는 것을 의미
• • 저장매체 : 자기 디스크나 자기테이프 등
• 공용 데이터(Shared Data) : 여러 사용자가 서로 다른 목적으로 데이터를 공동으로 이용한다는 것을 의미
• • 대용량화되고 구조가 복잡한 것이 많다.
• 변화하는 데이터(Changeable Data) : 데이터베이스에 '지금' 저장된 내용은 현 시점에서의 상태를 나타냄

• 새로운 데이터의 추가, 기존 데이터의 삭제, 갱신으로 항상 변화하면서도 항상 현재의 정확한 데이터를 유지한다는 뜻

다양한 측면에서의 특징

앞서 알아본 일반적 특성 이외에도 다양한 방면에서 특징을 가지고 있다.

• 정보의 축적 및 전달 측면
  • 기계 가독성 : 대량의 정보를 정보처리기기가 읽고 쓸 수 있음
  • 검색 가능성 : 필요한 정보를 검색할 수 있음
  • 원격 조작성 : 정보통신망을 이용하여 원거리에서도 온라인으로 이용할 수 있음

• 정보이용 측면 : 이용자의 정보 요구에 따라 다양한 정보를 신속하게 획득하고 원하는 정보를 경제적으로 찾아 낼 수 있음

• 정보관리 측면 : 방대한 양의 정보를 체계적으로 축적하고 새로운 내용 추가나 갱신이 용이함

• 정보기술발전 측면 : 데이터베이스는 정보처리, 검색, 관리 소프트웨어 등 네트워크 발전기술을 견인할 수 있음

• 경제, 산업적 측면 : 데이터베이스는 인프라로서 특성을 가지고 있어 경제, 산업, 사회 활동의 효율성을 제고하고 국민의 편의를 증진하는 수단으로 의미를 가짐

오늘은 Data를 처리하는 가장 근본적인 기술 중 하나인 DB의 정의와 특징에 대해 배웠다. 많이들 ADsP나 ADP를 준비할텐데 비단, 시험 공부로 끝나지 않고 근본 원리에 대해 배우는 시간이 되셨으면 좋겠다.

들어가는 질문 - 데이터란?

21세기 지금 이 글을 적고있는 2026년 2월 대한민국에 사람들은 '데이터'라는 언어에 이미 많이 익숙하다. 실제 우리가 휴대폰 요금제를 구할 때도 '데이터'라는 용어를 사용한다. 데이터는 라틴어인 Dare(주다)의 과거 분사형으로 '주어진 것'이라는 의미로 사용되었었는데, 현재는 추론과 추정의 근거를 이루는 사실 이라는 표현으로 많이 사용한다. 이는 데이터라는 것은 단순한 객체로서의 가치뿐 아니라 상호관계 속에서 가치를 가지기 때문이다.

데이터 & 정보

데이터의 유형

'데이터'의 특성을 나타내는 것 중에 가장 먼저 쓰는 용어는 '정성적', '정량적' 특성이라는 표현이다.

정성적은 물질의 성분이나 성질, 쉽게 말해 수치화 되어 있지 않은 특성을 말한다.

정량적은 양을 나타내거나 수치, 도형, 기호 등으로 나타내는 특성을 말한다.

이것을 확장해서 데이터를 비교하게 되면 아래와 같다.

• 정성적 데이터(Qualitative Data) : 저장이나 검색 등에 많은 비용이 소모되는 언어, 문자 등의 형태의 데이터 ex) 질환 사진, 블로그 글 등

• 정량적 데이터(Quantitative Data) : 정형화된 데이터들이며 실제 수치, 도형 기호 등으로 형태가 있으며 저장 검색 등 이 쉬움 ex) 나이, 키, 몸무게 등

데이터의 역할 : 지식경영의 핵심 이슈

아주 갑자기 데이터를 설명하다가 '지식경영'이라는 말이 나왔다. 나도 모르게 당황스러운 흐름이다.. 유명한 데이터 관련 시험에서 이런 흐름으로 내용이 이루어져있는데,

왜일까?

사실 데이터 그 자체는 어떠한 의미를 가지지 않는다. 우리는 그 데이터를 통해서 올바른 의사결정을 내리고 미래를 예측하고자 하는 것이 목적이다.

암묵지(Tacit Knowledge) & 형식지(Explicit)

• 암묵지 : 학습과 경험을 통해 개인에게 체화되어 있지만 겉으로 드러나지 않는 지식 -> 사회적으로 중요하지만 공유되기 어려움 ex) 글씨 이쁘게 쓰는 법, 과자봉지 빨리뜯는 법 등
• 형식지 : 문서나 메뉴얼 같이 형상화되어있는 지식

• 전달과 공유가 용이함 ex) 책, 유튜브영상 등

cf) 암묵지 & 형식지의 4단계 지식 전환 모드 : SECI 모델(Socialization-Externalization-Combination-Internalization Model)

• 1단계 : 공통화 암묵지의 지식 노하우를 다른 사람에게 알려주는 것

• 2단계 : 표출화 암묵적 지식 노하우를 책, 교본 등 형식지로 만드는 것

• 3단계 : 연결화 책이나 교본(형식지)에 자신이 알고 있는 새로운 지식(형식지)를 추가하는 것

• 4단계 : 내면화 만들어진 책이나 교본(형식지)를 보고 다른 직원들이 노하우(암묵적 지식)를 습득하는 것

  ---

데이터와 정보의 관계(DIKW 피라미드)

여러 시험에서 잘 다뤄지는 내용으로 실제 데이터에서부터 지혜를 얻는 과정을 계층구조로 표현한 것이다.

순서대로 생각해보면 아래와 같다.

• 데이터(Data) : 존재형식이나 다 데이터와의 상관관계등이 없는 가공하기 전의 수치나 기호

• 정보(Information) : 데이터의 가공, 처리와 데이터간 연관관계 속에서 의미가 도출된 것

• 지식(Knowledge) : 데이터의 연결된 패턴을 이해하여 이를 토대로 예측한 결과물

• 지혜(Wisdom) : 근본 원리에 대한 깊은 이해를 바탕으로 도출되는 아이디어(추론)

실제 우리가 햄버거 집을 가보자고 하자. 내가 지금있는 역삼역 근처에는 햄버거집이 KFC와 노브랜드 버거가 있다.(아래의 예시는 가정이다.)

KFC 치킨버거 : 6000원 노브랜드 치킨버거 : 6500원 이라고 했을때

데이터 : KFC 6000원, 노브랜드 6500원 정보 : KFC가 500원 더 싸다 지식 : 가난한 나는 더 싼 KFC에서 햄버거를 먹어야 겠당! 지혜 : 다른 것도 KFC가 더 싸겠군!

이 과정이라고 생각하면 된다.

오늘 내용 중에서 중요한 것은 다름이 아니라 '데이터'는 결국 '추론'을 하기위해 수집된는 것이다!

문제 : 백준 10798. 세로읽기 백준 10798 : 세로읽기

[문제 분석]

아직 글을 모르는 영석이가 벽에 걸린 칠판에 자석이 붙어있는 글자들을 붙이는 장난감을 가지고 놀고 있다.

이 장난감에 있는 글자들은 영어 대문자 ‘A’부터 ‘Z’, 영어 소문자 ‘a’부터 ‘z’, 숫자 ‘0’부터 ‘9’이다. 영석이는 칠판에 글자들을 수평으로 일렬로 붙여서 단어를 만든다. 다시 그 아래쪽에 글자들을 붙여서 또 다른 단어를 만든다. 이런 식으로 다섯 개의 단어를 만든다. 아래 그림 1은 영석이가 칠판에 붙여 만든 단어들의 예이다. <그림 1>

한 줄의 단어는 글자들을 빈칸 없이 연속으로 나열해서 최대 15개의 글자들로 이루어진다. 또한 만들어진 다섯 개의 단어들의 글자 개수는 서로 다를 수 있다.

심심해진 영석이는 칠판에 만들어진 다섯 개의 단어를 세로로 읽으려 한다. 세로로 읽을 때, 각 단어의 첫 번째 글자들을 위에서 아래로 세로로 읽는다. 다음에 두 번째 글자들을 세로로 읽는다. 이런 식으로 왼쪽에서 오른쪽으로 한 자리씩 이동 하면서 동일한 자리의 글자들을 세로로 읽어 나간다. 위의 그림 1의 다섯 번째 자리를 보면 두 번째 줄의 다섯 번째 자리의 글자는 없다. 이런 경우처럼 세로로 읽을 때 해당 자리의 글자가 없으면, 읽지 않고 그 다음 글자를 계속 읽는다. 그림 1의 다섯 번째 자리를 세로로 읽으면 D1gk로 읽는다.

그림 1에서 영석이가 세로로 읽은 순서대로 글자들을 공백 없이 출력하면 다음과 같다:

Aa0aPAf985Bz1EhCz2W3D1gkD6x

칠판에 붙여진 단어들이 주어질 때, 영석이가 세로로 읽은 순서대로 글자들을 출력하는 프로그램을 작성하시오.

[입력]

총 다섯줄의 입력이 주어진다. 각 줄에는 최소 1개, 최대 15개의 글자들이 빈칸 없이 연속으로 주어진다. 주어지는 글자는 영어 대문자 ‘A’부터 ‘Z’, 영어 소문자 ‘a’부터 ‘z’, 숫자 ‘0’부터 ‘9’ 중 하나이다. 각 줄의 시작과 마지막에 빈칸은 없다.

[출력]

영석이가 세로로 읽은 순서대로 글자들을 출력한다. 이때, 글자들을 공백 없이 연속해서 출력한다.

[풀이 전략]

처음 생각했을 때, 생각했던 로직은 다음과 같다 (1) 1차원 배열을 통해서 입력받은 문자열을 저장함 ** 이때 strArr의 length를 이용하서 max 값을 얻어 실제 arr 열의 길이를 구함 (2) 2차원 배열을 통해 char를 다 저장해줌 이때, 기본값은 null임 (3) 반복문을 두번 돌려서 세로로 한글자씩 받아오는데, 이때 세로줄에 null이 있으면 통과하는 코드 추가

[구현코드]

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String[] strArr = new String[5];
        int max = 0;
        for (int i = 0 ; i< 5 ; i++) {
            strArr[i] = sc.next();
            if (strArr[i].length() > max) max = strArr[i].length();
            } 
        char[][] arr = new char[5][max];
        for (int i =0 ; i<5 ; i++) for(int j = 0; j<strArr[i].length() ; j++) arr[i][j] = strArr[i].charAt(j);

        for(int i= 0 ; i<max ; i++)
            for(int j= 0 ; j<5 ; j++) {
                if (arr[j][i] == '\u0000')
                    continue; 
                System.out.print(arr[j][i]);}

    }
}

[다른풀이]

1. 문제 접근 방식 strArr와 size를 기반으로 길이 기반 풀이 길이를 같이 저장해서 길이로 조건을 줘서 print를 다르게 줌

2. 풀이적용

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // 선언
        Scanner sc = new Scanner(System.in);
        String[] strArr = new String[5];
        int[] size = new int[5]; // 5줄의 길이를 저장
        // 할당
        for (int i = 0 ; i< 5 ; i++) {
            strArr[i] = sc.next();
            size[i] = strArr[i].length();
            }
        // 길이가 된다면 출력
        for(int i= 0 ; i<15 ; i++) {
            for(int j= 0 ; j<5 ; j++) {
                if (size[j]>i)
                    System.out.print(strArr[j].charAt(i));
            }
        }
    }
}

오늘은 맛있는 새벽야미 끝

• 자바의 가장 최상위 클래스로 모든 클래스의 조상
• 모든 클래스는 직접적으로나 간접적으로 Object를 상속 받음
• Object의 멤버는 모든 클래스의 멤버

toString() 메서드

• 객체를 문자열로 변경하는 메서드를 말함

상세코드

public String toString(){
    return getClass().getName() + "@" + Integer.toHexString(hashCode());

}

- getClass()

    * 현재 객체의 실제 클래스 정보를 반환
    * 다형성 상황에서도 정확한 클래스가 나옴

- getName()

    * 클래스의 전체 경로 포함 이름 반환

        예: com.example.Student

- "@" : 구분자
- hashCode()
  * 객체의 고유한 정수값(int)
  * 기본 구현에서는 보통 객체의 메모리 주소 기반

 - Integer.toHexString(hashCode())
  * 메모리 주소 표현 방식이랑 친숙
  * 길이가 짧고 개발자들이 보기 편함

위의 코드의 결과는

com.example.Student@3f99bd52 이런 식으로 나오게 된다.

이건 쉽게 말해서, " 나는 com.example.Student 클래스에서 만들어진 객체이고, 이 해시값을 가진 인스턴스야" 라는 뜻을 가진다.

여기서 나타나는 이 문장이 실제 중요한 의미를 가지기는 어렵다. 따라서 우리는 이걸 Overriding을 해서 우리가 넣고 싶은 의미를 알 수 있게 만든다.

@Override
public String toString() {
    return "Student{name='" + name + "', age=" + age + "}";
}

equals() 메서드

• 두 객체가 동일한지 비교하는 메서드

  public boolean equals(Object obj){
    return (this == obj);
  }

  기본 equals() 메서드는 두 객체의 참조값(메모리 주소) 이 동일한지를 비교하므로, 동작 자체는 == 연산자와 동일하다.

하지만 String과 같은 일부 클래스는 equals() 메서드를 오버라이딩하여 객체의 값(value) 을 비교하도록 구현되어 있다. 이 때문에 같은 문자열 값을 가지는 서로 다른 객체라도 equals()는 true를 반환할 수 있다.

따라서 일반적으로 다음과 같이 이해할 수 있다.

== → 같은 객체인가? (주소 비교)

equals() → 논리적으로 같은 값인가? (내용 비교)

단, 사용자 정의 클래스에서는 equals()를 오버라이딩하지 않으면 equals() 역시 주소 비교를 수행한다.

hashCode() 메서드

• HashSet, HashMap 등에서 객체의 동일성을 확인하기 위해 사용
• equals 메서드를 재정의 할 때는 반드스 hashCode()

cf) hashcode : 객체를 식별하는 정수형 값 - 객체를 빠르게 검색하거나 비교할 때 사용 - 기본적으로 메모리 주소 기반으로 생성하지만 재정의 가능

getClass() 메서드

: 객체의 런타임 클래스 정보를 반환

public class Main{
public static void main(String[] args){
    String str = "Hello";
    System.out.println(str.getClass()); // class java.lang.String 
}
}

기타 메서드

• clone()
• finalize()
• wait() / notify() 등등

문제 : 백준 10990. 별 찍기 - 15 백준 10990 별 찍기 - 15

[문제 분석]

예제를 보고 규칙을 유추한 뒤에 별을 찍어 보세요.

[입력]

첫째 줄에 N(1 ≤ N ≤ 100)이 주어진다.

[출력]

첫째 줄부터 N번째 줄까지 차례대로 별을 출력한다.

[풀이 전략]

처음 생각했을 때, 생각했던 로직은 다음과 같다 (1) 빈칸 / * / 빈칸 / * 구조로 구현 (2) 조건문 : 처음에만 실제 별이 하나가 나타나야함 (3) 첫 번째 빈칸 N-1~0개으로 줌 (3) 가운데 빈칸 0, 1, 3, 5으로 증가함

[구현코드]

import java.util.Scanner;

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


Scanner sc = new Scanner(System.in);
int N = sc.nextInt(); 
for(int i = 0 ; i < N ; i++) {
    for(int j = 1 ; j < N-i  ; j++) { 
        System.out.print(" ");
        }
    if (i!=0)
        System.out.print("*");
    for(int j = N -2*i+1 ; j < N ; j ++) { 
        System.out.print(" ");
        }

    System.out.print("*");

    System.out.println();

}
}
}

[개선사항]

1. 절대값을 사용 Math.abs() 메서드는 입력된 숫자의 절댓값(Absolute Value)을 반환하는 Java의 표준 수학 함수이다. 단순히, 부호를 없애는 함수를 넘어 실제 기준점으로부터의 거리(Distance)를 계산하여 대칭으로 만들어내는 핵심 역할 수행

2. 문제 접근 방식 핵심 : 좌표 기반 접근 => 별이 찍히는 위치를 중심축으로부터의 거리로 해석 중심축 : j = N인 지점을 중심축으로 봄 거리계산 : |N - j| 중심축(N)과 현재 가로위치(j) 사이의 거리 별의 위치 : 위에서 아래로 내려올수록(i가 증가할수록), 별은 중심축에서 i만큼 떨어진 양쪽 대칭 지점에 찍힘

2. 풀이적용

import java.util.Scanner;
public class Main{
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N = sc.nextInt();
        // 세로(N)
        for (int i=0; i<N;i++) {
            // 가로 (N+세로 길이)
            for (int j=1; j<=N+i;j++) {
                // i == |N - j| 라면 * 찍기
                if (i==Math.abs(N-j))
                    System.out.print("*");
                // 아닌 경우 공백
                else
                    System.out.print(" ");
            }
            System.out.println();
        }
    }
}

오늘은 맛있는 런치야미 끝

문제 : 백준 2752. 세수정렬 백준 2752. 세수정렬

[문제 분석]

동규는 세수를 하다가 정렬이 하고 싶어졌다.

정수 세 개를 생각한 뒤에, 이를 오름차순으로 정렬하고 싶어졌다.

정수 세 개가 주어졌을 때, 가장 작은 수, 그 다음 수, 가장 큰 수를 출력하는 프로그램을 작성하시오.

[입력]

정수 세 개가 주어진다. 이 수는 1보다 크거나 같고, 1,000,000보다 작거나 같다. 이 수는 모두 다르다.

[출력]

제일 작은 수, 그 다음 수, 제일 큰 수를 차례대로 출력한다.

[풀이 전략]

처음 생각했을 때, 생각했던 로직은 다음과 같다 (1) 정수 3개를 배열로 받는다. (2) 배열을 반복문을 통해 비교한다. (3) 조건문을 통해서 실질적으로 순서 할당

[구현코드]

import java.util.Scanner;

public class Main {
public static void main(String[] args) {
    int[] arr= new int[3];
    Scanner sc = new Scanner(System.in);
    arr[0] = sc.nextInt();
    arr[1] = sc.nextInt();
    arr[2] = sc.nextInt();
    for (int i=0; i<3; i++)
        for(int j=0; j<2 ; j++)
            if(arr[j] > arr[j+1]) {
                int temp = 0; 
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp; 
                }

    System.out.print(arr[0]+" ");
    System.out.print(arr[1]+" ");
    System.out.print(arr[2]+" ");

}

}

[개선사항]

1. Arrays.sort 함수 사용

   for (int i=0; i<3; i++)
        for(int j=0; j<2 ; j++)
            if(arr[j] > arr[j+1]) {
                int temp = 0; 
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp; 
                }

   위에 구현한 코드는 이렇게 아래와 같이 작성할 수 있음

Arrays.sort(arr);

2. 최적화

import java.util.Arrays;
import java.util.Scanner;

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

        Scanner sc = new Scanner(System.in);

        /* 풀이 접근 방법
        배열을 만든 후 해당 배열 안에 입력값들을 받은 후
        Arrays.sort()를 이용해서 오름차순으로 정렬 뒤 차례대로 출력
         */

        //입력 받은 값 만큼의 배열을 만든 후 배열 크기 설정 
        int[] arr = new int[3];

        //반복문을 통해 arr의 크기 만큼 입력값 받기
        //보통 배열을 이용할 때 초기식의 초기값은 0으로 시작하는 게 좋음
        for(int i = 0; i<arr.length; i++) {

            //arr.length의 크기는 3번이니 총 3번의 값을 받음
            arr[i] = sc.nextInt();
        }

        //arr을 오름차순으로 배열
        Arrays.sort(arr);

        //차례대로 출력
        for(int i : arr) {
            System.out.printf("%d ", i);
        }

    }
} 

오늘도 맛있는 모닝야미 끝

사실 이 글을 적게된 아주 큰 이유는 내가 '진짜 비전공자'이기 때문이 크다.. 비전공자에게 프로그래밍의 시작에서 가장 어려운 지점은 바로 '프로그램'을 설치하는게 복잡하다는 점이다. 이 글이 누군가에게 읽히게 될지는 잘모르겠지만 실제 비전공자분들이 '자바'라는 프로그램 언어를 시작하는데 도움이 되길 바란다.

JDK(Java Development Kit)

JDK(Java Development Kit)란 자바(Java) 언어로 프로그램을 개발하기 위해 필요한 모든 도구와 라이브러리(컴파일러, 디버거 등)를 모아놓은 소프트웨어 개발 키트를 말한다. 프로그래밍을 배우기 시작하는 여러분에게는 기본적으로 이 개발 키트를 다운로드 하는 것으로 드디어 자바라는 무거운 문을 열게된다.

Window에 JDK 설치하기

자바를 다운로드 하는 방법은 다양하지만, 오늘 우리는 scoop 이용하는 방법에 대해 알아보고자한다. 여기서 scoop이란 아래와 같다.

앱과 해당 종속성을 다운로드하고 설치하는 데 사용되는 Microsoft Windows용 명령줄 패키지 관리자으로 Scoop은 웹 개발 도구 및 기타 소프트웨어 개발 도구를 설치하는 데 자주 사용'되는 도구를 말함

아주 어렵게 말했지만, 쉽게 말하자면 터미널에서 명령어 한 줄로 프로그램 깔고, 업데이트하고, 정리해주는 아주 고마운 프로그램이다.

Scoop 설치

Scoop의 대문은 아래와 같다.

Scoop 다운로드 사이트

Scoop에 들어갔다면, Window PowerShell을 열어준다.

해당 화면에서 아래와 같은 순서로 진행하게 되면 Scoop을 설치할 수 있다. (1) c:\ 이동
" Open a PowerShell terminal (version 5.1 or later) and from the PS C:> prompt, run: " => Scoop의 Quickstart에도 설명이 나와있다.

(2) Scoop 설치 스크립트 실행

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser

의미 : PowerShell 실행 정책 설정 명령어 => 외부에서 내려받은 스크립트를 실행 가능하게 만드는 사전 설정

Invoke-RestMethod -Uri https://get.scoop.sh | Invoke-Expression

의미 : Scoop 설치 스크립트를 다운로드해서 즉시 실행하는 명령어

(3) Scoop 설치완료

java 버킷 추가

다음으로는 Scoop을 이용하여 자바 버킷을 추가하자 => 이게 도대체 무슨 말일까? 버킷 = 설치 가능한 프로그램 목록 + 설치 방법이 적힌 저장소 따라서, 자바 버킷을 Scoop에서 추가한다는 말은 "자바 설치 메뉴판을 Scoop에 추가"한다는 뜻이다.

scoop bucket add java

java 버킷 검색

JDK를 검색해서 리스트를 확인해보자

scoop search jdk

jdk 설치

scoop install "Name"
scoop install zulu11-jdk

jdk 설치확인

java --version

이렇게 내가 원하는 버전의 jdk가 잘 설치가 되었음을 알 수 있다.

cf) Eclipse 다운로드

코드 작성을 편리하게 하게 하기위해서는 IDE를 깔아서 사용하는게 좋은데, 물론 IntelliJ 같은 좋은 프로그램도 있지만, 사실 처음 개발을 배우는 단계에서는 Eclipse가 사용하기 좋다.

Eclipse = 자바 개발용 통합 개발 환경(IDE)

아래 링크에서 다운로드 받을 수 있다. 이클립스 파운데이션

다운로드를 받은 후에 installer를 키게 되면

이 화면이 나타나게 되는데 여기서 Eclipse IDE for Java Developers 옵션으로 설치하면 된다. 설치 후 실행하면

워크스페이스를 설정할 수 있고, 이후로는 실제 사용하면 된다.

이 글은 26. 02. 04.에 백준을 풀려고 집 데스크탑을 열었는데, 이클립스가 안깔려있어서 귀찮아하며 이럴거면 벨로그에 글이라도 쓰자는 마인드로 적게 되었던 글입니다.