1. 코루틴의 기반: suspend fun의 마법

코루틴은 스레드보다 훨씬 가벼운 비동기 작업 단위입니다. 이 코루틴의 능력을 가능하게 하는 것이 바로 suspend 키워드입니다.

suspend의 핵심 원리

1. 표식(Marker): suspend는 이 함수가 실행을 잠시 멈췄다가(Suspend) 나중에 다시 시작할 수 있다(Resume)는 것을 컴파일러에게 알리는 표식입니다.
2. 컴파일러 변환: suspend fun이 호출되면, Kotlin 컴파일러는 이를 Continuation-Passing Style (CPS)이라는 복잡한 콜백 로직으로 변환합니다. 이 변환 덕분에 우리는 비동기 코드를 마치 순차적인 동기 코드처럼 작성할 수 있습니다.
3. 코루틴 스코프: suspend 함수는 코루틴(Scope)이라는 특별한 환경 내에서만 호출될 수 있습니다. 코루틴이 일시 중지된 지점의 상태를 저장하고 있다가 비동기 작업이 완료되면 재개(Resume)를 명령합니다.

// 예시: suspend를 사용하여 비동기 코드를 동기처럼 작성
suspend fun fetchData() {
    // 1. 네트워크 호출: 코루틴은 여기서 멈춥니다(Suspend). 메인 스레드는 막히지 않습니다.
    val user = apiService.getUserData() 

    // 2. 데이터가 도착하면 코루틴이 재개(Resume)되어 다음 줄이 실행됩니다.
    println("사용자 이름: ${user.name}")
}

2. Flow: 비동기 데이터 스트림

Flow는 코루틴 환경에서 시간이 지남에 따라 여러 개의 값을 순차적으로 내보내는 비동기 데이터 스트림입니다. API 응답처럼 단일 값을 한 번만 받는 suspend fun과 달리, Flow는 실시간 업데이트나 지속적인 데이터 흐름(예: 센서 데이터, DB 변경 사항)에 사용됩니다.

Flow의 3단계 구조

3. 🎯 Flow 소비 및 상태 변환 전략 4가지

Flow에서 데이터를 소비하는 방식은 앱의 성능과 안정성에 직접적인 영향을 미칩니다.

A. collect: 순차적(Serial) 소비

• 동작: Flow에서 값을 내보낼 때마다, 소비 블록 내부의 모든 로직이 완료될 때까지 다음 값의 처리를 기다립니다. 처리 순서가 엄격하게 보장됩니다.
• 사용처: 모든 데이터가 빠짐없이 순서대로 처리되어야 할 때 (예: 트랜잭션 기록).

B. collectLatest: 최신 값만 처리 및 이전 작업 취소

• 동작: 값을 처리하는 도중에 새로운 값이 들어오면, 진행 중이던 이전 값의 처리(suspend 블록)를 즉시 취소하고 가장 최신 값의 처리를 시작합니다.
• 사용처: 중간 과정은 중요하지 않고 최종 결과만 중요할 때 (예: 검색어 입력 시 이전 검색 요청 취소, 빠른 스크롤 시 이전 이미지 로드 취소).

// collectLatest 예시
someFlow.collectLatest { query ->
    // 1. 새로운 query가 들어오면 delay와 searchUsers는 즉시 취소됨
    delay(300) // 디바운스 효과
    val results = searchUsers(query) 
    updateUI(results)
}

C. stateIn: Flow를 StateFlow로 변환 (ViewModel 상태화)

• 동작: 일반 Flow(Cold Flow)를 StateFlow (Hot Flow)로 변환하여 UI 상태 관리에 적합하게 만듭니다. StateFlow는 항상 초기 값과 최신 단일 값을 유지합니다.
• 필수 인자:
  • scope: Flow가 실행될 코루틴 스코프 (보통 viewModelScope).
  • started: Flow 데이터 생산 시작 시점을 결정하는 정책 (대부분 SharingStarted.WhileSubscribed(5000) 사용).
• 사용처: ViewModel에서 Repository의 Flow 데이터를 받아 UI 상태로 노출할 때 사용됩니다.

// stateIn 예시 (ViewModel에서 사용)
class MyViewModel(repository: Repository) : ViewModel() {
    val uiState: StateFlow<UiState> = repository.getDataFlow()
        .map { data -> UiState.Success(data) } // 데이터를 UI 상태로 변환
        .stateIn(
            scope = viewModelScope,
            // 구독자가 있을 때만 데이터 생산 시작 (UI 최적화)
            started = SharingStarted.WhileSubscribed(5000), 
            initialValue = UiState.Loading // 초기 값 필수
        )
}

D. collectAsStateWithLifecycle (Compose UI 소비)

• 동작: StateFlow 또는 Flow를 Jetpack Compose의 State<T> 객체로 변환하여 UI 컴포저블 내에서 쉽게 읽고 사용할 수 있게 합니다. 값이 변경되면 **자동으로 재구성(Recomposition)**이 발생합니다.
• 라이프사이클 통합: Android Lifecycle 상태에 따라 Flow 수집을 자동으로 시작/중지합니다.
  • 화면 활성화 시 (예: STARTED 상태): 수집 시작
  • 화면 비활성화 시 (예: 백그라운드): 수집 중지
• 장점: 메모리 누수를 방지하고 앱 성능을 최적화하는 Compose UI의 모범 사례입니다.

// collectAsStateWithLifecycle 예시 (Compose Screen에서 사용)
@Composable
fun DataScreen(viewModel: MyViewModel = viewModel()) {
    // UI 상태 소비. lifecycle에 맞춰 collect가 자동 관리됨.
    val state by viewModel.uiState.collectAsStateWithLifecycle() 

    when (state) {
        is UiState.Loading -> LoadingIndicator()
        is UiState.Success -> Text((state as UiState.Success).data.content)
        // ...
    }
}

요약

suspend - 작업의 일시 중지/재개를 표현하는 함수 표식

Coroutine - suspend 실행과 상태 보존을 관리하는 실행 환경

Flow - 시간에 따라 변하는 비동기 값의 스트림 모델

Flow 소비/상태 변환 패턴:

collect: 모든 값을 순차 처리

collectLatest: 최신 값 중심 처리

stateIn: Flow를 UI 상태(StateFlow)로 변환/공유

collectAsStateWithLifecycle: Compose에서 라이프사이클 기반 안전 수집

Compose Runtime이 상태(State) 의 변경을 감지하고

UI 재구성을 효율적으로 수행하기 위해 사용하는 데이터 일관성(Consistency) 관리 시스템입니다.

간단히 말해,

• “현재 상태가 어떤 값인지”

• “어떤 컴포저블이 그 값을 참조 중인지”

• “값이 바뀌었을 때 어디를 다시 그려야 하는지”

  이 모든 것을 Snapshot 시스템이 내부에서 추적합니다.

2️⃣ Snapshot이 필요한 이유

Compose는 멀티스레드에서 상태를 바꿀 수도 있고,

Recomposition은 비동기적으로 발생합니다.

그래서 다음 두 가지 문제가 생길 수 있죠:

💡 Snapshot 시스템의 역할:

상태를 읽고 쓰는 시점을 “스냅샷(사진)”처럼 캡처해서

변경과 참조를 정교하게 추적하고, 필요한 UI만 다시 그리게 한다.

3️⃣ Snapshot의 내부 핵심 개념

4️⃣ 내부 구조 흐름

[mutableStateOf(0)]
      │
      ▼
 SnapshotMutableState
      │
  ┌───┴───────────────────────────────────┐
  │  SnapshotRecord(version, value)       │
  │  SnapshotObserver: who read this?     │
  └───────────────────────────────────────┘
      │
      ▼
 Compose Runtime registers observer
 (so it knows which composable depends on this state)

5️⃣ 상태 읽기(Read)와 쓰기(Write) 과정

🧩 (1) Read Phase

• 컴포저블이 state.value를 읽을 때,

  Snapshot Observer가 “이 컴포저블이 이 상태를 읽었다”고 기록합니다.

val count by remember { mutableStateOf(0) }
Text("Count: $count")

➡ 내부 동작:

SnapshotObserver:
  Text() 컴포저블이 count 상태를 참조함

🧩 (2) Write Phase

• count++ 처럼 상태가 바뀌면

  Snapshot 시스템이 “해당 상태를 읽은 모든 구독자(컴포저블)”를 탐색합니다.

• Compose Runtime이 그 구독자에 대해 Recomposition 요청을 보냅니다.

➡ 즉, Snapshot이 변경을 감지하고

“누가 이 데이터를 보고 있었는지”를 알고 있기 때문에

필요한 부분만 정확히 다시 그려줍니다.

6️⃣ Snapshot의 Commit Cycle

Compose는 상태 변경을 트랜잭션처럼 처리합니다.

