자바에서는 변수를 선언할 때 기본형(Primitive Type)과 참조형(Reference Type)으로 나눌 수 있다.

기본형(Primitive Type)

• int, long, double, boolean, char 등

• 변수에 값 자체를 저장

• 연산 가능, null 사용 불가

  int a = 10;
  int b = a; // 값 10을 복사

• 값을 복사했기 때문에 a와 b는 서로 영향을 주지 않는다.*

참조형(Reference Type)

• 클래스, 배열, 인터페이스 등

• 변수에 객체나 배열의 메모리 주소(참조값) 저장

• 연산 불가, null 사용 가능

  Student s1 = new Student();
  Student s2 = s1; // 참조값 복사

• s1과 s2는 같은 객체를 가리킨다. 따라서 한 쪽에서 값을 바꾸면 다른 쪽에도 영향을 준다.*

기본형 변수에는 직접 사용할 수 있는 값이 들어있지만 참조형 변수에는 위치(참조값)가 들어가 있다. 참조형 변수를 통해서 뭔가 하려면 결국 참조값을 통해 해당 위치로 이동해야 한다

자바에서 String은 특별하다. String은 사실은 클래스이기 때문에 참조형이다. 그런데 기본형처럼 문자 값을 바로 대입할 수 있다. 문자열은 매우 자주 다루기 때문에 자바에서 특별하게 편의 기능을 제공한다.

메서드 호출 시 차이

자바는 항상 값을 복사해서 전달한다. 하지만 전달되는 값이 "실제 값"인지 "참조값"인지에 따라 결과가 달라진다.

기본형 전달

void change(int x) {
    x = 20;
}

int a = 10;
change(a);
System.out.println(a); // 10

→ 값만 복사되므로 원본 a는 변경되지 않음

참조형 전달

public class Student {
  String name;
  int age;
  int grade;
}

void change(Student s) {
    s.grade = 100;
}

Student student = new Student();
student.grade = 90;
change(student);
System.out.println(student.grade); // 100

→ 참조값이 복사되었기 때문에 같은 객체를 공유함. 내부 상태 변경 가능

기본형과 참조형의 메서드 호출

자바에서 메서드의 매개변수(파라미터)는 항상 값에 의해 전달된다. 그러나 이 값이 실제 값이냐, 참조(메모리 주소)값이냐에 따라 동작이 달라진다.

• 기본형 메서드로 기본형 데이터를 전달하면, 해당 값이 복사되어 전달된다. 이 경우, 메서드 내부에서 매개변수(파라미터)의 값을 변경해도, 호출자의 변수 값에는 영향이 없다.
• 참조형 메서드로 참조형 데이터를 전달하면, 참조값이 복사되어 전달된다. 이 경우, 메서드 내부에서 매개변수(파라미터)로 전달된 객체의 멤버 변수를 변경하면, 호출자의 객체도 변경된다.

메서드 호출 활용

public static void main(String[] args) {
    Student student1 = createStudent("학생1", 15, 90);
    Student student2 = createStudent("학생2", 14, 95);

    printStudent(student1);
    printStudent(student2);
}

static void printStudent(Student student) {
    System.out.println("이름:" + student.name + " 나이:" + student.age + " 성적:" + student.grade);
}

static Student createStudent(String name, int age, int grade) {
    Student student = new Student();
    student.name = name;
    student.age = age;
    student.grade = grade;

    return student;
}

• createStudent()라는 메서드를 만들고 객체를 생성하는 부분도 이 메서드안에 함께 포함했다. 이제 이 메서드 하나로 객체의 생성과 초기값 설정을 모두 처리한다.
• 그런데 메서드 안에서 객체를 생성했기 때문에 만들어진 객체를 메서드 밖에서 사용할 수 있게 돌려주어야 한다. 그래야 메서드 밖에서 이 객체를 사용할 수 있다.
• 메서드는 호출 결과를 반환(return)을 할 수 있다. 메서드의 반환 기능을 사용해서 만들어진 객체의 참조값을 메서드 밖으로 반환하면 된다

변수의 초기화

• 멤버 변수(필드): 클래스에 선언
• 지역 변수: 메서드에 선언, 매개변수도 지역 변수의 한 종류

class Data {
    int x; // 자동 초기화: 0
    String str; // 자동 초기화: null
}

void method() {
    int y; // 초기화 안 하면 오류 발생
    System.out.println(y); // ❌
}

참조형의 null과 NullPointerException

참조형 변수는 아직 객체를 가리키지 않을 때 null로 초기화된다.

public class Data {
    int value;
}

Data data = null;
data.value = 0; // ❌ NullPointerException

→ null은 아무 객체도 가리키지 않기 때문에 .name과 같은 접근 시 예외 발생

GC (Garbage Collection)

자바에서는 더 이상 사용하지 않는 객체를 자동으로 정리(삭제)해주는 기능이 있다.
이것을 GC(Garbage Collection, 가비지 컬렉션)이라고 부른다.

Data data = null;
System.out.println("1. data = " + data);

data = new Data();
System.out.println("2. data = " + data);

data = null;
System.out.println("3. data = " + data);

실행 흐름 설명

1. data = null;

• data 변수는 null로 초기화되어 있어 아무 객체도 참조하지 않는 상태이다.
• 출력 결과: 1. data = null

2. data = new Data();

• new Data()로 새로운 객체가 생성되고, 해당 객체의 참조값이 data 변수에 저장된다.
• 이 시점에서 메모리 어딘가에 Data 인스턴스가 존재하고, data가 그 위치를 참조한다.
• 출력 결과: 2. data = ref.Data@xxxxxx (참조값)

3. data = null;

• 다시 data 변수에 null을 할당하면, 기존에 참조하던 Data 객체와의 연결이 끊긴다.
• 이제 아무도 그 객체를 참조하지 않게 되며, 더 이상 접근할 방법이 없다.
• 출력 결과: 3. data = null

이 시점에 메모리 내부에서는 Data 객체는 여전히 메모리에 존재하지만, 참조하는 변수(data)가 없기 때문에 쓸모 없는 객체가 된다. 이러한 객체를 자바에서는 Garbage(쓰레기)로 판단한다. GC(Garbage Collector)는 이러한 객체를 주기적으로 감지하고 메모리에서 자동으로 제거한다.

GC(Garbage Collection)의 특징

• 수동 삭제 불필요 개발자가 직접 free()나 delete를 호출할 필요 없음 (C/C++과의 차이점)

• 참조가 끊긴 객체만 제거 현재 어떤 변수도 참조하지 않는 객체만 GC 대상이 됨

• 언제 작동할지 모름 GC는 JVM이 알아서 적절한 시점에 실행함 (명시적 제어는 어려움)

• null 할당은 힌트일 뿐 변수에 null을 대입해도 GC가 바로 작동하진 않음

주의할 점

• 참조가 하나라도 남아 있으면 GC 대상이 아님

• 메모리 누수를 막기 위해 불필요한 참조는 null로 명시적으로 끊어주는 것이 좋을 때도 있음

• 단, null을 썼다고 해서 GC가 즉시 작동하는 것은 아니다

자바는 객체지향 프로그래밍 언어입니다. 그리고 그 중심에는 클래스(class)가 있습니다. 클래스를 이해하면 객체를 만들고 다룰 수 있으며, 코드의 재사용성과 구조적 설계 능력을 갖출 수 있습니다.

클래스가 필요한 이유

학생 2명의 이름, 나이, 성적을 출력하는 프로그램을 만들려면 아래와 같이 각각의 변수를 만들어야 한다.

String student1Name = "학생1";
int student1Age = 15;
int student1Grade = 90;
String student2Name = "학생2";
int student2Age = 16;
int student2Grade = 80;

문제점

• 학생 수가 늘어나면 변수도 함께 늘어남
• 출력 코드도 늘어나며 유지보수가 어려움

배열 도입 후 개선

String[] names = {"학생1", "학생2"};
int[] ages = {15, 16};
int[] grades = {90, 80};

• 반복문 사용 가능
• 하지만 이름, 나이, 성적이 각각 다른 배열로 나뉘어 있어 데이터 정합성 관리가 어려움

클래스 도입

public class Student {
    String name;
    int age;
    int grade;
}

Student student1 = new Student();
student1.name = "학생1";
student1.age = 15;
student1.grade = 90;

• 학생이라는 하나의 단위로 데이터를 묶어 관리
• 코드 가독성과 유지보수성 향상

클래스란?

• 클래스는 객체를 만들기 위한 설계도
• 클래스는 객체가 가져야 할 속성(필드)과 기능(메서드)를 정의

클래스의 기본 구조

public class 클래스이름 {
    // 멤버 변수 (필드)
    // 생성자
    // 메서드
}

객체(Object)와 인스턴스(Instance)

• 객체(Object): 클래스에 따라 생성된 실체
• 인스턴스(Instance): 객체와 의미는 같지만, 특정 클래스에서 만들어졌다는 것을 강조할 때 사용

  Student student1 = new Student(); // student1은 Student 클래스의 인스턴스

객체 생성 과정

Student student1 = new Student();

1. new Student() → 메모리에 Student 객체 생성 (예: x001)

2. student1 변수에 참조값(x001) 저장

3. student1.name → x001 객체의 name 필드에 접근

자바는 객체 자체가 아니라 객체 참조값(주소)을 저장한다.

클래스와 필드 사용