┌───────────────────────────┐
│  1️⃣ Snapshot Open        │ ← 상태 변경 시작
│  2️⃣ Modify Record        │ ← 새 값 기록 (임시)
│  3️⃣ Apply (Commit)       │ ← 모든 변경을 일괄 반영
│  4️⃣ Notify Observers     │ ← 관련 컴포저블 재구성 요청
└───────────────────────────┘

이 덕분에 여러 상태가 동시에 바뀌어도

UI는 일관된 한 시점의 값만 본다.

7️⃣ Coroutine·Runtime과의 관계

rememberCoroutineScope() 등에서 비동기로 상태를 바꾸는 경우도,

Snapshot은 코루틴 내부의 상태 변경까지 감지합니다.

val scope = rememberCoroutineScope()
val state = remember { mutableStateOf(0) }

Button(onClick = { scope.launch { state.value++ } }) {
    Text("Click ${state.value}")
}

• 코루틴이 백그라운드에서 state.value++ 수행
• Snapshot이 write operation을 감지
• Compose Runtime이 관련 컴포저블을 재구성

💡 즉, CoroutineScope는 실행의 단위,

Snapshot은 상태 일관성 관리의 단위,

그리고 Runtime이 그 둘을 통합적으로 제어합니다.

8️⃣ 전체 내부 흐름 요약

CoroutineScope.launch { state.value++ }   // suspend context에서 상태 변경
        │
        ▼
Snapshot Write detected by Runtime
        │
        ▼
Snapshot Commit → Notify Observers
        │
        ▼
Runtime marks affected Composables as invalid
        │
        ▼
Recomposition Scheduler executes → affected UI redraw

9️⃣ Snapshot의 장점

비유로 이해하기

Snapshot은 런타임의 타임머신입니다.

런타임이 매 순간 상태의 “사진(Snapshot)”을 찍어두고,

새로운 변경이 생기면

“이 사진을 참조하던 컴포넌트만 다시 갱신”하는 구조입니다.

한 줄 요약

Snapshot은 Compose Runtime 내부의 상태 관리 핵심 엔진으로,

모든 mutableStateOf 값을 트랜잭션처럼 추적·커밋하며

필요한 컴포저블만 재구성되도록 보장한다.

즉, Compose의 반응형·일관된 UI를 가능하게 하는 런타임 레벨의 뇌(Brain) 이다.

Jetpack Compose의 UI 생명주기와 상태 추적을 관리하는 시스템입니다.

• Compose는 선언형 UI → “UI = 상태(state)의 함수”
• Compose Runtime은 내부적으로 상태 변경을 감지하고, 필요한 부분만 재구성(Recomposition) 합니다.
• remember나 mutableStateOf() 같은 것은 Compose Runtime이 상태를 추적하기 위한 장치예요.

즉, Runtime은 “UI를 그려주고, 상태를 기억하고, 상태 변화에 맞춰 UI를 다시 그리는 관리자”입니다.

2️⃣ CoroutineScope란?

비동기 코드의 실행 범위를 정의하는 “작업 영역”입니다.

val scope = rememberCoroutineScope()
scope.launch {
    // 이 블록 안은 별도의 코루틴으로 실행
}

3️⃣ rememberCoroutineScope()란?

Compose에 특화된 CoroutineScope로,

현재 컴포저블이 런타임에 활성 상태일 동안만 살아 있는 코루틴 스코프를 제공합니다.

즉:

• 해당 스코프는 컴포저블이 화면에 있을 때만 유효합니다.
• 컴포저블이 사라지거나, 재구성 시 상태가 제거되면 → Scope도 자동으로 cancel() 됩니다.

val bottomSheetActionScope = rememberCoroutineScope()

✅ 이 스코프는 Compose Runtime이 자동으로 관리합니다.

UI가 사라지면 코루틴도 정리돼서 메모리 누수나 비정상 실행이 발생하지 않아요.

4️⃣ BottomSheet에서의 동작 원리

val bottomSheetState = rememberModalBottomSheetState()
val bottomSheetActionScope = rememberCoroutineScope()

if (bottomSheetState.isVisible) {
    BottomSheetScreen(bottomSheetState) {
        bottomSheetActionScope.launch {
            bottomSheetState.hide()
        }
    }
}

이 구조를 세분화해서 보면 👇

🧩 (1) rememberModalBottomSheetState()

• Compose Runtime이 BottomSheet의 상태(열림/닫힘) 을 추적함.
• 이 상태는 remember로 “화면 내에서 유지되는 상태”가 됨.

🧩 (2) rememberCoroutineScope()

• 현재 컴포저블의 수명에 종속된 CoroutineScope 생성.
• BottomSheet가 화면에 있는 동안만 유지됨.

🧩 (3) launch { bottomSheetState.hide() }

• BottomSheetState의 hide() 함수는 suspend function (일시 중단 가능 함수)이므로,
• 반드시 코루틴 안에서 호출해야 함. (그래서 launch 필요)
• 이 코루틴은 bottomSheetActionScope에서 실행됨 → 즉, Compose 런타임이 관리하는 Scope 내부에서 실행됨.

5️⃣ “모달시트가 안보일 때 코루틴을 닫는다”는 말의 의미

이건 매우 정확한 표현이에요.

Compose의 런타임은 다음과 같은 원리로 동작합니다:

즉,

• 모달시트가 사라지는 순간 → 해당 Compose UI는 더 이상 렌더링 대상이 아님
• 이때 Compose 런타임이 자동으로 remember로 생성된 코루틴 스코프를 dispose
• 내부에서 실행 중이던 코루틴도 함께 cancel되어 종료됩니다.

💡 즉, “모달시트가 닫히면 코루틴을 끊는다”는 건

Compose Runtime이 해당 코루틴 스코프를 자동으로 정리(cancellation)한다는 뜻이에요.

6️⃣ Compose Runtime ↔ Coroutine 관계 요약

7️⃣ 전체 흐름 다이어그램

[Compose Runtime]
    │
    ├─ rememberModalBottomSheetState()
    │     ↓ (상태 저장 및 추적)
    │
    ├─ rememberCoroutineScope()
    │     ↓ (UI 수명에 맞는 코루틴 스코프 생성)
    │
    └─ launch { bottomSheetState.hide() }
          ↓
     suspend fun hide() → BottomSheetState 애니메이션 비동기 처리
          ↓
     BottomSheet 사라짐 → Composition Tree에서 제거
          ↓
     rememberCoroutineScope() 자동 cancel()

8️⃣ 정리: Compose에서 코루틴이 작용하는 방식

9️⃣ 예시로 정리하면

“BottomSheet가 떠 있는 동안만 CoroutineScope가 유지되고,

닫히면 Compose Runtime이 자동으로 Scope를 정리한다.”

val sheetState = rememberModalBottomSheetState()
val sheetScope = rememberCoroutineScope()

BottomSheetScreen(sheetState) {
    sheetScope.launch {
        sheetState.hide() // suspend 함수 → 코루틴 내에서 실행
    }
}

✔️ 코루틴은 런타임이 UI 생명주기에 맞춰 관리

✔️ hide() 수행 도중 UI가 사라지면 → 런타임이 Scope를 cancel → 코루틴 즉시 종료

한줄 요약

Compose Runtime은 상태와 UI 생명주기를 관리하고,

rememberCoroutineScope()는 그 생명주기에 맞춰 자동으로 생성·소멸되는 코루틴 실행 컨테이너이다.

즉, BottomSheet가 닫히면 Scope가 cancel되어 코루틴도 함께 종료된다.

비유로 이해하기

Compose Runtime은 무대 감독, CoroutineScope는 조명 팀과 같아요.

무대(컴포저블)가 열리면 조명이 켜지고 (코루틴 실행),

무대가 닫히면 감독(Runtime)이 조명 팀에게 “끄자(cancel)” 하고 조명을 종료시킵니다.

즉, 무대가 사라지면(모달시트 닫힘) 코루틴도 함께 끝납니다.

remember · State Hoisting · Recomposition 관계

1️⃣ remember란?

재구성(Recomposition) 중에도 값을 유지하기 위한 “상태 저장 장치”

var count by remember { mutableStateOf(0) }

2️⃣ Recomposition이란?

상태(State)가 변할 때, 해당 상태를 참조하는 UI만 다시 그리는 과정

3️⃣ “부모에 remember를 선언한다”는 뜻은?

“상태를 자식이 아니라 부모 쪽에서 기억하고 관리한다”는 의미입니다.

이렇게 하면 부모가 상태를 제어하고, 자식은 단순히 “UI 표현 + 이벤트 전달”만 담당합니다.

비교 예시 ① ❌ 비권장: 자식 내부에 remember 선언