Student student = new Student();
student.name = "학생1";
student.age = 15;
student.grade = 90;

• student.name처럼 .(dot)으로 객체의 필드에 접근

System.out.println(student.name);

• 참조값을 통해 실제 객체의 데이터에 접근해 출력함

배열과 클래스 결합

학생이 많아질 경우, Student 객체를 배열로 관리할 수 있다.

Student[] students = new Student[2];
students[0] = student1;
students[1] = student2;

출력 예시:

for (Student s : students) {
    String result = String.format("이름: %s, 나이: %d, 성적: %d", s.name, s.age, s.grade);
    System.out.println(result);
}

마무리

지금까지 클래스를 도입하는 이유와 객체 생성 방식, 그리고 배열과 결합하여 데이터를 어떻게 구조화할 수 있는지 배웠습니다.
클래스를 통해 현실 세계의 개념을 코드로 표현할 수 있다는 점에서, 객체지향 프로그래밍의 첫걸음을 떼었다고 할 수 있습니다.

다음 글에서는 객체를 생성할 때 자동으로 호출되는 생성자(Constructor)와 객체의 동작을 정의하는 메서드(Method)에 대해 자세히 알아보겠습니다.

운영체제는 프로그램을 실행할 때 메모리를 여러 영역으로 나누어 관리한다. 대표적인 구조는 다음과 같다.

• 코드(Code) 영역 실행할 프로그램의 기계어 코드가 저장되는 영역 주로 읽기 전용이며, 실행 중 변경되지 않는다.
• 데이터(Data) 영역 전역 변수나 static 변수처럼 프로그램 전체에서 공유되는 데이터가 저장되는 공간
• 힙(Heap) 영역 동적으로 할당되는 메모리 공간 new, malloc() 등을 통해 할당하며, 명시적으로 해제해줘야 합니다.
• 스택(Stack) 영역 함수 호출 시 지역 변수와 리턴 주소 등을 저장하는 공간 함수가 끝나면 자동으로 메모리가 해제된다.

힙은 위쪽으로, 스택은 아래쪽으로 자라며, 중간에서 만나면 메모리 부족(overflow) 이 발생할 수 있다.

2. 가상 메모리(Virtual Memory)

가상 메모리는 실제 메모리(RAM)보다 더 큰 메모리를 사용하는 것처럼 보이게 하는 운영체제의 기법이다.

• 프로세스마다 독립된 메모리 공간을 제공하여 안정성과 보안을 보장
• 실제 필요한 메모리만 물리 메모리에 올려두고, 나머지는 디스크(보조기억장치) 에 저장한다.

3. 페이지와 페이지 폴트

가상 메모리는 페이지(Page) 단위로 관리된다.

• 가상 주소 공간과 물리 주소 공간을 같은 크기의 페이지로 나눕니다.
• 필요한 페이지만 물리 메모리에 올려 사용합니다.

페이지 폴트(Page Fault)는 접근하려는 페이지가 물리 메모리에 없을 때 발생하는 인터럽트이다. 이 경우 운영체제가 해당 페이지를 디스크에서 불러와 물리 메모리에 적재한다.

4. 스와핑(Swapping)

스와핑은 프로세스의 일부나 전체를 디스크와 메모리 사이에서 교체하는 것을 말한다.

• 메모리가 부족할 경우, 덜 사용되는 데이터를 디스크로 내보내고(active한 프로세스에게 메모리를 할당) 필요할 때 다시 불러온다.
• 이 과정은 느리지만 메모리를 효율적으로 사용할 수 있게 해준다.

5. 가상 메모리의 동작 과정 요약

1. 프로세스는 가상 주소를 사용해 메모리에 접근
2. MMU(메모리 관리 유닛)가 페이지 테이블을 참조해 물리 주소로 변환
3. 물리 메모리에 해당 페이지가 없으면 → 페이지 폴트 발생
4. 운영체제가 디스크에서 페이지를 읽어와 물리 메모리에 적재
5. 프로세스는 다시 해당 데이터에 접근 가능

정리

하나의 프로그램이 여러 개의 프로세스를 생성하여 병렬로 실행하는 구조

• 각 프로세스는 독립된 메모리 공간을 가짐
• 프로세스 간 통신은 IPC(Inter-Process Communication)을 통해 수행됨 (예: 파이프, 소켓 등)
• 하나가 죽어도 다른 프로세스에 영향이 적음

예시

• 웹 브라우저(크롬): 탭마다 별도 프로세스로 실행 → 한 탭이 다운되어도 다른 탭은 영향 없음
• 서버: 클라이언트 요청마다 별도 프로세스로 처리

멀티스레드(Multi-Thread)란?

하나의 프로세스 안에서 여러 개의 스레드가 동시 실행되는 구조

• 스레드는 코드, 데이터, 힙을 공유하고 스택만 독립적
• 같은 프로세스 내에서 빠르게 통신하고 협업 가능
• 하지만 하나의 스레드 오류가 전체 프로세스에 영향을 줄 수 있음

예시

• 게임 클라이언트: 렌더링, 사운드, 네트워크를 각각 다른 스레드에서 처리
• 웹 서버: 요청 처리, 로깅, DB 저장 등을 스레드로 병렬화

구조 비교

장단점 요약

멀티프로세스

• 장점
  • 안정성 높음 (독립적 구조)
  • 문제 발생 시 확산 방지
• 단점
  • 메모리 사용량 많음
  • 프로세스 간 통신이 복잡하고 느림

멀티스레드

• 장점
  • 메모리 효율적 (공유 구조)
  • 통신 및 협업 빠름
• 단점
  • 스레드 간 동기화 필요 (race condition 발생 가능)
  • 하나의 스레드가 전체를 멈출 수 있음

선택 기준은?

예시

• 브라우저는 탭마다 격리가 필요해 멀티프로세스
• 게임, 실시간 서버는 빠른 반응이 필요해 멀티스레드

프로세스는 실행 중인 프로그램의 인스턴스이다.

하나의 실행 파일(.exe, .py 등)을 더블 클릭하면, 운영체제는 그 파일을 메모리에 로딩하고 독립적인 실행 환경을 구성하며, 이때 만들어지는 것이 바로 프로세스이다.

• 고유한 메모리 공간을 가짐 (코드, 데이터, 스택, 힙)

  • Code : 코드 자체를 구성하는 메모리 영역 (프로그램 명령)
  • Data : 전역 변수, 정적 변수, 배열 등 초기화된 데이터는 Data 영역에 저장 초기화되지 않은 데이터는 BSS 영역에 저장
  • Heap : 동적 할당 시 사용 (new(), malloc() 등)
  • Stack : 지역 변수, 매개 변수, 리턴 값 (임시 메모리 영역)

• 운영체제에서 PID(Process ID)를 부여

• 서로 독립적이기 때문에 다른 프로세스와 직접 메모리를 공유하지 않음

스레드(Thread)란?

스레드는 프로세스 내에서 실행되는 작업의 최소 단위이다.

모든 프로세스는 최소한 하나의 스레드를 가지고 시작하며, 필요에 따라 여러 개의 스레드를 가질 수 있다. 같은 프로세스 내 스레드들은 메모리 공간을 공유하기 때문에 협업이 빠르고 효율적이다.

• 스레드는 Stack만 따로 할당받고 나머지 영역은 공유한다.

  • 코드, 데이터, 힙 영역은 공유
  • 스택은 스레드마다 별도로 존재

• 스레드는 독립적인 동작을 수행하기 위해 존재 (독립적으로 함수를 호출할 수 있어야 함)

• 함수의 매개 변수, 지역 변수 등을 저장하는 Stack 영역은 독립적으로 할당받아야 함

• 경량화된 실행 단위로, 생성/소멸 비용이 적음

프로세스 vs 스레드 비교표

메모리 구조 관점에서의 차이

1. 운영체제의 기본 메모리 영역 구조

• 프로그램이 실행되면 메모리에 다음과 같은 영역들이 할당된다.

  ┌─────────────┐ ← 높은 주소
  │ 스택 (Stack) │ ◀ 함수 호출, 지역 변수
  ├─────────────┤
  │ 힙 (Heap)    │ ◀ 동적 메모리 (new, malloc 등)
  ├─────────────┤
  │ 데이터 영역    │ ◀ 전역 변수, static 변수
  ├─────────────┤
  │ 코드 영역     │ ◀ 실행 명령어 (기계어)
  └─────────────┘ ← 낮은 주소

  2. 프로세스의 메모리 구조

• 각 프로세스는 위 구조 전체를 독립적으로 가지고 있음
• 다른 프로세스와 코드/데이터/스택/힙 모두 분리됨
• 하나의 프로세스가 죽거나 메모리를 잘못 써도 다른 프로세스에 영향 없음

  [프로세스 A]
  ┌ 코드 영역     ┐
  │ 데이터 영역    │
  │ 힙 영역       │
  │ 스택 영역     │
  

[프로세스 B] ┌ 코드 영역 ┐ │ 데이터 영역 │ │ 힙 영역 │ │ 스택 영역 │

**장점**: 안정성 높음
**단점**: 프로세스 간 통신이 느림 (공유 X → IPC 필요)


### 3. 스레드의 메모리 구조
- 스레드는 같은 프로세스 내부에서 실행되는 작업 단위
- 따라서, 코드 / 데이터 / 힙 영역은 공유하고, 스택만 개별로 가짐

[프로세스 A] (2개의 스레드) ┌ 코드 영역 ┐ ← 공유 │ 데이터 영역 │ ← 공유 │ 힙 영역 │ ← 공유 ├───────────────┤ │ 스택 (스레드 1) │ ← 개별 ├───────────────┤ │ 스택 (스레드 2) │ ← 개별 └───────────────┘

``` 장점: 데이터 공유 빠름, 스레드 간 협업에 유리 단점: 한 스레드가 힙/데이터를 잘못 건드리면 전체가 충돌 가능 (동기화 이슈)

이러한 구조 덕분에 스레드는 협업이 빠르지만, 잘못된 접근 시 동기화 문제나 데이터 충돌이 발생할 수 있다.

왜 스택은 공유하지 않을까?

• 스택은 함수 호출, 지역 변수 등을 저장하는 영역
• 스레드마다 콜스택이 다르므로 반드시 분리되어야 함
• 분리되지 않으면 A 스레드 함수가 B 스레드의 변수에 영향을 줄 수 있어 심각한 오류 발생 가능

실제 예시

• 크롬 브라우저

  • 크롬은 탭마다 독립된 프로세스를 실행한다.
  • 탭 내에서는 렌더링, 자바스크립트, 네트워크 등 역할을 하는 스레드들이 함께 동작한다.
    → 탭이 다운되어도 다른 탭에 영향이 없는 이유이다.

• 게임 클라이언트

  • 하나의 프로세스 안에 렌더링 스레드, 사운드 스레드, 네트워크 스레드 등 다수의 스레드가 병렬로 실행된다. → 빠른 반응성과 실시간 처리에 유리하다.

• 웹 서버 (예: Node.js)

  • 단일 프로세스에서 이벤트 루프 기반 스레드 모델을 사용해 I/O 작업을 비동기 처리한다.
  • 고성능 처리를 위해 클러스터링으로 멀티프로세스를 병행하기도 한다.

운영체제는 하드웨어와 소프트웨어 사이의 중간 관리자 역할을 하며, 시스템 자원을 효율적으로 관리한다.

운영체제의 구조

1. 커널(Kernel)

운영체제의 핵심 하드웨어와 직접 소통하며, 메모리, CPU, 파일 시스템, 장치 등을 제어한다.

• 커널 모드에서만 실행되며, 사용자 프로그램은 직접 하드웨어를 접근할 수 없다.
• 대표 예시: Linux Kernel, Windows NT Kernel

2. 시스템 콜(System Call)

사용자 프로그램이 OS 기능을 사용할 수 있도록 제공하는 인터페이스

• 예: read(), write(), fork(), exec(), open()
• 하드웨어 접근은 반드시 시스템 콜을 통해 커널에 요청해야 한다.

프로세스와 스레드

• 운영체제는 각 프로세스를 별도로 관리하고, 스레드 간에는 자원 공유를 허용하기도 한다.

메모리 관리

운영체제는 RAM을 효율적으로 분배하고, 충돌을 방지한다.
프로세스마다 아래와 같은 메모리 구조가 존재한다.

• 코드 영역: 프로그램 실행 코드
• 데이터 영역: 전역 변수, static 변수
• 힙 영역: 동적 메모리 할당 공간
• 스택 영역: 함수 호출, 지역 변수 저장

운영체제는 각 프로세스의 메모리 공간을 분리하여 안정성을 확보합니다.

파일 시스템

운영체제는 디스크 상의 파일을 논리적으로 관리한다.

• 파일 이름, 위치, 크기, 권한 등의 메타데이터 관리
• 디렉토리 구조 생성 및 탐색
• 대표 파일 시스템 포맷: FAT32, NTFS, ext4 등

입출력 장치 관리 (I/O)

• 디스크, 마우스, 키보드, 네트워크 장치 등은 모두 I/O 장치
• 운영체제는 I/O 요청을 받아 장치 드라이버를 통해 처리한다.
• 사용자 프로그램은 시스템 콜을 통해만 접근 가능

서버 운영체제에 리눅스가 많은 이유

1. 비용 효율성

• 오픈소스 : 리눅스는 무료로 사용할 수 있는 오픈소스 운영 체제입니다. 서버를 대량으로 운영하는 기업이나 데이터센터 입장에서, 상용 운영 체제(예: Windows Server) 대신 리눅스를 선택하면 라이선스 비용을 절감할 수 있음
• 유연한 커스터마이징: 필요에 따라 소스 코드를 수정해 최적화할 수 있기 때문에 특정 하드웨어나 애플리케이션에 맞춘 서버 환경 구축이 용이

2. 안정성과 신뢰성

• 대부분의 리눅스 배포판(Ubuntu Server, CentOS, Red Hat 등)은 24/7(항상 가동)을 목표로 설계되었고, 다운타임이 적음
• 커널 패치와 업데이트가 활발히 이루어져 장기적인 안정성이 보장
• 금융, 클라우드 서비스, 인터넷 기업 등 대규모 트래픽을 처리하는 시스템에서 안정성이 중요한데, 리눅스는 이에 적합

3. 보안

• 사용자 권한 체계와 파일 시스템 보안이 강력
• 오픈소스 특성 덕분에 보안 취약점이 빠르게 발견되고 수정
• 서버 관리자가 방화벽, 접근 제어, 암호화와 같은 고급 보안 기능을 자유롭게 설정

4. 유연성과 확장성

• 리눅스는 다양한 서버 환경에 적응가능
• 웹 서버(Apache, Nginx), 데이터베이스 서버(MySQL, PostgreSQL), 파일 서버 등 모든 서버 역할을 수행할 수 있는 범용성.
• 다양한 하드웨어(고성능 서버부터 저성능 IoT 디바이스까지)를 지원하여 확장성이 높음

5. 커뮤니티와 생태계

• 전 세계 개발자와 서버 관리자가 참여해, 문제 해결과 최적화를 돕는 방대한 자료와 문서를 제공
• 리눅스를 기반으로 한 다양한 서버용 배포판(예: CentOS, Ubuntu Server, Debian, Red Hat)이 존재해, 용도에 맞는 선택이 가능

6. 서버 및 클라우드 환경에서의 점유율

• 리눅스는 클라우드 서버와 호환성이 뛰어나며, AWS, Google Cloud, Microsoft Azure 같은 주요 클라우드 서비스도 리눅스를 기반으로 운영
• 서버의 약 96%가 리눅스 기반이며, 이는 기업과 데이터센터에서의 선호도가 높음을 알 수 있음

7. 오픈소스 소프트웨어와의 호환성

• 리눅스는 많은 오픈소스 서버 소프트웨어와 완벽한 호환성을 제공

8. 성능 최적화

• 리눅스는 가벼운 커널 구조와 프로세스 관리 방식을 통해 서버 하드웨어를 최대한 효율적으로 활용
• 메모리 사용량이 적고, CPU 자원을 효율적으로 배분
• 불필요한 서비스와 GUI를 제거해 서버 전용으로 최적화된 환경을 구축 가능

사용자가 실행 파일(예: .exe, .java, .py)을 실행하면, 운영체제는 해당 파일의 위치, 속성, 권한 등을 확인하고 실행 가능한지 판단을 한다.

2. 운영체제가 메모리에 프로그램 로딩

운영체제(OS)는 실행 파일을 RAM(주기억장치)에 올려서 실행할 준비를 한다. 이때 코드, 전역 변수, 실행 환경 등을 메모리에 배치하고, 새로운 프로세스(Process)를 생성한다.

• 각 프로세스는 고유한 PID(프로세스 ID)를 가짐
• 스택, 힙, 코드 영역 등이 메모리에 구성됨

3. CPU가 명령어를 하나씩 실행

메모리에 올라간 명령어들은 CPU가 읽고 실행한다. 이때 CPU는 내부의 레지스터, 연산장치(ALU)를 활용해 계산, 판단, 제어를 수행한다.

• Program Counter는 현재 실행할 명령어 위치를 추적함
• 연산은 ALU에서 수행되고, 중간 결과는 레지스터/메모리에 저장됨

4. 메모리 공간 관리 (스택, 힙)

실행 중인 프로그램은 메모리 내에서 여러 공간을 사용한다.

• 스택(Stack): 함수 호출, 지역 변수 저장
• 힙(Heap): 동적 메모리 할당 (new, malloc 등)

운영체제는 각 프로세스의 메모리를 분리해 충돌을 방지합니다.

5. 입출력 작업은 운영체제가 처리

파일 열기, 마우스 클릭, 키보드 입력, 네트워크 통신 등은 시스템 콜(System Call)을 통해 운영체제가 하드웨어와 직접 소통하며 처리한다.

6. 멀티태스킹과 CPU 스케줄링

컴퓨터는 동시에 여러 프로그램이 실행되는 것처럼 보이지만, 실제로는 운영체제가 CPU 시간을 분할하여 각 프로세스에 할당하고 빠르게 전환(Context Switching)한다.

이 덕분에 사용자 입장에서는 여러 앱이 동시에 작동하는 것처럼 느껴진다.

7. 프로그램 종료와 자원 회수

프로그램이 종료되면 운영체제는 해당 프로세스가 사용하던 메모리, 파일 핸들, 네트워크 연결 등을 정리하고 시스템 자원을 회수한다.

예시: 메모장 실행 시 내부 동작

1. 사용자가 메모장 아이콘을 더블 클릭

2. notepad.exe가 RAM에 로딩되고 프로세스가 생성됨

3. CPU가 명령어를 순차적으로 실행하며 메모장 화면이 나타남

4. 파일 열기 시, OS가 디스크에서 파일을 읽어 메모리에 올림

5. 작업 완료 후 프로그램 종료 → 자원 해제, 프로세스 종료

컴퓨터는 소프트웨어와 하드웨어로 구성되어 있으며, 이 중 하드웨어는 우리가 눈으로 볼 수 있는 물리적인 부품들을 의미합니다. 이 글에서는 컴퓨터 하드웨어의 구조와 각 구성 요소의 역할에 대해 쉽게 설명해보겠습니다.

1. CPU (Central Processing Unit, 중앙처리장치)

CPU는 컴퓨터의 두뇌라고 불리며, 모든 연산과 명령 처리를 담당 사용자나 프로그램이 내리는 명령을 해석하고 실행하는 역할

• 주요 구성
  • 연산장치(ALU): 계산 담당
  • 제어장치(CU): 명령어 순서대로 실행

• 단위: GHz (속도), 코어 수 (병렬 처리 능력)

2. 메인 메모리 (RAM vs ROM)

컴퓨터에서 가장 기본적인 메모리로는 RAM과 ROM이 있다. 이 둘은 모두 메모리지만, 성격과 역할이 다르다.

RAM (Random Access Memory)

RAM: 컴퓨터에서 현재 실행 중인 프로그램이나 데이터를 임시로 저장하는 장치 휘발성이기 때문에 전원을 끄면 저장된 내용은 사라진다.

• 프로그램 실행 중 데이터를 임시 저장
• 속도는 빠르지만 전원을 끄면 모두 사라짐 (휘발성)
• 용량이 크면 한 번에 여러 작업 가능 (예: 8GB, 16GB 등)
• 실행 속도와 멀티태스킹 성능에 큰 영향

ROM (Read Only Memory)

ROM: 이름처럼 데이터를 읽기 전용으로 저장하는 비휘발성 메모리 컴퓨터가 켜질 때 가장 먼저 사용하는 부팅용 펌웨어(BIOS/UEFI)가 저장된 공간

• 전원을 꺼도 데이터가 유지됨 (비휘발성)
• 사용자가 직접 수정할 수 없음 (특수 환경 제외)
• 하드웨어가 기본적으로 필요한 정보(펌웨어, 부트로더 등)를 저장
• 읽기만 가능하며, 내용은 제조 시점에 고정되거나 제한적으로 수정 가능

RAM vs ROM 요약 비교

3. 저장 장치 (HDD / SSD)

운영체제, 애플리케이션, 사용자 데이터 등을 영구적으로 저장하는 장치

• 파일, 앱, OS 등 영구 저장
• HDD: 느리지만 저렴, 기계식
• SSD: 빠르고 조용, 반도체 방식

4. 메인보드 (Motherboard)

모든 하드웨어 부품이 연결되는 중심 회로판 CPU, RAM, 저장 장치, 전원 등 모든 부품들이 이 보드를 통해 서로 통신

• 모든 부품이 꽂히는 중심 회로판
• 전원 공급 및 데이터 전달 통로 역할
• 칩셋, 슬롯, 포트 등 다양한 회로와 단자가 포함

5. GPU (그래픽카드)

GPU는 화면 출력, 3D 렌더링, 영상 처리 등 그래픽 연산을 담당하는 장치 최근에는 인공지능 연산용으로도 사용

• 내장 GPU: CPU나 메인보드에 포함
• 외장 GPU: 별도로 장착, 고성능 게임 및 작업에 유리
• CPU보다 더 많은 연산 코어를 가지고 있음 (병렬 연산에 특화)
• 복잡한 그래픽 연산을 CPU 대신 처리해서 전체 성능을 높여줌

6. 입출력 장치 (I/O Devices)

사용자가 컴퓨터와 상호작용할 수 있도록 돕는 장치

• 입력 장치: 키보드, 마우스, 마이크, 스캐너 등
• 출력 장치: 모니터, 스피커, 프린터 등

데이터베이스에서 대량의 데이터를 빠르게 검색하려면 어떻게 해야 할까? 바로 인덱스(Index)를 사용하는 것이다.

인덱스란?

• 인덱스는 데이터베이스 테이블의 데이터를 빠르게 조회하기 위한 자료구조이다.
• 도서관의 책 색인처럼, 원하는 데이터를 효율적으로 찾을 수 있도록 도와주는 역할을 한다.

예를 들어, 아래와 같은 쿼리를 실행한다고 가정해본다면

SELECT * FROM users WHERE user_id = 123;

• user_id에 인덱스가 없다면 → 모든 데이터를 Full Scan
• user_id에 인덱스가 있다면 → 인덱스를 통해 바로 해당 위치 조회

인덱스의 자료구조

B-트리 인덱스 (B-Tree Index)

B-트리는 정렬된 데이터를 트리 형태로 저장하는 자료구조 대부분의 관계형 데이터베이스(MySQL, PostgreSQL 등)에서 기본 인덱스로 사용됨 검색, 삽입, 삭제 연산을 평균적으로 $O(log n)$에 수행할 수 있다.

구조예시

                  [30]
                /      \
           [10, 20]   [40, 50]
          /   |   \    /   |   \
       [5] [15] [25] [35] [45] [55]

• 루트 노드: [30]
• 내부 노드: [10, 20], [40, 50]
• 리프 노드: [5], [15], ..., [55]
• 모든 리프 노드는 같은 깊이에 있음 → 균형 트리

검색 동작

예: WHERE age = 45 → 루트에서 시작 → 45는 30보다 크므로 오른쪽 → [40, 50] 에서 45는 40보다 크고 50보다 작으므로 중간 자식으로 이동 → 리프 노드 [45] 도달 → 검색 성공

인덱스 생성 예시

-- 단일 인덱스
CREATE INDEX idx_users_userid ON users(user_id);

-- 복합 인덱스
CREATE INDEX idx_users_name_email ON users(name, email);

인덱스의 장점

• 검색 속도 향상: WHERE, JOIN, ORDER BY 절의 성능 향상

• 정렬 최적화: 정렬이 빠르게 처리됨

• 조인 성능 향상: 키 기반 검색 속도 증가

인덱스의 단점

• 쓰기 성능 저하: INSERT/UPDATE/DELETE 시 인덱스도 갱신 필요

• 디스크 공간 추가 사용: 인덱스를 저장할 공간 필요

• 인덱스 남용 주의: 너무 많은 인덱스는 오히려 성능 저하

언제 인덱스를 사용해야 할까?

인덱스 조회 계획 확인

• 인덱스가 실제로 사용되고 있는지 확인하려면 EXPLAIN을 사용

  EXPLAIN SELECT * FROM users WHERE user_id = 123;

인덱스 종류 요약

관계형 데이터베이스(RDBMS)에서 정규화는 데이터의 중복을 제거하고, 데이터 무결성을 유지하기 위해 테이블 구조를 체계적으로 설계하는 기법

2. 정규화의 목적

• 중복 제거: 같은 정보가 여러 곳에 반복 저장되지 않도록
• 이상 현상 방지: 삽입/삭제/수정 시 데이터 불일치 방지
• 무결성 유지: 일관성 있는 데이터 저장
• 재사용성 향상: 여러 테이블을 효율적으로 연결 가능

3. 이상현상이란?

이상현상은 테이블 설계가 잘못됐을 때 발생하는 비정상적인 현상

4. 정규화 단계

4-1. 제1정규형 (1NF) – 원자값(Atomic Value)

• 컬럼에 반복되거나 집합적인 값이 존재하면 안 됨
• 각 필드는 더 이상 나눌 수 없는 단일값만 저장

비정규화 테이블 예시

1NF 적용

4-2. 제2정규형 (2NF) - 부분 함수 종속 제거

• 제1정규화(1NF)를 만족해야 하며,
• 기본키의 일부분에만 종속되는 속성(부분 함수 종속)이 없어야 한다.

즉, 모든 비프라이머리 속성(기본키가 아닌 속성)은 기본키 전체에 대해 완전 함수 종속이어야 함.

비정규화 예시

• 제1정규형까지만 적용된 테이블

• 기본키: (학번, 과목명) → 복합키
• 교수명은 과목명에만 종속됨 → 부분 함수 종속 발생

문제점

• 과목과 교수의 관계는 중복됨 (수학=김교수)
• 과목명이 바뀌거나 교수가 변경되면 다수의 행을 수정해야 함 → 이상 발생 가능

→ 교수명은 과목에만 종속되어 있으므로 과목 테이블로 분리

2NF 적용

• 학생-수강 테이블 (Student_Subject)

4-3. 제3정규형 (3NF) - 이행 함수 종속 제거

• 제2정규화(2NF)를 만족해야 하며
• 이행적 함수 종속(Transitive Dependency)을 제거해야 한다

이행적 함수 종속(Transitive Dependency):

• A → B, B → C가 존재할 때, A → C도 성립하는 관계
• 여기서 C는 A에 직접적으로 종속된 게 아니라, B를 거쳐 종속됨

즉, 기본키가 아닌 다른 컬럼에 종속된 속성이 존재하는 경우!

비정규화 예시

• 제2정규화까지만 적용된 테이블

• 기본키: 학번(StudentID)
• 학과명(DeptName)은 학과코드(DeptCode)에 종속
• 학과코드는 학번에 종속 → 따라서 학과명은 학번에 이행적 종속됨

문제점

• 학과명이 바뀌면 여러 행을 수정해야 함
• 데이터 중복으로 인해 갱신 이상(Anomaly) 발생 가능

3NF 적용

• 학생 테이블 (Student)

5. 정규화 vs 비정규화

언제 정규화를 사용할까?

• 데이터 무결성이 중요할 때
• 데이터 중복 최소화가 필요할 때
• 업데이트, 삭제 이상을 방지하고 싶을 때

언제 비정규화를 사용할까?

• 조회 속도가 중요한 시스템 (예: 분석, 검색 위주)
• 복잡한 조인이 시스템 성능에 영향을 줄 때
• 캐싱이나 요약 데이터가 필요한 경우

정규화는 데이터의 일관성을 보장하고 유지 관리가 용이하다는 장점이 있지만, 때로는 성능상 이유로 비정규화가 필요할 수도 있다.

"설계 초기엔 정규화, 성능 최적화 시 비정규화"가 일반적인 접근

분할 정복(Divide and Conquer)은 복잡한 문제를 작은 부분 문제로 나누어 해결한 뒤, 이를 다시 합쳐 원래 문제의 해답을 얻는 알고리즘 설계 기법이다.

쉽게 말해, "문제를 작게 나누고, 각 문제를 해결한 뒤, 그 결과를 합쳐서 큰 문제를 해결하는 방식"

1. 분할 정복의 동작 과정

분할 정복 알고리즘은 보통 다음 세 단계로 구성된다.

1. 분할(Divide): 큰 문제를 더 작은 부분 문제로 나눈다.
2. 정복(Conquer): 각각의 작은 부분 문제를 재귀적으로 해결한다.
3. 병합(Combine): 작은 문제들의 결과를 합쳐서 원래 문제의 해답을 얻는다.

2. 분할 정복의 특징 및 장점

• 문제를 작은 단위로 나누어 복잡도를 낮추는 데 효과적이다.
• 작은 부분 문제들이 서로 독립적으로 해결 가능하기 때문에 병렬 처리에 유리하다.
• 재귀적 방법을 자주 사용하며, 간결하고 효율적인 코드 작성이 가능하다.

3. 분할 정복을 사용하는 대표적인 알고리즘들

4. 분할 정복의 시간복잡도 분석

분할 정복 알고리즘의 일반적인 시간 복잡도는 다음과 같이 표현된다. $$ T(n) = aT(n/b) + O(n^d) $$

• $a$ : 재귀 호출 횟수
• $n/b$ : 문제의 크기가 얼마나 작아지는지
• $O(n^d)$ : 분할 및 병합에 걸리는 시간

병합 정렬의 경우

• $T(n) = 2T(n/2) + O(n) = O(n log n)$

5. 분할 정복 예시

5-1 거듭제곱(Fast Power)

거듭제곱은 단순히 a^n을 반복 곱셈으로 구하면 $O(n)$의 시간이 걸린다.
하지만 분할 정복을 사용하면 $O(log n)$ 시간에 빠르게 계산할 수 있다.

아이디어

• 짝수 지수 $a^n = (a^{n/2})^2$
• 홀수 지수 $a^n = a \times (a^{\lfloor n/2 \rfloor})^2$

예시 코드

def fast_power(a, n):
    if n == 0:
        return 1
    half = fast_power(a, n // 2)
    if n % 2 == 0:
        return half * half
    else:
        return a * half * half

# 예시: 2^10 = 1024
print(fast_power(2, 10))  # 출력: 1024

시간 복잡도

• $O(log n)$ → 재귀 호출이 n을 절반씩 줄이기 때문에 매우 빠름

5-2 모듈러(modular) 거듭제곱

큰 수를 계산할 때는 중간에 모듈러 연산을 적용해 오버플로우를 방지하고 효율적으로 계산할 수 있다.

아이디어

• 짝수 지수 $a^n \bmod m = ( a^{n/2} \bmod m )^2 \bmod m$
• 홀수 지수 $a^n \bmod m = a \times ( a^{\lfloor n/2 \rfloor} \bmod m )^2 \bmod m$

예시 코드

def fast_power_mod(a, n, mod):
    if n == 0:
        return 1
    half = fast_power_mod(a, n // 2, mod)
    result = (half * half) % mod
    if n % 2 == 1:
        result = (result * a) % mod
    return result

# 예시: 2^10 % 1000 = 24
print(fast_power_mod(2, 10, 1000))  # 출력: 24

파이썬 내장 함수와 비교

import time

# 비교용 큰 수
a = 987654321
n = 10**9
mod = 1_000_000_007

# 사용자 정의 함수 시간 측정
start = time.time()
custom_result = fast_power_mod(a, n, mod)
end = time.time()
print(f"Custom fast_power_mod result: {custom_result}")
print(f"Custom function time: {end - start:.6f} seconds")

# 내장 함수 pow 시간 측정
start = time.time()
builtin_result = pow(a, n, mod)
end = time.time()
print(f"Built-in pow result: {builtin_result}")
print(f"Built-in pow time: {end - start:.6f} seconds")

# 결과
Custom fast_power_mod result: 69424128
Custom function time: 0.000118 seconds
Built-in pow result: 69424128
Built-in pow time: 0.000005 seconds

• 내장 함수 pow(a, b, mod)는 C로 작성되어 있고 파이썬 인터프리터 수준에서 최적화되어 있기 때문에 매우 빠르다.

• 반면, fast_power_mod는 Python으로 작성된 재귀 함수이므로 약간의 오버헤드가 있지만, 그럼에도 불구하고 충분히 빠른 속도를 보여준다.

정렬 알고리즘은 데이터를 특정 기준에 따라 순서를 맞추어 나열하는 알고리즘이다. 주로 숫자나 문자를 오름차순 또는 내림차순으로 정렬할 때 사용 됨 자료구조와 알고리즘 분야에서 기초적이면서도 매우 중요한 개념

1. 버블 정렬(Bubble Sort)

가장 간단한 정렬 방법 중 하나로, 인접한 두 원소를 비교하며 큰 값(또는 작은 값)을 계속 뒤로 보내면서 정렬

• 시간 복잡도: 최선 $O(N)$, 평균 및 최악 $O(N^2)$
• 공간 복잡도: $O(1)$
• 특징: 이해하기 쉽지만 성능이 좋지 않아 실제로는 거의 사용되지 않음

동작 과정

• 인접한 원소 두 개씩 비교하여 순서를 바꿈
• 배열 끝까지 반복하면 가장 큰(또는 작은) 원소가 맨 뒤로 이동
• 위 과정을 반복해 정렬을 완료

  def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        swapped = False
        for j in range(n - 1 - i):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
                swapped = True
        if not swapped:
            break
    return arr
  

print(bubble_sort([4, 3, 5, 1, 2]))

---

## 2. 선택 정렬(Selection Sort)

매번 가장 작은(또는 가장 큰) 원소를 찾아 맨 앞으로 보내는 방식으로 정렬

- **시간 복잡도**: 최선, 평균, 최악 모두 **$O(N^2)$**
- **공간 복잡도**: **$O(1)$**
- **특징**: 간단하지만 비효율적

### 동작 과정
- 전체 배열에서 가장 작은 원소를 찾아 첫 번째 위치와 교환
- 두 번째 위치부터 이 과정을 반복하여 전체를 정렬
```python
def selection_sort(arr):
    n = len(arr)
    for i in range(n):
        min_idx = i
        for j in range(i + 1, n):
            if arr[min_idx] > arr[j]:
                min_idx = j
        arr[i], arr[min_idx] = arr[min_idx], arr[i]
    return arr