@Composable
fun Child() {
    var text by remember { mutableStateOf("") } // 자식이 직접 상태 관리
    TextField(
        value = text,
        onValueChange = { text = it }
    )
}

📍 문제점:

• 자식이 상태를 직접 들고 있어 부모가 제어 불가
• 다른 자식과 상태 공유 불가
• 재사용성과 테스트성이 떨어짐

비교 예시 ② ✅ 권장: 부모에 remember 선언 (State Hoisting)

@Composable
fun Parent() {
    var text by remember { mutableStateOf("") } // 부모가 상태를 기억하고 관리
    Child(
        value = text,
        onValueChange = { text = it }
    )
}

@Composable
fun Child(value: String, onValueChange: (String) -> Unit) {
    TextField(
        value = value,
        onValueChange = onValueChange
    )
}

📍 설명:

• remember는 부모에 선언 → 부모가 상태를 기억
• 자식은 단순히 값을 표시하고 이벤트를 부모로 전달
• 사용자가 입력 시 → onValueChange 콜백 → 부모의 상태(text) 변경 → UI 자동 업데이트

4️⃣ State Hoisting (상태 끌어올리기)

자식이 직접 상태를 들고 있지 않고,

부모가 상태를 관리하며 자식에게 값과 이벤트 콜백을 전달하는 패턴

5️⃣ 코드 예시 (Counter 구조)

@Composable
fun ParentCounter() {
    var count by remember { mutableStateOf(0) }
    ChildCounter(
        count = count,
        onCountChange = { count = it }
    )
}

@Composable
fun ChildCounter(count: Int, onCountChange: (Int) -> Unit) {
    Button(onClick = { onCountChange(count + 1) }) {
        Text("Clicked $count times")
    }
}

💡 핵심 요약:

부모는 상태를 “기억(remember)”하고

자식은 “표현(UI)”과 “이벤트 전달”만 담당한다.

6️⃣ 데이터 흐름 구조

┌──────────────────────┐
│      Parent()        │
│  var count by remember│
│  mutableStateOf(0)   │
│          │            │
│          ▼            │
│  ChildCounter(count,  │
│     onCountChange)    │
└──────────┬────────────┘
           │
           ▼
  Button → onClick() → 부모의 상태 업데이트

🔁 부모가 상태를 기억하고, 자식은 상태를 표시 및 이벤트만 전달

→ “단방향 데이터 흐름 (Unidirectional Data Flow)” 완성

7️⃣ 왜 부모에 remember를 선언해야 할까?

8️⃣ 확장 예시 (부모 remember + 자식 분리)

@Composable
fun Parent() {
    var count by remember { mutableStateOf(0) }   // 부모 remember 선언

    Column {
        ChildDisplay(count = count)
        ChildButton(onIncrease = { count++ })
    }
}

@Composable
fun ChildDisplay(count: Int) {
    Text("Count: $count")
}

@Composable
fun ChildButton(onIncrease: () -> Unit) {
    Button(onClick = onIncrease) {
        Text("Increase")
    }
}

📍 이 구조의 장점

• 상태는 부모가 기억
• 자식은 Dumb UI (표시 + 콜백만 처리)
• Recomposition 최소화 → 성능 효율적

9️⃣ 요약: “부모 remember 선언”의 의미

🔟 정리 요약표

비유로 이해하기

부모가 상태를 “기억”하는 건,

“노트북에서 문서 파일을 열고, 여러 탭(자식들)에서 같은 문서를 공유하는 것”과 같아요.

파일(상태)은 하나지만, 탭(UI)은 여러 개일 수 있고,

부모(노트북)는 항상 최신 내용을 기억하고 있습니다.

비동기 데이터를 다루는 가장 코틀린스러운 방법.

1️⃣ Flow란?

Flow는 비동기적으로 여러 값을 순차적으로 내보내는(emit) 데이터 스트림이에요.

데이터를 한 번에 다 가져오지 않고, 필요할 때마다 값을 흘려보내는 구조라고 보면 됩니다.

2️⃣ Cold Flow vs Hot Flow

→ 대부분의 경우 Cold Flow로 충분하며,

Hot Flow는 UI 상태 관리(ViewModel) 나 이벤트 전달용으로 사용됩니다.

3️⃣ Flow의 기본 구조 (생산자–중개자–소비자)

Flow는 데이터의 “흐름(stream)”을 구성하는 3단계로 이루어져 있어요.

flow {
    emit(1) // 생산자: 데이터 방출
    emit(2)
    emit(3)
}.filter { it % 2 == 1 } // 중개자: 홀수만 통과
 .map { "값: $it" }     // 중개자: 형식 변경
 .collect { println(it) } // 소비자: 최종 처리

출력:

값: 1
값: 3

4️⃣ emit이란?

emit()은 Flow 내부에서 데이터를 방출(내보내는) 함수예요.

생산자가 emit()으로 값을 보내고, 소비자는 collect()로 받습니다.

val flow = flow {
    emit("첫 번째 데이터")
    emit("두 번째 데이터")
}

즉, emit = 생산자 → 소비자 방향으로 “데이터 신호를 보냄”

5️⃣ Flow와 스레드 (flowOn)

기본적으로 Flow는 collect가 실행되는 코루틴 컨텍스트에서 동작합니다.

데이터 생성은 백그라운드에서, 수집은 UI 스레드에서 하고 싶다면 flowOn()을 사용합니다.

flow {
    emit(loadData()) // I/O
}.flowOn(Dispatchers.IO)
 .collect { updateUI(it) } // Main

6️⃣ Hot Flow (상태 관리용 Flow)

🟢 StateFlow

• 항상 하나의 최신 상태를 유지
• 새로운 구독자도 즉시 현재 값 수신
• LiveData 대체로 UI 상태 관리에 자주 사용

private val _uiState = MutableStateFlow("Loading")
val uiState: StateFlow<String> = _uiState

_uiState.value = "Success"

🟣 SharedFlow

• 여러 구독자가 같은 이벤트를 공유
• Snackbar, Toast, Navigation 이벤트 등 단발성 알림에 적합

private val _event = MutableSharedFlow<String>()
val event = _event.asSharedFlow()

viewModelScope.launch {
    _event.emit("데이터 저장 완료!")
}

7️⃣ MutableListFlow 패턴 (리스트 상태 관리)

MutableListFlow는 관용적으로 부르는 이름으로,

정식 타입은 MutableStateFlow<List<T>>입니다.

리스트를 상태로 관리할 때 자주 쓰입니다.

private val _items = MutableStateFlow<List<String>>(emptyList())
val items: StateFlow<List<String>> = _items

fun addItem(newItem: String) {
    _items.value = _items.value + newItem
}

기존 리스트를 수정하는 대신 새 리스트로 교체해야 UI가 갱신됩니다.

✨ 요약

안드로이드 개발에서 Flow를 쓰는 이유

핫 플로우를 꼭 알아야 하는 이유

• 안드로이드 ViewModel에서 UI 상태를 노출할 때 거의 표준처럼 사용됨

  (LiveData보다 더 강력하고 코루틴 친화적)

• Jetpack Compose의 collectAsState() 와 완벽하게 호환됨

  → Compose 전환 시 필수 개념

• 이벤트 처리(SharedFlow)는 UI 피드백 구현 시 자주 등장

Kotlin 컬렉션은 List / Set / Map으로 나뉘며, 각각 읽기 전용과 가변 형태가 있다.

• 읽기 전용: List<T>, Set<T>, Map<K, V>
• 가변: MutableList<T>, MutableSet<T>, MutableMap<K, V>

읽기 전용은 인터페이스 제약일 뿐, 객체가 절대 변하지 않는다는 의미의 “진짜 불변”을 보장하지 않는다.

1) List / MutableList

• List: 순서가 있는 목록, 추가·삭제 불가
• MutableList: 순서가 있는 목록, 추가·삭제 가능

val l: List<Int> = listOf(1, 2, 3)
val m: MutableList<Int> = mutableListOf(1, 2, 3)

println(l[0])   // 인덱스 접근
println(m.size) // 크기 조회

m.add(4)
m.remove(2)
println(m)      // [1, 3, 4]

ArrayList 참고

• ArrayList<T>는 구현체 이름이다.
• JVM에서 mutableListOf()는 보통 ArrayList 기반으로 생성된다.

val a: ArrayList<String> = arrayListOf("A", "B")
val b: MutableList<String> = mutableListOf("A", "B")

2) LinkedList

• 노드들이 포인터로 연결된 연결 리스트 개념의 컬렉션
• Kotlin 표준 팩토리는 없으며 JVM에선 java.util.LinkedList를 직접 사용

val ll = java.util.LinkedList<Int>()
ll.addFirst(10)
ll.addLast(20)
println(ll) // [10, 20]

3) Set / MutableSet

• 중복 없는 집합