print(selection_sort([4, 3, 5, 1, 2]))

3. 삽입 정렬(Insertion Sort)

배열의 각 원소를 이미 정렬된 부분에 삽입하는 방식

• 시간 복잡도: 최선 $O(N)$, 평균 및 최악 $O(N^2)$
• 공간 복잡도: $O(1)$
• 특징: 데이터가 어느 정도 정렬되어 있을 때 매우 효율적

동작 과정

• 첫 번째 원소를 정렬된 부분으로 간주
• 두 번째 원소부터 정렬된 부분 내 적절한 위치를 찾아 삽입
• 전체 원소를 대상으로 반복

  def insertion_sort(arr):
    n = len(arr)
    for i in range(1, n):
        key = arr[i]
        j = i - 1
        while j >= 0 and arr[j] > key:
            arr[j + 1] = arr[j]
            j -= 1
        arr[j + 1] = key
    return arr
  

print(insertion_sort([4, 3, 5, 1, 2]))

---

## 4. 병합 정렬(Merge Sort)

배열을 절반씩 나누어 각각 정렬한 후 병합하는 방식으로, 분할 정복(Divide and Conquer)을 사용합니다.

- **시간 복잡도**: 최선, 평균, 최악 모두 **$O(N log N)$**
- **공간 복잡도**: **$O(N)$**
- **특징**: 안정적이며 성능이 일관적

### 동작 과정
- 배열을 절반씩 나누어 최소 단위로 쪼갬
- 각 단위를 정렬하며 병합하여 다시 큰 배열로 합침
- 전체 배열이 정렬될 때까지 반복
```python
def merge_sort(arr):
    if len(arr) <= 1:
        return arr
    mid = len(arr) // 2
    left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])
    return merge(left, right)

def merge(left, right):
    result = []
    i = j = 0
    while i < len(left) and j < len(right):
        if left[i] <= right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1
    result.extend(left[i:])
    result.extend(right[j:])
    return result

print(merge_sort([4, 3, 5, 1, 2]))

5. 퀵 정렬(Quick Sort)

기준점(pivot)을 정해 기준보다 작은 값과 큰 값을 나누어 정렬하는 방법

• 시간 복잡도: 최선, 평균 $O(N log N)$, 최악 $O(N^2)$
• 공간 복잡도: $O(log N)$
• 특징: 일반적으로 매우 빠르지만 피벗 선택에 따라 성능이 달라진다.

동작 과정

• 배열에서 피벗을 선정(첫 번째, 마지막, 중앙값 등)
• 피벗 기준으로 작은 값은 왼쪽, 큰 값은 오른쪽에 배치
• 나뉜 부분에 대해 반복하여 정렬을 완료

  def quick_sort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quick_sort(left) + middle + quick_sort(right)
  

print(quick_sort([4, 3, 5, 1, 2]))

---

## 6. 힙 정렬(Heap Sort)

힙 자료구조를 이용하여 정렬하는 알고리즘

- **시간 복잡도**: 최선, 평균, 최악 모두 **$O(N log N)$**
- **공간 복잡도**: **$O(1)$**
- **특징**: 성능이 안정적이며 추가 메모리 공간을 거의 사용하지 않음

### 동작 과정
- 배열을 힙(heap) 형태로 구성(heapify)
- 힙에서 루트 원소(최대 또는 최소)를 하나씩 꺼내어 배열 뒤에서부터 채움
- 힙을 재구성하며 반복적으로 진행
```python
import heapq