val s: Set<Int> = setOf(1, 2, 2, 3) // {1, 2, 3}
val ms: MutableSet<Int> = mutableSetOf(1, 2)
ms.add(2)  // 변화 없음
ms.add(3)  // {1, 2, 3}

자주 쓰는 구현체

• HashSet : 일반 집합
• LinkedHashSet : 삽입 순서 유지
• TreeSet : 항상 정렬 상태 유지

val sorted = sortedSetOf(3, 1, 2) // TreeSet 기반
println(sorted) // [1, 2, 3]

4) Map / MutableMap

• Key → Value 쌍을 보관, Key 중복 시 덮어씀

val m1: Map<String, Int> = mapOf("A" to 1, "B" to 2)
val m2: MutableMap<String, Int> = mutableMapOf("A" to 1)

m2["B"] = 2         // 추가/수정
println(m2["A"])    // 조회
m2.remove("A")      // 삭제

자주 쓰는 구현체

• HashMap : 일반 맵
• LinkedHashMap : 삽입 순서 유지
• TreeMap : Key 기준 정렬 유지

val sortedMap = sortedMapOf(2 to "two", 1 to "one")
println(sortedMap) // {1=one, 2=two}

5) 정렬 유지 컬렉션

항상 정렬 규칙을 유지해야 할 때 TreeSet과 TreeMap을 사용한다. 요소의 자연 순서나 Comparator로 기준을 지정한다.

data class Item(val name: String, val price: Int)

val byPrice = java.util.TreeSet<Item>(
    compareBy(Item::price).thenBy(Item::name)
)

byPrice.add(Item("A", 1200))
byPrice.add(Item("B", 800))
println(byPrice) // 가격→이름 순으로 정렬된 상태로 보관

6) 선택 가이드

• 읽기 전용 목록이 필요하면 listOf
• 추가·삭제되는 목록이면 mutableListOf
• 중복 없이 모으려면 mutableSetOf 또는 HashSet
• 키로 값을 관리하려면 mutableMapOf 또는 HashMap
• 항상 정렬 상태가 필요하면 sortedSetOf 또는 sortedMapOf
• 삽입 순서를 유지하며 보고 싶으면 LinkedHashSet, LinkedHashMap

7) 컬렉션 확장 함수

val nums = listOf(1, 2, 3, 4, 5)

val even = nums.filter { it % 2 == 0 } // [2, 4]
val doubled = nums.map { it * 2 }      // [2, 4, 6, 8, 10]

nums.forEach { println(it) }           // 요소 순회

1️⃣ inline 이란?

“함수 호출을 인라인(복붙) 하여 호출 오버헤드를 줄이는 키워드”

기본 개념

• 일반 함수는 호출 시 스택에 함수를 넣고 실행하지만,

  inline 함수는 컴파일 시 함수 본문을 호출 위치에 그대로 삽입합니다.

• 즉, 함수 호출 비용(call overhead) 을 제거해줍니다.

✅ 예시

inline fun repeatTwice(action: () -> Unit) {
    action()
    action()
}

fun main() {
    repeatTwice { println("Hi") }
}

컴파일 시 내부적으로 이렇게 바뀜 👇

(즉, 함수 호출 자체가 사라집니다.)

fun main() {
    println("Hi")
    println("Hi")
}

효과

• 성능 최적화 (람다 호출 오버헤드 제거)
• 비지역 반환(non-local return) 가능 (람다 안에서 return하면 바깥 함수 종료)

2️⃣ noinline 이란?

“인라인 함수 안에서 특정 람다 파라미터만 인라인하지 않도록 예외 처리”

사용 배경

• inline 함수 안에서는 기본적으로 모든 람다 파라미터가 인라인됨.

• 하지만 람다를 나중에 저장하거나 다른 함수에 전달해야 한다면,

  인라인되면 안 되므로 noinline을 붙여야 함.

• 객체 생성시 noinline이 붙는다면 선언할때마다 계속 생성함

✅ 예시

inline fun doSomething(
    inlineBlock: () -> Unit,
    noinline normalBlock: () -> Unit
) {
    inlineBlock()           // 인라인됨
    val ref = normalBlock   // ❌ 일반 람다는 저장 불가 → noinline 덕분에 가능
    ref()                   // 나중에 호출 가능
}

정리

• inline 함수 내부에서 람다를 저장/전달해야 한다면 → noinline
• 즉, “인라인은 하지 말고 일반 변수처럼 써라.”

3️⃣ crossinline — 비지역 반환 금지 + 안전한 컨텍스트 호출 허용

“인라인 함수 안의 람다를 다른 컨텍스트(비동기, 콜백 등) 에서 호출할 수 있도록 허용하되,

비지역 반환은 컴파일 단계에서 금지시킴”

✅ 예시

inline fun runAsync(crossinline block: () -> Unit) {
    Thread {
        block() // 다른 스레드(비동기) 안에서 실행
    }.start()
}

fun main() {
    runAsync {
        println("Running in background")
        // return ❌ 불가능 (비지역 반환 금지)
        return@runAsync ✅ 가능 (지역 반환)
    }
}

핵심 의미 두 가지

1. 컴파일 타임에 비지역 반환을 차단

   → 다른 컨텍스트에서 return이 호출돼 프로그램 흐름이 꼬이는 걸 방지

2. 비동기 컨텍스트 허용

   → 람다가 스레드, 콜백, 리스너 안에서도 안전하게 실행 가능

4️⃣ 한눈에 보는 비교표

5️⃣ 함께 이해하면 좋은 개념: 비지역 반환 (Non-local return)

inline fun call(block: () -> Unit) {
    block()
    println("After block")
}

fun main() {
    call {
        println("Inside")
        return  // ✅ main()까지 빠져나감
    }
    println("This line never runs")
}

→ inline 함수이기 때문에 block() 내부의 return이

바깥 함수(main) 까지 영향을 미침.

즉, 이것이 “비지역 반환(non-local return)”입니다.

crossinline을 붙이면 이런 식의 제어 흐름을 컴파일러가 막습니다.

6️⃣ 안드로이드 예시 — SearchView 검색어 리스너

SearchView의 setOnQueryTextListener() 콜백을

확장 함수로 더 간결하게 만들 수 있습니다.

inline fun SearchView.onQueryTextChanged(
    crossinline onQuery: (String) -> Unit
) {
    setOnQueryTextListener(object : SearchView.OnQueryTextListener {
        override fun onQueryTextSubmit(query: String?) = true

        override fun onQueryTextChange(newText: String?): Boolean {
            onQuery(newText.orEmpty()) // crossinline: 안전하게 콜백 호출
            return true
        }
    })
}

✅ 사용 예시

searchView.onQueryTextChanged { keyword ->
    // 실시간 검색어 추천
    adapter.submitList(allItems.filter { it.contains(keyword, ignoreCase = true) })
}

콜백이 익명 객체(다른 컨텍스트) 안에서 실행되므로crossinline을 써서 비지역 반환을 금지 + 안전한 호출을 허용.

7️⃣ 마무리 요약

it — 람다식의 기본 매개변수

람다식에서 매개변수가 하나뿐일 때,

그 값을 직접 이름 붙이지 않아도 자동으로 it 으로 참조할 수 있습니다.

numbers.map { it * 2 }

위 코드는 아래와 완전히 동일합니다 👇

numbers.map { number -> number * 2 }

즉, it은 “현재 처리 중인 요소”를 나타내는 기본 이름이에요.

별도의 변수명을 쓰지 않아도 간단하게 표현할 수 있다는 게 장점입니다.

.map() — 리스트 변환 (Transformation)

리스트의 각 요소를 변환하여 새로운 리스트를 만듭니다.

• 기존 리스트는 변경되지 않습니다.
• 각 요소에 변환 함수(람다식) 을 적용합니다.

한 줄 요약:

map은 “리스트의 모든 요소에 어떤 함수를 적용해서 변환한 결과를 리턴”합니다.

.filter() — 조건 필터링 (Filtering)

조건식을 만족하는 요소만 걸러서 새로운 리스트로 반환합니다.

한 줄 요약:

filter는 “조건을 통과한 요소만 남기는 함수”입니다.

체이닝 (Chaining)

map과 filter는 함께 이어서 쓸 수 있습니다.

이걸 함수 체이닝(Function Chaining) 이라고 부르며,

중간 리스트를 만들지 않고 한 줄로 연속적인 변환 과정을 표현할 수 있습니다.

val result = numbers
    .filter { it > 3 }   // 3보다 큰 숫자만 필터링 → [4, 5, 6, 7, 8]
    .map { it * 10 }     // 각 숫자에 10을 곱함 → [40, 50, 60, 70, 80]
    .take(3)             // 앞에서 3개만 가져옴 → [40, 50, 60]

이런 식으로 코드를 위에서 아래로 자연스럽게 읽을 수 있어

for문보다 훨씬 간결하고 가독성이 좋아집니다.

핵심 정리표

최종 예제 코드

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8)

    // 1️⃣ map — 리스트의 각 요소를 변환 (Transformation)
    val doubled = numbers.map { it * 2 }
    println("두 배가 된 숫자들: $doubled") // [2, 4, 6, 8, 10, 12, 14, 16]

    // 2️⃣ filter — 조건을 만족하는 요소만 남김 (Filtering)
    val evens = numbers.filter { it % 2 == 0 }
    println("짝수들: $evens") // [2, 4, 6, 8]

    // 3️⃣ 체이닝 — filter + map + take
    val result = numbers
        .filter { it > 3 }   // [4, 5, 6, 7, 8]
        .map { it * 10 }     // [40, 50, 60, 70, 80]
        .take(3)             // [40, 50, 60]

    println("최종 결과: $result")
}

✅ 마무리 요약

• it 👉 현재 요소를 가리키는 기본 변수
• .map() 👉 변환 (Transformation)
• .filter() 👉 선택 (Filtering)
• 여러 함수를 체이닝하면 가독성 높은 “데이터 처리 파이프라인” 완성

• lateinit은 "나중에 초기화하겠다"(late initialization)는 의미를 가진 키워드입니다.
• 보통 val(읽기 전용)에는 사용할 수 없고, var(가변 변수) 와 Non-null 타입에만 적용됩니다.
• 즉, 선언 시 값을 할당하지 않고, 나중에 꼭 초기화할 것을 보장할 때 사용합니다.

📌 사용 조건

1. var 이어야 함 (val에는 사용 불가)
2. Non-null 타입이어야 함 (String? 같은 Nullable에는 불가)
3. 기본 타입(Int, Double 등) 에는 사용 불가 → 객체 타입만 가능

기본 예시

class User {
    lateinit var name: String   // 나중에 반드시 초기화할 변수

    fun initName(newName: String) {
        name = newName
    }

    fun printName() {
        println("사용자 이름: $name")
    }
}

val u = User()
u.initName("민수")   // 나중에 초기화
u.printName()        // 출력: 사용자 이름: 민수

선언 시 값이 없어도 컴파일 오류가 발생하지 않고, 나중에 initName()에서 반드시 초기화함.

자주 쓰이는 상황

1) DI (의존성 주입)

class Service

class Client {
    lateinit var service: Service   // 외부에서 주입 예정
}

→ 스프링(Spring) 같은 프레임워크에서 객체 주입 시점에 활용.

2) Android 개발 (View, Context 등)

class MainActivity : AppCompatActivity() {
    lateinit var textView: TextView

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        textView = findViewById(R.id.myTextView)
        textView.text = "Hello World!"
    }
}

→ onCreate() 시점에서 초기화되므로, lateinit을 사용해 미리 null 체크 없이 선언 가능.

⚠️ 주의사항

1. 초기화 전에 사용하면 UninitializedPropertyAccessException 발생

    lateinit var title: String
    println(title) // ❌ 초기화 안 해서 런타임 오류

2. 기본 타입에는 사용할 수 없음

    lateinit var age: Int // ❌ 컴파일 오류

   → 해결: Int?(nullable) 또는 Delegates.notNull() 활용

    var age: Int by Delegates.notNull()

3. 꼭 "반드시 나중에 초기화된다"는 논리적 보장이 필요

정리

• lateinit = 나중에 초기화하는 Non-null var
• 주로 DI, Android View 바인딩, 테스트 코드 등에서 많이 사용
• 초기화 전 접근 시 런타임 오류가 나므로, 확실히 초기화 시점을 보장할 때만 사용해야 함

기본 개념

• init 블록은 클래스의 인스턴스를 생성할 때 (생성자가 호출될 때) 실행되는 코드 블록입니다.
• 주로 클래스 본체 내에서 속성 초기화 로직을 수행하거나 생성 시 필요한 유효성 검사, 계산, 설정 등의 추가적인 작업을 수행하는 데 사용됩니다.
• 주 생성자(Primary Constructor)*는 클래스 헤더에 정의되며 실행 가능한 코드를 포함할 수 없기 때문에, 이러한 초기화 코드는 init 블록에 위치해야 합니다.
• 주 생성자(Primary constructor): 클래스 헤더에 정의되는 매개변수
• init 블록: 객체 생성 시 자동으로 실행되는 초기화 블록
• 속성(Property): val/var로 클래스 내부에 선언된 멤버 변수

class Student(val name: String, var age: Int) {
    init {
        require(age >= 0) { "나이는 음수가 될 수 없습니다: $age" }
        println("학생 생성 완료 → $name, $age")
    }
}

val s = Student("민수", 20)
// 출력: 학생 생성 완료 → 민수, 20

속성 선언 패턴

1) 가장 간단한 패턴 (헤더에 바로 선언)

class Car(val brand: String = "Hyundai", var color: String = "white")

2) init 블록에서 가공·검증 후 할당

class Car(brand: String, color: String) {
    val brand: String
    var color: String

    init {
        require(brand.isNotBlank()) { "브랜드는 비어 있을 수 없습니다." }
        this.brand = brand.trim()
        this.color = color.lowercase()
    }
}

초기화 실행 순서

1. 주 생성자 인자 평가
2. 속성 초기화 → init 블록 실행 (위에서 아래 순서대로)

class Order(id: String) {
    val normalizedId = id.trim()   // 1) 속성 초기화
    init { println("init 실행: $normalizedId") }  // 2) init 블록 실행
}

보조 생성자와 this()

보조 생성자(Secondary constructor)는 반드시 주 생성자에 위임합니다.

그리고 항상 init 블록이 먼저 실행됩니다.

class Person(val name: String, val age: Int) {
    init { println("init 실행: $name, $age") }

    constructor(name: String) : this(name, 0) {
        println("보조 생성자 실행 → $name (age=0)")
    }
}

val p1 = Person("민재")
// 출력: init 실행 → 보조 생성자 실행

상속과 초기화 순서

상위 클래스 → 하위 클래스 순으로 초기화가 진행됩니다.

open class Base(val id: String) {
    init { println("Base init: $id") }
}

class Child(id: String, val tag: String) : Base(id) {
    init { println("Child init: $tag") }
}

val c = Child("ID-1", "TAG-9")
// 출력: Base init → Child init

자주 쓰는 패턴 모음

✅ 데이터 클래스 + 검증

data class Point(val x: Int, val y: Int) {
    init { require(x in 0..100 && y in 0..100) }
}

✅ 기본값 + 이름 있는 인자

class User(val name: String, val age: Int = 0, val country: String = "KR")

val u1 = User("지연")
val u2 = User(name = "Alex", age = 30)

✅ 팩토리 함수 활용 (init 깔끔하게)

class Color private constructor(val r: Int, val g: Int, val b: Int) {
    companion object {
        fun fromHex(hex: String): Color {
            val clean = hex.removePrefix("#")
            require(clean.length == 6)
            return Color(
                clean.substring(0, 2).toInt(16),
                clean.substring(2, 4).toInt(16),
                clean.substring(4, 6).toInt(16)
            )
        }
    }
}

val green = Color.fromHex("#4CAF50")

⚠️ 실수 방지 체크리스트

• ❌ init에 인자를 직접 넣으려 함 → init은 인자를 받지 않습니다.
• ❌ 생성자에서 val/var 빠뜨림 → 단순 매개변수만 남고 속성이 안 만들어짐.
• ❌ 모든 검증·가공을 init에 몰아넣음 → 복잡해지면 팩토리 함수 활용 추천.
• ❌ 자바 연동 시 기본값만 사용 → 필요하면 @JvmOverloads 사용.

📝 결론

• init 블록은 인자를 직접 받지 않고 주 생성자의 매개변수를 활용하는 구조
• 초기화 시점에 검증·로그·가공 작업을 넣는 용도로 적합
• 단순 속성은 생성자 헤더에 바로 val/var 선언하는 게 더 깔끔

이들은 함수의 반환, 타입 계층, 예외 처리를 명확하게 정의하는 데 중요한 역할을 합니다.

1. Unit: 반환값이 없는 함수

• 정의: 반환 값이 없음을 나타내는 타입 (자바의 void와 유사).
• 차이점: void는 키워드지만, Unit은 실제 타입이며 단 하나의 인스턴스만 존재.
• 제네릭 활용 가능: Unit은 타입이므로 제네릭 인자로 사용할 수 있음.
• 사용 용도: 반환할 데이터는 없지만, 함수가 동작을 마쳤음을 명시적으로 표현할 때.

fun exampleFunction(): Unit {
    println("This function returns Unit.")
}