def heap_sort(arr):
    heapq.heapify(arr)
    return [heapq.heappop(arr) for _ in range(len(arr))]

print(heap_sort([4, 3, 5, 1, 2]))

# 힙 정렬(Heap Sort) 내부 동작 코드 예시

def heapify(arr, n, i):
    largest = i       # 현재 노드를 가장 큰 값으로 가정
    left = 2 * i + 1  # 왼쪽 자식 인덱스
    right = 2 * i + 2 # 오른쪽 자식 인덱스

    # 왼쪽 자식이 루트보다 크면 업데이트
    if left < n and arr[left] > arr[largest]:
        largest = left

    # 오른쪽 자식이 현재까지의 최대값보다 크면 업데이트
    if right < n and arr[right] > arr[largest]:
        largest = right

    # 루트가 최대가 아니라면 교환 후 하위 트리 heapify
    if largest != i:
        arr[i], arr[largest] = arr[largest], arr[i]
        print(f"heapify: swapped {arr[i]} and {arr[largest]}, array: {arr}")
        heapify(arr, n, largest)

def heap_sort(arr):
    n = len(arr)

    # 최대 힙(max heap) 만들기
    for i in range(n // 2 - 1, -1, -1):
        heapify(arr, n, i)
        print(f"build max-heap step: {arr}")

    print(f"Max heap constructed: {arr}")

    # 힙에서 요소를 하나씩 추출하며 정렬
    for i in range(n - 1, 0, -1):
        # 현재 루트(최대값)와 마지막 원소 교환
        arr[0], arr[i] = arr[i], arr[0]
        print(f"Swap root with index {i}: {arr}")

        # 힙 크기를 줄이고 다시 heapify
        heapify(arr, i, 0)
        print(f"Heap after removing max element: {arr}")

    return arr

# 테스트 코드
arr = [4, 3, 5, 1, 2]
sorted_arr = heap_sort(arr)
print(f"Sorted array: {sorted_arr}")

정렬 알고리즘 특징 비교

정리

정렬 알고리즘은 각각의 상황과 데이터 특성에 따라 선택하는 것이 중요하다.

• 데이터가 거의 정렬되어 있으면 삽입 정렬이 효율적
• 일반적인 경우 빠른 속도를 원하면 퀵 정렬을 고려
• 안정적이고 일관된 성능이 필요하면 병합 정렬이나 힙 정렬이 적합

자주 반복되는 작업을 하나의 코드 블록으로 정의해 재사용할 수 있게 해주는 메서드(method)는 가독성과 유지보수를 높이는 핵심 도구이다.

메서드가 필요한 이유

int a = 1, b = 2;
System.out.println(a + "+" + b + " 연산 수행");
int sum1 = a + b;

int x = 10, y = 20;
System.out.println(x + "+" + y + " 연산 수행");
int sum2 = x + y;

• 위처럼 같은 연산을 반복해야 할 때, 코드 중복이 많고 유지보수가 어렵다

메서드의 기본 구조

public static int add(int a, int b) {
    int sum = a + b;
    return sum;
}

• public static: 제어자
• int: 반환 타입 (리턴값의 타입)
• add: 메서드 이름 (호출 시 사용)
• (int a, int b): 매개변수(파라미터) – 메서드에 전달하는 값
• { ... }: 메서드 본문 – 실제 동작을 수행하는 코드 블록

사용 예시

int sum1 = add(5, 10);  // 결과: 15
int sum2 = add(15, 20); // 결과: 35

• add(5, 10) 호출 → 메서드 내부 실행 → 결과 15 반환 → 변수에 저장
• 메서드는 호출하는 쪽에서는 내부 동작을 몰라도 사용 가능 (블랙박스)

메서드와 형변환 (형이 다른 값을 메서드에 넘길 때)

자바에서는 메서드를 호출할 때, 전달하는 값(인수)의 타입이 메서드가 정의한 매개변수 타입과 다를 수 있음 이때 자바는 형변환(casting)을 자동 또는 명시적으로 처리해야 한다.

자동 형변환 (묵시적 형변환)

작은 타입 → 큰 타입으로 넘길 때는 자바가 자동으로 형을 맞춰준다.

public static void printDouble(double value) {
    System.out.println("실수: " + value);
}

int i = 10;
printDouble(i);  // int → double 자동 형변환

• int는 double보다 작은 타입
• 자바가 자동으로 10을 10.0으로 변환해서 넘겨줌

명시적 형변환 (강제 형변환)

큰 타입 → 작은 타입으로 넘기면 컴파일 에러 발생! 이 경우 개발자가 명시적으로 형변환을 해줘야 한다.

public static void printInt(int value) {
    System.out.println("정수: " + value);
}

double d = 3.14;
printInt((int) d); // 명시적 형변환 필요 → 결과: 3

• 실수형 3.14는 정수형보다 크므로 자동 변환 불가능
• (int)를 붙여서 강제로 정수로 변환해야 함
• 소수점은 잘려서 정수 부분만 남음

printInt(3.14); // ❌ 컴파일 오류!

• 손실 가능성이 있으므로 자동 변환을 허용하지 않음

메서드 오버로딩 (Overloading)

같은 이름의 메서드라도, 매개변수의 타입이나 개수가 다르면 여러 개 만들 수 있다. 이를 오버로딩(overloading)이라고 한다.

오버로딩 예제

• 이름은 모두 add지만, 매개변수 개수 또는 매개변수 타입이 다르기 때문에 각각 별개의 메서드로 인식됨

  public static int add(int a, int b) {
    return a + b;
  }
  

public static double add(double a, double b) { return a + b; }

public static int add(int a, int b, int c) { return a + b + c; }

System.out.println(add(1, 2)); // int 버전 호출 System.out.println(add(1.0, 2.0)); // double 버전 호출 System.out.println(add(1, 2, 3)); // 파라미터 3개짜리 버전 호출

### ⚠️ 주의: 반환값만 다르면 오버로딩이 안 된다!
```java
public static int test() {
    return 1;
}

// 아래 메서드는 에러 발생!
public static double test() {
    return 1.0;
}

• 컴파일러는 메서드 이름과 매개변수 시그니처만 보고 구분
• 반환값은 오버로딩 판별 기준이 아니기 때문에 위 코드는 중복 정의 오류가 발생

오버로딩이 왜 필요할까?

• 같은 동작이지만 입력 방식이 다를 때 print(String) vs print(int)처럼 다양한 타입을 처리 가능

• 확장성 향상 같은 이름으로 처리 가능하므로 메서드 이름을 외우기 쉬움

• 코드 가독성 증가 의미 있는 메서드 이름을 일관되게 사용할 수 있음

많은 양의 데이터를 효율적으로 다루기 위해 배열(Array)을 사용

예를 들어 학생 5명의 점수를 관리한다고 할 때, 배열이 없다면 이렇게 작성해야 한다.

int student1 = 90;
int student2 = 80;
int student3 = 70;
int student4 = 60;
int student5 = 50;

• 학생 수가 많아질수록 코드가 선언 + 출력 모두 비효율적
• 비슷한 변수 이름 반복, 반복문 적용 불가 → 유지보수 어려움

배열의 선언과 생성

int[] students;             // 배열 변수 선언
students = new int[5];      // 배열 생성

• int[] → int형 배열을 의미
• new int[5] → int 5개짜리 배열 생성
• 배열 생성 시 자바가 자동으로 초기화해준다.
  • 숫자는 0, boolean은 false, String(문자열)은 null로 초기화 된다.

배열 참조의 개념

배열은 참조형(reference type)이다. 즉, 변수는 배열이 저장된 메모리 주소(참조값)를 가지고 있다.

int[] students = new int[5]; //1. 배열 생성
int[] students = x001; //2. new int[5]의 결과로 x001 참조값 반환
students = x001 //3. 최종 결과

→ x001은 배열의 주소이고, 이를 통해 배열에 접근한다.

• 실제 배열의 참조값을 출력하면 다음과 같이 나온다.

  System.out.println(students);
  //출력 결과: `[I@16f65612` (int형 배열의 참조값)

  [I@4617c264 @앞의 [I는 int형 배열을 뜻한다. @뒤에 16진수는 참조값을 뜻한다.

인덱스

• 배열은 변수와 사용법이 비슷한데, 차이점이 있다면 다음과 같이 []사이에 숫자 번호를 넣어주면 된다.
• 배열의 위치를 나타내는 숫자를 인덱스(index)라 한다.

//변수 값 대입
students[0] = 90;
students[1] = 80;
//변수 값 사용
System.out.println("학생1 점수: " + students[0]);
System.out.println("학생2 점수: " + students[1]);

배열은 0부터 시작한다

• new int[5]와 같이 5개의 요소를 가지는 int형 배열을 만들었다면 인덱스는 0,1,2,3,4가 존재한다.
• 여기서 주의해야 할 점이 있는데 인덱스는 0부터 시작한다는 것이다. 배열의 요소를 5개로 생성했지만, 인덱스는 0부터 시작한다.
• 따라서 사용 가능한 인덱스의 범위는 0 ~ (n-1)이 된다. 그래서 students[4]가 배열의 마지막 요소이 다.
• 만약 students[5]와 같이 접근 가능한 배열의 인덱스 범위를 넘어가면 오류가 발생한다.

배열 초기화

• 앞서 배열을 생성하면 자바가 자동으로 초기화해준다고 소개를 했다.
• 배열 생성 후 값을 대입하려면 아래와 같이 해야한다. 이 경우 코드가 늘어나는 단점이 생긴다.

  int[] students;             // 배열 변수 선언
  students = new int[5];      // 배열 생성
  // 초기화된 배열: {0, 0, 0, 0, 0}
  

// 배열에 값 대입 students[0] = 90; students[1] = 80; students[2] = 70; students[3] = 60; students[4] = 50;

- 생성과 동시에 값을 대입해보자
```java
int[] student; // 배열 선언
students = new int[]{90, 80, 70, 60, 50}; // 배열 생성과 초기화

• 선언과 동시에 생성 및 초기화도 가능

  int[] students = new int[]{90, 80, 70, 60, 50};
  // 또는
  int[] students = {90, 80, 70, 60, 50};

2차원 배열

2차원 배열은 행(row)과 열(column)로 구성된 배열

• 2차원 배열 선언과 생성

  int[][] arr = new int[2][3];
  arr[0][0] = 1;  // 1행 1열

• 2차원 배열 초기화

  int[][] arr = {
    {1,2,3},
    {4,5,6}
  }; //행2, 열3

• 2차원 배열 출력

  for (int row = 0; row < arr.length; row++) {
    for (int column = 0; column < arr[row].length; column++) {
        System.out.print(arr[row][column] + " ");
    }
    System.out.println(); //한 행이 끝나면 라인을 변경
  }

Enhanced For Loop

배열 요소를 처음부터 끝까지 순회할 때 사용 각각의 요소를 탐색한다는 의미로 for-each문이라고도 많이 부른다.

향상된 for문 정의

for (변수 : 배열 또는 컬렉션) {
  // 배열 또는 컬렉션의 요소를 순회하면서 수행할 작업
}

예제

// 일반 for문
for(int i = 0; i < numbers.length; ++i) {
    int number = numbers[i];
    System.out.println(number);
}

// Enhanced For 문, for-each문
for (int number : numbers) {
    System.out.println(number);
}

• 인덱스가 필요 없는 경우에 코드가 훨씬 깔끔해짐
• 인덱스를 활용해야 할 경우에는 일반 for문을 사용해야 함

자바에서 사용자로부터 키보드 입력을 받을 때는 Scanner 클래스를 가장 많이 사용한다. System.in을 활용해서 다양한 타입의 값을 간단하게 입력받을 수 있다.

Scanner 사용 기본 구조

Scanner scanner = new Scanner(System.in);

• System.in : 표준 입력 (키보드)
• new Scanner(...) : 입력 도구 생성

Scanner 주요 메서드 정리

• 입력예제

  Scanner scanner = new Scanner(System.in);
  System.out.print("이름을 입력하세요: ");
  String name = scanner.nextLine();
  System.out.println("안녕하세요, " + name + "님!");

Scanner 사용 시 주의점

• nextInt() 등 숫자 입력 후 nextLine()을 바로 쓰면 버퍼 문제로 줄바꿈이 넘어감

int age = scanner.nextInt();
String name = scanner.nextLine(); // ← 여기서 빈 문자열이 들어올 수 있음

→ 해결법: nextLine()을 한 번 더 써서 줄바꿈 제거

• Scanner는 보통 프로그램 끝나기 전에 닫지 않아도 큰 문제는 없지만, 자바에서는 리소스 정리를 위해 scanner.close();를 호출하는 습관이 좋음

예시

Scanner scanner = new Scanner(System.in);

System.out.print("나이를 입력하세요: ");
int age = scanner.nextInt();  // 여기서 숫자 입력

System.out.print("이름을 입력하세요: ");
String name = scanner.nextLine();  // 이름 입력?
System.out.println("입력된 이름: " + name);

실행

• 입력

  나이를 입력하세요: 20
  이름을 입력하세요: 

• 결과

  입력된 이름: 

  사용자 입장에서는 분명 숫자 20을 입력하고 엔터를 쳤는데, 다음 nextLine()에서 입력을 건너뛰고 바로 빈 문자열("")이 들어가 버린다.

왜 이런 일이 발생할까?

• nextInt()는 숫자만 읽고, 사용자가 누른 엔터(줄바꿈 문자 \n)는 버퍼에 남겨둔다.
• 이후 nextLine()이 호출되면, 그 남아 있던 \n만 읽고 끝난다.
• 결과적으로 입력 없이 넘어간 것처럼 보이는 것이다.

해결 방법

• 숫자 입력 후 버퍼를 비워주는 nextLine()을 한 번 더 호출하면 된다.

  Scanner scanner = new Scanner(System.in);
  

System.out.print("나이를 입력하세요: "); int age = scanner.nextInt(); scanner.nextLine(); // ★ 여기서 엔터 제거!

System.out.print("이름을 입력하세요: "); String name = scanner.nextLine();

System.out.println("입력된 이름: " + name);

```

정수나 실수 입력 후 문자열 입력이 바로 이어진다면, 반드시 nextLine()으로 버퍼를 비워줘야 한다!

자바에서 변수는 선언된 범위(스코프) 안에서만 유효하며, 서로 다른 타입 간 대입에는 형변환이 필요하다. 이번 글에서는 이 두 개념을 정리한다.

1. 스코프 (Scope)

1-1. 지역 변수의 생존 범위

• 변수는 선언된 {} 블록 안에서만 유효하다. 해당 블록을 벗어나면 변수는 제거되고 접근할 수 없다.

public static void main(String[] args) {
    int m = 10; // main 전체에서 유효

    if (true) {
        int x = 20; // if 블록 내부에서만 유효
        System.out.println(m); // 가능
        System.out.println(x); // 가능
    }

    // System.out.println(x); // 오류: x는 스코프 밖
    System.out.println(m); // 가능
}

1-2. for 문과 스코프

• for문 안에서 선언한 변수는 해당 for 블록 안에서만 사용 가능하다.

  for (int i = 0; i < 3; i++) {
    System.out.println(i); // 가능
  }
  // System.out.println(i); // 오류: i는 for문 밖

왜 스코프가 필요할까?

• 메모리 낭비 줄임
• 코드 가독성 향상
• 유지보수에 유리

변수는 꼭 필요한 범위 내에서만 사용하는 것이 좋다.

• ❌ 잘못된 예

  int temp = 0;
  

if (m > 0) { temp = m * 2; }

- ✅ 좋은 예
```java
if (m > 0) {
    int temp = m * 2;
}

2. 형변환 (Casting)

2-1. 묵시적(자동) 형변환

• 작은 타입 → 큰 타입으로 변환은 자동으로 처리된다.

  int intValue = 10;
  long longValue = intValue;
  double doubleValue = intValue;

• int → long → double 은 값의 손실이 없기 때문에 자동으로 변환된다.
• 이처럼 묵시적 형변환은 컴파일 시점에 처리되며, .class 파일에는 해당 형변환 정보가 명확하게 기록된다.

즉, 자바 컴파일러가 소스 코드를 바이트코드로 변환할 때 형변환을 JVM이 인식할 수 있도록 명확하게 삽입한다.

2-2. 명시적(강제) 형변환

• 큰 타입 → 작은 타입으로 변환하려면 명시적으로 변환해야 한다.

double d = 1.5;
int i = (int) d;  // 소수점 버려짐 → i = 1

형변환과 오버플로우

형변환을 할 때 만약 작은 숫자가 표현할 수 있는 범위를 넘어서면 어떻게 될까?

long big = 2147483648L;  // int 최대값 초과
int small = (int) big;

System.out.println(small);  // 출력: -2147483648

• 2147483648은 int 범위를 넘는 값 → 형변환 시 비트 앞쪽(부호비트 포함)이 잘려 나감
• 그 결과 int의 최소값(-2,147,483,648) 이 된다

왜 이런 일이 생길까?

• 컴퓨터는 메모리 공간이 고정되어 있으므로, 큰 타입에서 작은 타입으로 변환할 경우 비트 수가 줄어들면서 앞쪽 비트들이 손실된다.
  이는 2의 보수 표현 방식에 의해 음수로 해석될 수 있다.

오버플로우가 발생해도 컴파일 에러는 없다

• 형변환 자체는 문제가 없기 때문에 컴파일러는 에러를 내지 않는다.
  하지만 결과는 예기치 않게 나올 수 있으므로, 반드시 값을 확인하거나 조건을 체크해야 한다.

오버플로우는 눈에 보이지 않고, 경고 없이 발생하기 때문에 항상 주의해야 한다!

3. 계산 시 형변환

• 계산 과정에서도 자동 형변환이 발생할 수 있다.
• 같은 타입끼리 계산 → 결과도 같은 타입
• 다른 타입끼리 계산 → 큰 타입으로 자동 형변환

int div1 = 3 / 2;
System.out.println("div1 = " + div1); //1

double div2 = 3 / 2;
System.out.println("div2 = " + div2); //1.0

double div3 = 3.0 / 2;
System.out.println("div3 = " + div3); //1.5

double div4 = (double) 3 / 2;
System.out.println("div4 = " + div4); //1.5

int a = 3;
int b = 2;
double result = (double) a / b;
System.out.println("result = " + result); //1.5

작은 컵에서 큰 컵은 OK, 큰 컵에서 작은 컵은 흘러넘칠 수 있다!

반복문은 특정 코드를 여러 번 반복 실행하고 싶을 때 사용한다.

1. while 문

• 조건이 참인 동안 반복 실행한다. 조건식이 false가 되면 반복이 종료된다.

기본구조

while (조건식) {
    // 반복할 코드
}

• 예제

  int count = 0;
  while (count < 3) {
    count++;
    System.out.println("현재 숫자는: " + count);
  }

2. do-while문

• 조건과 상관없이 최소 1회는 실행된다. 조건이 거짓이라도 코드 블럭은 최소 한 번은 실행됨

기본구조

do {
    // 반복할 코드
} while (조건식);

• 예제

  int i = 10;
  do {
    System.out.println("현재 숫자는: " + i);
    i++;
  } while (i < 3);

3. for 문

• 초기식, 조건식, 증감식을 한 줄에 모아 작성할 수 있어 가독성이 좋다.

  기본구조

  for (초기식; 조건식; 증감식) {
    // 반복할 코드
  }

• 예제

  for (int i = 1; i <= 3; i++) {
    System.out.println("i = " + i);
  }

4. break와 continue

break: 반복문을 즉시 종료 continue: 현재 반복을 건너뛰고 다음 반복으로 진행

• break 예제

  int sum = 0;
  int i = 1;
  

while (true) { sum += i; if (sum > 10) { break; } i++; } // 출력: 1 2 4 5

- `continue` 예제
```java
for (int i = 1; i <= 5; i++) {
    if (i == 3) continue;
    System.out.println(i);
}

5. 중첩 반복문

• 반복문 안에 또 다른 반복문을 넣을 수 있다.

  for (int i = 1; i <= 9; i++) {
    for (int j = 1; j <= 9; j++) {
        System.out.println(i + " * " + j + " = " + (i * j));
    }
  }
  

```

6. for vs while 비교

정해진 횟수 반복 → for문 조건 만족할 때까지 반복 → while문

조건문은 특정 조건에 따라 실행 흐름을 제어할 수 있게 해준다.

1. if문

기본 구조

if (조건) {
    // 조건이 참일 때 실행
} else if (다른 조건) {
    // 위 조건이 거짓이고, 이 조건이 참일 때 실행
} else {
    // 모든 조건이 거짓일 때 실행
}

• 예제

  int age = 20;
  

if (age >= 18) { System.out.println("성인입니다."); } else { System.out.println("미성년자입니다."); }

- `else if`를 활용한 다중 조건 분기
```java
int age = 14;

if (age <= 7) {
    System.out.println("미취학");
} else if (age <= 13) {
    System.out.println("초등학생");
} else if (age <= 16) {
    System.out.println("중학생");
} else if (age <= 19) {
    System.out.println("고등학생");
} else {
    System.out.println("성인");
}

2. switch 문

• switch는 특정 값에 따라 코드를 분기할 때 사용한다.

  int grade = 2;
  int coupon;
  

switch (grade) { case 1: coupon = 1000; break; case 2: coupon = 2000; break; case 3: coupon = 3000; break; default: coupon = 500; }

System.out.println("발급받은 쿠폰 " + coupon);

- Java 14 이후 새로운 `switch`
  - `->` 화살표 문법
  - 값을 반환할 수 있음
  - `break` 생략
```java
int grade = 2;

int coupon = switch (grade) {
    case 1 -> 1000;
    case 2 -> 2000;
    case 3 -> 3000;
    default -> 500;
};

3. 삼항 연산자

기본구조

(조건) ? 참_값 : 거짓_값

• 단순한 분기를 표현할 때 if보다 코드가 짧고 간결함

  int age = 18;
  String status = (age >= 18) ? "성인" : "미성년자";
  System.out.println(status);

조건문 종류 요약표

비트 연산자는 정수를 2진수 비트 단위로 직접 조작할 수 있게 해주는 연산자다. 평소에는 자주 쓰이지 않지만, 알고리즘 문제, 성능 최적화, 비트 마스킹 등에 매우 유용하다.

주요 비트 연산자

비트 연산 예제

int a = 5; // 00000101
int b = 3; // 00000011

System.out.println(a & b);  // 1  (00000001)
System.out.println(a | b);  // 7  (00000111)
System.out.println(a ^ b);  // 6  (00000110)
System.out.println(~a);     // -6 (11111010) 2의 보수

시프트 연산자 예제

int n = 8; // 00001000

System.out.println(n << 1); // 16 (00010000) → 왼쪽 시프트: *2
System.out.println(n >> 1); // 4  (00000100) → 오른쪽 시프트: /2

활용 예시

• 짝수 / 홀수 판별

  int x = 7;
  

if ((x & 1) == 1) { System.out.println("홀수"); } else { System.out.println("짝수"); }

- 값을 2배 또는 반으로 만들기
```java
int x = 4;

System.out.println(x << 1); // 8 (곱하기 2)
System.out.println(x >> 1); // 2 (나누기 2)

• 비트 마스크 예시 (권한 체크)

  int READ = 1;      // 0001
  int WRITE = 2;     // 0010
  int EXECUTE = 4;   // 0100
  

int permission = READ | WRITE; // 0011

// 권한 확인 boolean canWrite = (permission & WRITE) != 0; System.out.println(canWrite); // true

---

### '`>>`' vs '`>>>`' 차이점


| 연산자 | 이름               | 설명                                  |
|--------|--------------------|---------------------------------------|
| `>>`   | 산술 시프트         | 부호 비트 유지하며 오른쪽 이동 (음수 유지) |
| `>>>`  | 논리 시프트         | **부호 무시**, 비어있는 자리를 0으로 채움 |

#### '`>>>`' 예제

```java
int a = -8; // 11111111 11111111 11111111 11111000 (32bit)

System.out.println(a >> 2);   // -2
System.out.println(a >>> 2);  // 1073741822

• a >> 2: 산술 시프트 → 부호 유지 → 여전히 음수
• a >>> 2: 부호 무시, 왼쪽에 0을 채움 → 매우 큰 양수로 나옴
• >>>는 부호 없는 시프트를 하기 때문에, 음수를 양수로 바꿀 수도 있다.

Java에서 문자열(String)을 비교할 때 흔히 실수하는 부분 중 하나는 == 연산자를 사용하는 것이다. 하지만 ==은 문자열을 비교할 때 내용이 아닌 주소(참조값) 를 비교하므로 정확한 비교가 되지 않는다.

'==' vs '.equals()' 차이

예제 1: 리터럴 비교 (같은 주소)

• 문자열 리터럴은 String Pool에 저장되므로 동일한 "hello"를 참조함.

  String a = "hello";
  String b = "hello";
  

System.out.println(a == b); // true (같은 리터럴을 참조) System.out.println(a.equals(b)); // true

---

### 예제 2: new 키워드 사용 (다른 주소)
- `new String()`은 새로운 객체를 생성하므로 같은 `"hello"`라도 주소가 다르다.

```java
String a = new String("hello");
String b = new String("hello");

System.out.println(a == b);       // false (주소 다름)
System.out.println(a.equals(b));  // true (내용 같음)

⚠️ 반드시 .equals() 사용해야 하는 이유

• ==은 주소 비교 → 값이 같아도 다른 객체면 false
• .equals()는 값 비교 → 실제 문자열이 같으면 true

  String a = "abc";
  String b = "abc";
  System.out.println(a == b);         // true
  System.out.println(a.equals(b));    // true
  

String c = new String("abc"); System.out.println(a == c); // false System.out.println(a.equals(c)); // true

---

### 널(null) 안전한 비교 방법
- `.equals()`를 사용할 때는 NPE(NullPointerException) 에 주의해야 한다.
- 문자열이 `null`일 가능성이 있으면 `"문자열".equals(변수)` 형태로 비교

```java
String str = null;

// 안전한 방법
"hello".equals(str); // false (null이어도 안전)

// 위험한 방법
str.equals("hello"); // ❌ NullPointerException 발생 가능