// 반환 타입 생략 시 자동으로 Unit 추론
fun exampleFunction2() {
    println("This function also returns Unit.")
}

2. Any: 모든 타입의 부모

• 정의: 코틀린 모든 클래스의 최상위 타입 (자바의 Object와 유사).
• 특징: 기본 타입(Int, String 등)까지 포함.
• 주의점: Any는 null 불가. null 허용 시 Any? 사용해야 함.
• 사용 용도: 다양한 타입을 하나의 변수/컬렉션에 담고 싶을 때.

//any 메소드(함수)

• equals(other:any) , hashCode(), toString() 등 있음

  fun printAny(value: Any) {
    println("받은 값: $value")
    println("값의 타입: ${value::class.simpleName}")
  }
  

fun main() { printAny("안녕하세요!") // String printAny(12345) // Int printAny(true) // Boolean }

---

## 3. Nothing: 존재하지 않는 값

- **정의**: 어떤 값도 가질 수 없는 타입. 인스턴스 생성 불가.
- **의미**: 함수가 **정상적으로 종료되지 않음**을 컴파일러에게 알려줌.
- **사용 용도**: 예외 발생, 무한 루프, 프로그램 흐름이 끊기는 상황에 사용.
- **활용 사례**:
    - `fail()` 같이 반드시 예외를 던지는 함수.
    - `?:` (엘비스 연산자)와 함께 null 처리.

```kotlin
fun fail(message: String): Nothing {
    throw IllegalArgumentException(message)
}

fun main() {
    val name: String? = "코틀린"
    val safeName = name ?: fail("이름이 없습니다!") // "코틀린" 할당

    val anotherName: String? = null
    val anotherSafeName = anotherName ?: fail("이름이 없습니다!")
    println("이 코드는 실행되지 않습니다.") // 도달 불가
}

추가로 알면 좋은 점

• Void와 Unit의 차이

  • Void(자바): null만 가질 수 있는 참조 타입.
  • Unit(코틀린): 단일 인스턴스를 가지며 실제 객체.

• Nothing? 타입

  • Nothing?은 null만 허용하는 타입. 일반적으로 잘 쓰이지 않지만, API 설계에서 의미를 명확히 할 때 활용 가능.

• 타입 계층 구조

    Nothing  ←  (모든 하위 타입의 시작점, 값 없음)
         ↑
       String, Int, Boolean ...  ← 일반 타입들
         ↑
        Any   ← 최상위 부모
         ↑
       Unit   ← 반환값 없음(특수 케이스)

이 다이어그램은 Kotlin 타입 계층 구조를 보여줍니다:

• 최상위는 Any
• String, Int, Boolean 등 모든 구체 타입이 Any를 상속
• Unit 역시 Any의 하위 타입
• Nothing은 모든 타입의 하위 타입(즉, "값이 존재하지 않음")

코루틴은 OS 스레드보다 훨씬 가벼운 경량 스레드(Light-weight Thread)입니다.

복잡한 콜백(Callback) 지옥 없이 비동기 코드를 마치 순차적인 코드처럼 작성할 수 있게 해줍니다.

🔹 핵심 키워드: suspend

코루틴의 마법은 suspend 키워드에서 시작됩니다.

suspend 함수는 실행을 잠시 중단(Suspend)했다가, 필요할 때 다시 이어서 실행(Resume)할 수 있는 함수입니다.

이 중단/재개 메커니즘 덕분에, 코루틴은

I/O 작업(네트워크 통신, 파일 읽기 등)처럼 대기 시간이 긴 작업 동안

스레드를 점유하지 않고 효율적으로 자원을 사용할 수 있습니다.

2️⃣ launch와 Job: 코루틴의 시작과 생명 주기

2.1 launch 함수 — 코루틴을 시작하는 빌더

launch는 새로운 코루틴을 시작하는 가장 기본적인 코루틴 빌더(Coroutine Builder)입니다.

• 역할: 결과를 반환할 필요가 없는, “실행 후 잊어버리는” 비동기 작업 시작 시 사용
• 반환값: 실행된 코루틴 자체를 의미하는 Job 객체를 반환

import kotlinx.coroutines.*

fun main() = runBlocking {
    // launch를 사용해 비동기 작업 시작
    val myJob: Job = launch {
        println("작업 시작: 네트워크 통신 중...")
        delay(1000L) // 1초간 suspend
        println("작업 완료: 데이터 수신됨")
    }

    // launch는 Job 객체를 반환하므로, 이를 통해 코루틴 제어 가능
}

2.2 Job 객체 — 코루틴의 생명 주기 제어 핸들

Job은 실행 중인 코루틴의 생명 주기(Lifecycle)를 관리하고 제어하는 역할을 합니다.

또한, 부모-자식 관계가 있어 부모 코루틴이 취소되면 모든 자식 코루틴이 자동으로 취소됩니다.

이를 구조화된 동시성(Structured Concurrency)이라 합니다.

import kotlinx.coroutines.*

fun main() = runBlocking {
    val job = launch {
        try {
            delay(2000L) // 중단 가능한 함수 필요
            println("이 메시지는 출력되지 않을 수 있습니다.")
        } catch (e: CancellationException) {
            println("작업이 취소되었습니다.")
        }
    }

    delay(500L)
    job.cancel() // 0.5초 후 취소 요청
    job.join()   // 취소가 끝날 때까지 대기
    println("메인 루틴 종료")
}

3️⃣ CoroutineScope: 코루틴의 실행 범위와 생명 주기 관리

코루틴은 혼자서 존재할 수 없으며, 반드시 CoroutineScope 내에서 실행되어야 합니다.

Scope는 코루틴이 활동할 수 있는 범위(Scope)를 정의하고, 생명 주기를 관리하는 단위입니다.

3.1 스코프의 역할

• 책임 범위 정의: 스코프 내에서 시작된 코루틴들은 해당 스코프의 생명 주기를 따름

• 구조화된 동시성: 스코프가 종료되거나 취소되면 그 안의 모든 자식 코루틴(Job)이 자동으로 취소됨

  → 메모리 누수 및 예측 불가능한 동작 방지

3.2 대표적인 스코프

3.3 CoroutineScope 사용 예시

launch와 Job은 항상 Scope 내에서 사용됩니다.

import kotlinx.coroutines.*

// 1. CoroutineScope 생성
val myApplicationScope = CoroutineScope(Dispatchers.Default)

fun startWork() {
    // 2. 스코프 내에서 launch 호출
    val workJob = myApplicationScope.launch {
        println("백그라운드에서 작업 시작")
        delay(3000L)
        println("긴 작업 완료")
    }
}

fun cleanup() {
    // 3. 스코프 취소
    myApplicationScope.cancel()
    println("스코프 취소 완료: 모든 자식 코루틴 종료됨")
}

✅ 결론: 세 가지 핵심 요소 정리

한 줄 요약

“CoroutineScope는 무대, launch는 배우의 등장, Job은 그 배우의 생명줄이다.”

학습 요약

• 고차 함수(Higher-Order Function)
  • 함수를 인자로 받거나, 함수를 반환하는 함수
  • Kotlin에서 콜백 함수를 간단히 구현할 수 있음
• 람다 표현식
  • { parameter -> body } 형식
  • 파라미터가 하나일 경우 it 키워드로 축약 가능
  • 마지막 인자가 함수일 경우, 소괄호 밖으로 빼기 가능
• 콜백 함수 (Callback)
  • 특정 시점에 호출되도록 넘겨주는 함수
  • 비동기 처리나 이벤트 처리에 자주 사용됨

실습 코드

fun main() {
    // 고차 함수 호출 - 콜백 전달
    myFunc {
        println("함수 호출")
    }

    // 매개변수가 두 개일 때 (Int + 콜백)
    myFunc2(5) {
        println("함수 호출 2")
    }

    // 괄호 생략 가능 (마지막 인자가 람다일 경우)
    myFunc() {
        println("괄호 생략 형태")
    }

    // 람다식에서 파라미터가 하나면 it 사용 가능
    repeatAction(3) {
        println("반복 실행 $it 번째")
    }
}

// 콜백을 받는 고차 함수
fun myFunc(callBack: () -> Unit) {
    println("함수 시작")
    callBack()
    println("함수 끝!!")
}

fun myFunc2(a: Int, callBack: () -> Unit) {
    println("함수 시작2, a=$a")
    callBack()
    println("함수 끝!!2")
}

// 콜백에 매개변수를 전달하는 예제
fun repeatAction(times: Int, action: (Int) -> Unit) {
    for (i in 1..times) {
        action(i)  // i를 콜백에 전달
    }
}

추가 정리 포인트

• () -> Unit : 파라미터 없고 반환값 없는 함수 타입
• (Int) -> String : Int를 받아서 String을 반환하는 함수 타입
• Kotlin에서는 익명 함수 대신 람다를 더 많이 활용
• 고차 함수는 비동기 처리, 이벤트 리스너, DSL 구현에서 강력하게 쓰임

문제 링크

📝 문제 설명

ISBN(International Standard Book Number)은 전 세계 모든 도서에 부여된 고유번호로, 국제 표준 도서번호이다. ISBN에는 국가명, 발행자 등의 정보가 담겨 있으며 13자리의 숫자로 표시된다. 그중 마지막 숫자는 체크기호로 ISBN의 정확성 여부를 점검할 수 있는 숫자이다. 이 체크기호는 일련번호의 앞에서부터 각 자리마다 가중치 1, 3, 1, 3…. 를 곱한 것을 모두 더하고, 그 값을 10으로 나눈 나머지가 0이 되도록 만드는 숫자 m을 사용한다. 수학적으로는 다음과 같다.

ISBN이 abcdefghijklm 일 때, a+3b+c+3d+e+3f+g+3h+i+3j+k+3l+m ≡ 0 (mod 10)

즉, 체크기호 m = 10 - (a+3b+c+3d+e+3f+g+3h+i+3j+k+3l) mod 10 이다.

단, 10으로 나눈 나머지 값이 0일 경우 체크기호는 0이다.

전북대학교 중앙도서관에서 사서로 일하고 있는 영훈이는 책 정리를 하다가 개구쟁이 광현이에 의해서 ISBN이 훼손된 도서들을 발견했다. 광현이때문에 야근해야 하는 불쌍한 영훈이를 위해서 손상된 자리의 숫자를 찾아내는 프로그램을 작성해주자.

ISBN 13자리 숫자가 입력된다. 훼손된 숫자는 *로 표시한다. (훼손된 일련번호는 체크기호를 제외한 무작위 한 자리이다.)

출력

훼손된 숫자 *에 알맞은 숫자를 출력한다.

✅ 입력 예시

9788968322*73

✅ 예제 출력

2

💡 풀이 코드 (풀이코드한 언어)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class bj_14626 {

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

        // 가중치가 1,3,1,3 ... 이니까
        // 홀수위치에는 1을 곱하고 짝수 위치에는 3을 곱하여 다 더했을때 10으로 나눈 나머지가 0이면된다.
        //10으로 나눈 나머지가 0이 될 수 있는 훼손된 숫자 값을 구한다.

        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));

        String s = bf.readLine();

        int idx = 0, sum = 0;        

        for(int i=0; i<s.length(); i++) {
            char ch = s.charAt(i);
            //손상된 자리를 제외한 모든 숫자에 대한 가중치를 적용한 합
            //i%2 == 0 -> 짝수인덱스 -> 홀수번째 -> 그대로 더하기
            //i%2 != 0 -> 홀수인덱스 -> 짝수번째 -> 3곱해서 더하기
            if(ch != '*') sum += i % 2 == 0? ch - '0' : (ch - '0') *3;
            //손상된 자리를 넣어줌
            else idx = i;
        }

        int answer = 0;
        for(int i =0; i<10; i++) {
            //손상된 자리에 들어올 숫자 0~9
            //숫자 넣어봐서 가중치 넣어 계산해보기
            //i%2 == 0 -> 짝수인덱스 -> 홀수번째 -> 그대로 더하기
            //i%2 != 0 -> 홀수인덱스 -> 짝수번째 -> 3곱해서 더하기
            if(idx % 2 == 0 && (sum + i) % 10 == 0) {
                answer = i; 
            }
            else if(idx % 2 != 0 && (sum + 3 * i) % 10 == 0) {
                answer = i; 
            }
        }

        System.out.print(answer);

    }

}

타입 확인 (is)

• is 연산자를 이용해 객체가 특정 타입인지 확인 가능
• is가 true로 확인되면 스마트 캐스트(Smart Cast) 기능이 적용되어, 별도의 형 변환 없이 해당 타입의 멤버를 바로 사용 가능
• !is 를 사용하면 반대(특정 타입이 아닌 경우) 확인 가능

타입 변환 (as)

• as 연산자를 사용하면 강제 타입 캐스팅 수행
• 상속관계에서만 사용이 가능
• instance에서 명시적으로 캐스팅 할 때 사용
• 잘못된 타입으로 변환 시 런타임 오류(ClassCastException) 발생
• 안전한 캐스팅을 위해 as? 연산자 사용 가능 → 캐스팅 실패 시 null 반환

실습 코드

fun main() {
    val dog: Animal = Dog()
    val cat = Cat()

    // 강제 캐스팅 (잘못된 변환 → 런타임 오류 발생)
    // cat as Dog

    // 안전한 캐스팅
    val maybeDog = cat as? Dog
    println(maybeDog) // null

    // 타입 확인
    if (dog is Dog) { // true
        dog.move()   // 스마트 캐스트 적용됨
        dog.draw()
        println("멍멍이")
    }

    if (dog is Animal) { // true
            //Animal만 통과했기때문에 move만 있고 draw()는 없다.
        dog.move()
        println("멍멍")
    }

    if (dog !is Cat) { // true
        println("이 객체는 고양이가 아님")
    }
}

interface Drawable {
    fun draw()
}

abstract class Animal {
    open fun move() {
        println("이동")
    }
}

class Dog : Animal(), Drawable {
    override fun move() {
        println("후다닥")
    }
    override fun draw() {
        println("그림 그리기")
    }
}

class Cat : Animal() {
    override fun move() {
        println("살금")
    }
}

정리 포인트

• is → 타입 확인, 스마트 캐스트 지원
• !is → 특정 타입이 아님을 확인
• as → 강제 캐스팅 (잘못된 경우 예외 발생)
• as? → 안전한 캐스팅 (실패 시 null 반환)
• 자바와 달리 코틀린은 instanceof 대신 is 사용, 명확하고 간결함

문제 링크

📝 문제 설명

2024년 2월 3일 개최 예정인 온사이트 그랜드 아레나에서는 참가자들에게 티셔츠 한 장과 펜 한 자루가 포함된 웰컴 키트를 나눠줄 예정입니다. 키트를 제작하는 업체는 다음과 같은 조건으로만 주문이 가능합니다.

티셔츠는 S, M, L, XL, XXL, 그리고 XXXL의 6가지 사이즈가 있습니다. 티셔츠는 같은 사이즈의 $T$장 묶음으로만 주문할 수 있습니다. 펜은 한 종류로, $P$자루씩 묶음으로 주문하거나 한 자루씩 주문할 수 있습니다. 총 $N$명의 참가자 중 S, M, L, XL, XXL, XXXL 사이즈의 티셔츠를 신청한 사람은 각각 $S, M, L, XL, XXL, XXXL$명입니다. 티셔츠는 남아도 되지만 부족해서는 안 되고 신청한 사이즈대로 나눠주어야 합니다. 펜은 남거나 부족해서는 안 되고 정확히 참가자 수만큼 준비되어야 합니다.

티셔츠를 $T$장씩 최소 몇 묶음 주문해야 하는지, 그리고 펜을 $P$자루씩 최대 몇 묶음 주문할 수 있고, 그 때 펜을 한 자루씩 몇 개 주문하는지 구하세요.

첫 줄에 참가자의 수 $N$이 주어집니다. $(1 \le N \le 10^9)$ 

둘째 줄에 티셔츠 사이즈별 신청자의 수 $S, M, L, XL, XXL, XXXL$이 공백으로 구분되어 주어집니다. $(0 \le S, M, L, XL, XXL, XXXL \le N;$ $S + M + L + XL + XXL + XXXL = N)$ 

셋째 줄에 정수 티셔츠와 펜의 묶음 수를 의미하는 정수 $T$와 $P$가 공백으로 구분되어 주어집니다. $(2 \le T, P \le 10^9)$ 

출력

첫 줄에 티셔츠를 $T$장씩 최소 몇 묶음 주문해야 하는지 출력하세요. 다음 줄에 펜을 $P$자루씩 최대 몇 묶음 주문할 수 있는지와, 그 때 펜을 한 자루씩 몇 개 주문하는지 구하세요.

✅ 입력 예시

23

3 1 4 1 5 9

5 7

✅ 예제 출력

7

3 2

ex ) S, M, L, XL, XXL 사이즈 티셔츠를 $1$묶음씩 구매하고 XXXL 사이즈 티셔츠를 $2$묶음 구매합니다.

💡 풀이 코드 (풀이코드한 언어)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class bj_30802 {

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

        //티셔츠는 남아도 되지만 부족해서는 안됨으로 (사이즈 선택한 사람수/ 티셔츠 묶음 수) 나머지 있으면 추가 주문
        //펜은 정확히 참가자 수 만큼 준비 (전체인원수/펜 묶음 수) 나머지 낱개

        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));

        int N = Integer.parseInt(bf.readLine()); // 참가자 수

        int[] sizeArr = new int[6]; //사이즈 배열

        StringTokenizer st = new StringTokenizer(bf.readLine());

        //각 사이즈안에 선택한 사람수 넣어주기
        for(int i =0; i<sizeArr.length; i++) {
            sizeArr[i] = Integer.parseInt(st.nextToken());
        }

        //셋째줄 값 받아서 넣기
        st = new StringTokenizer(bf.readLine());
        int T = Integer.parseInt(st.nextToken()); // 정수 티셔츠
        int P = Integer.parseInt(st.nextToken()); // 펜의 묶음 수 

        //묶음 수
        int cnt = 0;
        //(사이즈 선택한 사람수/ 티셔츠 묶음 수) 나머지 있으면 추가 주문
        for(int i = 0; i<sizeArr.length; i++) {
            cnt += sizeArr[i] / T;

            //나머지가 있을경우 +1 아니면 그대로
            cnt = sizeArr[i] % T > 0? cnt + 1 : cnt;
        }

        //t장씩 최소 묶음 주문 수
        System.out.println(cnt);
        //P자루씩 묶음수와 나머지 => 몫과 나머지
        System.out.println(N/P + " " + N%P);

    }

}

상속 (Inheritance)

• 코틀린에서 클래스는 기본적으로 final (상속 불가)
• 상속이 필요하다면 클래스 선언 앞에 open 키워드를 붙여야 함
• 메소드나 프로퍼티도 기본적으로 오버라이드 불가 → open 키워드 필요
• 오버라이드 시 반드시 override 키워드 사용

인터페이스 (Interface)

• interface 키워드로 선언
• 여러 개를 동시에 구현 가능 (class A : B(), C, D)
• 함수는 기본적으로 추상 메소드이지만, 구현이 포함된 디폴트 메소드도 정의 가능
• override 키워드를 사용해 구현

실습 코드

fun main() {
    val dog = Dog()
    dog.move() // 후다닥
    dog.draw()

    val cat = Cat()
    cat.move() // 살금
}

interface Drawable { // 인터페이스
    fun draw()
}

abstract class Animal { // 추상 클래스
    open fun move() {
        println("이동")
    }
}

class Dog : Animal(), Drawable {
    // Animal의 move() 오버라이드
    override fun move() {
        println("후다닥")
    }

    // Drawable 인터페이스 구현
    override fun draw() {
        println("그림 그리기")
    }
}

class Cat : Animal() {
    override fun move() {
        println("살금")
    }
}

정리 포인트

• 기본 클래스는 상속 불가 → open 키워드를 붙여야 상속 가능
• 함수도 마찬가지 → open이 없으면 오버라이드 불가
• abstract class는 일부 구현만 제공 가능, 객체 생성 불가
• interface는 다중 구현 가능 → 클래스는 다중 상속 불가하지만 인터페이스로 보완 가능
• 오버라이드 시 항상 override 키워드 필수

• 프로퍼티를 정의할 때, 코틀린이 자동으로 생성해주는 실제 값을 저장하는 공간
• getter/setter를 직접 정의할 때 프로퍼티를 자기 자신으로 참조하면 무한 루프에 빠질 수 있음 → 이를 막기 위해 field라는 키워드를 사용

기본 동작

class Person {
    var name: String = "홍길동"
        get() = field        // name 프로퍼티의 실제 저장값 반환
        set(value) {
            field = value    // name의 실제 저장값을 변경
        }
}

• field → 프로퍼티의 backing field를 의미
• getter에서 name을 직접 호출하면 getter가 무한히 호출됨 → 대신 field를 사용해야 함

무한 루프 예시 (잘못된 코드)

class Person {
    var name: String = "홍길동"
        get() = name   // ❌ 잘못된 접근 → getter 재귀 호출
}

➡️ get() 안에서 다시 name을 호출하므로 무한 루프 발생

커스텀 활용 예시

class Person {
    var age: Int = 0
        set(value) {
            field = if (value < 0) 0 else value // 음수 방지 로직
        }
}

fun main() {
    val p = Person()
    p.age = -5
    println(p.age) // 0
}

정리 포인트

• field는 오직 프로퍼티 내부의 getter/setter 안에서만 사용 가능

• backing field는 프로퍼티에 대한 실제 저장 공간 역할

• val은 setter가 없으므로 읽기 전용 backing field만 가짐

• custom getter만 정의하고 field를 쓰지 않으면 backing field 자체가 생성되지 않음

  (즉, 계산된 값만 반환하는 프로퍼티로 동작)

학습 요약

• val → 읽기 전용(기본적으로 getter만 생성)
• var → 읽기/쓰기 가능(getter, setter 모두 생성)
• private set → 외부에서 setter 접근 차단 (읽기 전용처럼 사용 가능)
• get() → 커스텀 게터 정의 가능 (field 키워드를 사용)
• data class → equals, hashCode, toString 등을 자동으로 생성하여 객체 비교나 출력에 용이

실습 코드

fun main() {
    val john = Person("john", 20)
    val john2 = Person("john", 20)

    // 기본 클래스는 서로 다른 인스턴스 → 주소값 출력
    println(john)   // Person@735f7ae5
    println(john2)  // Person@180bc464
    println(john == john2) // false

    // 게터(get) 오버라이드 활용
    println(john.hobby) // "취미 : 축구"

    // 데이터 클래스 사용 시, 값 비교로 동등성 판단
    /*
    data class Person(val name: String, var age: Int)
    println(john == john2) // true
    */
}

class Person(
    val name: String,
    var age: Int,
) {
    var hobby = "축구"
        private set // 외부에서 hobby 변경 불가
        get() = "취미 : $field" // field 키워드 사용하여 backing field 접근

    init {
        println("init") // 객체 생성 시 자동 실행
    }

    fun some() {
        hobby = "야구" // 클래스 내부에서는 변경 가능
    }
}

정리 포인트

• 기본 getter/setter 자동 생성
  • val → getter만 생성
  • var → getter + setter 생성
• 커스텀 getter/setter
  • get() 또는 set() 오버라이드 가능
  • field → 프로퍼티의 backing field를 가리킴
• 접근 제어
  • private set → 외부에서 값 변경 차단 (읽기 전용처럼 사용)
• 객체 비교
  • 일반 클래스: 참조(주소) 비교
  • data class: 값 비교 (자동으로 equals/hashCode/toString 생성)

backing field란?

정리한 내용 링크

문제 링크

📝 문제 설명

세준이는 기말고사를 망쳤다. 세준이는 점수를 조작해서 집에 가져가기로 했다. 일단 세준이는 자기 점수 중에 최댓값을 골랐다. 이 값을 M이라고 한다. 그리고 나서 모든 점수를 점수/M*100으로 고쳤다.

예를 들어, 세준이의 최고점이 70이고, 수학점수가 50이었으면 수학점수는 50/70*100이 되어 71.43점이 된다.

세준이의 성적을 위의 방법대로 새로 계산했을 때, 새로운 평균을 구하는 프로그램을 작성하시오. 첫째 줄에 시험 본 과목의 개수 N이 주어진다. 이 값은 1000보다 작거나 같다. 둘째 줄에 세준이의 현재 성적이 주어진다. 이 값은 100보다 작거나 같은 음이 아닌 정수이고, 적어도 하나의 값은 0보다 크다.

출력

첫째 줄에 새로운 평균을 출력한다. 실제 정답과 출력값의 절대오차 또는 상대오차가 10-2 이하이면 정답이다.

✅ 입력 예시

3

10 20 30

✅ 예제 출력

66.666667

💡 풀이 코드 (풀이코드한 언어)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;

public class bj_1546 {

    public static void main(String[] args) throws NumberFormatException, IOException {

        //입력 받은 값중 최댓값 M을 사용하여 모든 점수에 (점수/M)*100으로 연산을 해준다
        //그 다음 새로운 평균을 구한다.

        BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));

        //배열 생성
        //시험 본 과목수 받기
        double arr[] = new double[Integer.parseInt(bf.readLine())];



        StringTokenizer st = new StringTokenizer(bf.readLine()," ");

        //각 과목점수 배열에 넣기
        for(int i = 0; i<arr.length; i++) {
            arr[i] = Double.parseDouble(st.nextToken());
        }

        //새로운 점수값 더할 변수 선언
        double sum = 0;

        //배열 정렬을 하면 오름차순 정렬이됨
        //마지막 원소가 최댓값이 된다. arr[arr.length-1]
        Arrays.sort(arr);

        for(int i =0; i< arr.length; i++) {

            //새로운 값을 전체 더하기
            //(점수/최댓값)*100
            sum += ((arr[i]/arr[arr.length-1])*100);
        }

        //평균 출력
        System.out.println(sum/arr.length);
    }

}