🟣
Kotlin 치트시트

Kotlin 2.x 모던 문법, 널 안전성(Null Safety), data class, 확장 함수, Scope 함수(apply/let/run/also/with), 코루틴, Flow 및 Spring 연동 레퍼런스
#kotlin#jvm#android#coroutine#flow#backend#spring#functional최종 업데이트: 2026-09-27
Kotlin 치트시트 핵심 명령어 및 실전 가이드

Kotlin 2.x 모던 문법, 널 안전성(Null Safety), data class, 확장 함수, Scope 함수(apply/let/run/also/with), 코루틴, Flow 및 Spring 연동 레퍼런스
## 1. 코틀린 시작 & 환경 설정 (Getting Started & Setup)
```bash
# 🟣 [1] SDKMAN!을 통한 코틀린 컴파일러 설치
sdk install kotlin
# 버전 확인
kotlinc -version

# [2] 대화형 인터랙티브 REPL 실행
kotlinc

# [3] 단일 파일 컴파일 및 실행
kotlinc hello.kt -include-runtime -d hello.jar
java -jar hello.jar
```
```kotlin
// Hello World 엔트리포인트 (최상위 함수 지원, 세미콜론 불필요)
fun main() {
    println("Hello, Kotlin 2.0!")
}
```

## 2. 변수 & 제어문 (Variables & Control Flow)
```kotlin
// [1] 변수 선언: val (불변, 읽기 전용) vs var (가변)
val siteName = "LuckyTechWorld" // 재할당 불가 (권장)
var visitCount = 0             // 재할당 가능
val age: Int = 28               // 타입 명시 (생략 시 자동 추론)

// [2] 문자열 템플릿 (String Templates)
println("사이트: $siteName, 방문자수: ${visitCount + 1}")

// [3] if-else 표현식 (삼항 연산자 대안)
// 코틀린에서 if는 문(statement)이 아니라 값을 반환하는 식(expression)
val max = if (a > b) a else b

// [4] 강력한 when 표현식 (Switch 문 대체)
val description = when (val score = calculateScore()) {
    100 -> "완벽"
    in 90..99 -> "우수"
    in 70..89 -> "보통"
    is Int -> "정수 점수: $score"
    else -> "미달"
}

// [5] For 루프 & 범위(Ranges)
for (i in 1..5) print(i)       // 1, 2, 3, 4, 5 (닫힌 범위)
for (i in 1 until 5) print(i)  // 1, 2, 3, 4 (끝 미포함)
for (i in 10 downTo 0 step 2) print(i) // 10, 8, 6, 4, 2, 0
```

## 3. 완벽한 널 안전성 (Null Safety)
```kotlin
// [1] 널 가능 타입 (?)
var nonNull: String = "Hello"
// nonNull = null // 컴파일 에러!

var nullable: String? = "World"
nullable = null // 허용

// [2] 안전 호출 연산자 (?.)
// nullable이 null이면 호출하지 않고 null 반환 (NPE 원천 차단)
val length: Int? = nullable?.length

// [3] 엘비스 연산자 (?: - Null 대체 기본값)
val result = nullable?.length ?: 0 // null이면 0 반환
// 조기 리턴(guard clause)에 활용
val email = user.email ?: return false

// [4] 안전한 타입 캐스팅 (as?)
val str: String? = obj as? String // 캐스팅 실패 시 ClassCastException 대신 null

// [5] 널 아님 확정 단언 (!!.) - 실무 사용 지양
// val len = nullable!!.length // null이면 즉시 NPE 발생!
```

## 4. 데이터 클래스 & 특별한 클래스 (Special Classes)
```kotlin
// [1] data class (DTO 전용 - equals, hashCode, toString, copy, componentN 자동 생성)
data class User(
    val id: Long,
    val name: String,
    val email: String,
    val isActive: bool = true // 기본값 제공
)

val u1 = User(1L, "lucky", "lucky@test.com")
val u2 = u1.copy(name = "newLucky") // 특정 필드만 변경한 불변 복사본 생성
val (userId, userName) = u1         // 구조 분해 할당 (Destructuring)

// [2] sealed class & sealed interface (상속 범위 제한, Enum보다 유연한 상태 표현)
sealed interface ApiResult<out T> {
    data class Success<T>(val data: T) : ApiResult<T>
    data class Error(val message: String, val code: Int) : ApiResult<Nothing>
    object Loading : ApiResult<Nothing>
}

// when과 조합 시 else 브랜치 불필요 (컴파일러가 모든 분기 완전성 검사)
fun handleResult(result: ApiResult<String>) = when (result) {
    is ApiResult.Success -> println("성공: ${result.data}")
    is ApiResult.Error -> println("에러: ${result.message}")
    ApiResult.Loading -> println("로딩 중...")
}

// [3] object 싱글톤 & companion object
object DatabaseConfig {
    val url = "jdbc:mysql://localhost:3306/db"
}

class Order private constructor(val id: Long) {
    companion object { // Java의 public static 개념
        fun create(): Order = Order(System.currentTimeMillis())
    }
}
```

## 5. 함수 & 람다 표현식 (Functions & Lambdas)
```kotlin
// [1] 단일 표현식 함수 & 기본값 / 명명된 인자
fun add(a: Int, b: Int = 10): Int = a + b

// 호출 시 매개변수 이름을 명시하여 가독성 증대
fun sendMail(to: String, title: String = "공지", body: String) { }
sendMail(to = "test@test.com", body = "내용입니다") // title은 기본값 사용

// [2] 고차 함수 & 후행 람다(Trailing Lambda)
// 마지막 인자가 람다인 경우 괄호() 밖으로 뺄 수 있음
fun perform(id: Int, action: (Int) -> String): String = action(id)

val output = perform(100) { value ->
    "결과값: ${value * 2}"
}
// 매개변수가 하나뿐인 람다는 암시적 it 키워드 사용
val square: (Int) -> Int = { it * it }
```

## 6. 확장 함수 & 확장 프로퍼티 (Extension Functions)
```kotlin
// 기존 클래스를 수정하거나 상속하지 않고도 새로운 메서드 추가 가능
// String 클래스에 isValidEmail() 확장 함수 추가
fun String.isValidEmail(): Boolean {
    return this.contains("@") && this.contains(".")
}

val email = "lucky@example.com"
println(email.isValidEmail()) // true

// 널 가능 수신 객체(?.) 확장 함수
fun String?.orEmptyDefault(default: String): String {
    return this ?: default
}

val nullableName: String? = null
println(nullableName.orEmptyDefault("익명")) // "익명"
```

## 7. 스코프 함수 5총사 (Scope Functions Cheatsheet)
```text
# 객체의 컨텍스트 안에서 코드 블록을 실행하는 5가지 함수
┌──────────┬──────────────┬───────────────┬───────────────────────────────┐
│ 함수명   │ 컨텍스트참조 │ 반환값        │ 주요 실무 사용 목적          │
├──────────┼──────────────┼───────────────┼───────────────────────────────┤
│ let      │ it           │ 람다 결과     │ 널 검사 및 결과 변환         │
│ run      │ this         │ 람다 결과     │ 객체 구성 후 계산값 산출     │
│ with     │ this         │ 람다 결과     │ 비-널 객체 일괄 그룹 작업    │
│ apply    │ this         │ 수신 객체(본인)│ 객체 생성 및 초기화/빌더     │
│ also     │ it           │ 수신 객체(본인)│ 부가 작업 (로깅, 유효성 검사)│
└──────────┴──────────────┴───────────────┴───────────────────────────────┘
```
```kotlin
// [1] let - null safe 연산에 가장 많이 사용
user?.let { u ->
    println("사용자 이름: ${u.name}")
}

// [2] apply - 객체 생성 후 속성 설정 (체이닝에 최적)
val user = User().apply {
    this.name = "Lucky"
    this.email = "lucky@test.com"
}

// [3] also - 원래 객체를 그대로 반환하며 중간 로깅
val numbers = mutableListOf(1, 2, 3)
    .also { println("초기 리스트: $it") }
    .apply { add(4) }
```

## 8. 컬렉션 & 시퀀스 (Collections & Sequences)
```kotlin
// [1] 불변(읽기 전용) vs 가변 컬렉션
val readOnlyList = listOf("A", "B", "C")       // add 불가
val mutableList = mutableListOf("A", "B")     // add, remove 가능
mutableList += "C"

// [2] 컬렉션 함수형 변환 API
val numbers = listOf(1, 2, 3, 4, 5, 6)
val evens = numbers.filter { it % 2 == 0 }     // [2, 4, 6]
val doubled = numbers.map { it * 2 }           // [2, 4, 6, 8, 10, 12]
val userMap = users.associateBy { it.id }      // Map<Long, User> 변환
val grouped = users.groupBy { it.role }        // Map<String, List<User>>

// [3] Sequence (대량 데이터 지연 연산 - Java Stream과 유사)
// 중간 결과를 생성하지 않고 원소별로 파이프라인 즉시 통과
val result = (1..1_000_000).asSequence()
    .filter { it % 2 == 0 }
    .map { it * 10 }
    .take(5)
    .toList()
```

## 9. 코루틴 동시성 프로그래밍 (Coroutines Basics)
```kotlin
// build.gradle.kts: implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.8.0")
import kotlinx.coroutines.*

suspend fun fetchUserData(): String {
    delay(1000) // 논블로킹 일시 중단 (Thread.sleep 대신 사용)
    return "User: Lucky"
}

fun main() = runBlocking {
    // 1. launch: 결과를 반환하지 않는 비동기 실행 (Fire-and-forget)
    val job = launch(Dispatchers.Default) {
        println("백그라운드 연산 실행 중...")
    }

    // 2. async: 결과(Deferred<T>)를 반환하는 병렬 비동기 실행
    val deferred1 = async(Dispatchers.IO) { fetchUserData() }
    val deferred2 = async(Dispatchers.IO) { "Point: 100" }

    // await()로 병렬 완료 대기
    println("${deferred1.await()} - ${deferred2.await()}")
}
```

## 10. 코루틴 Flow (비동기 콜드 스트림)
```kotlin
import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*

// 값을 여러 번 방출(emit)할 수 있는 비동기 스트림 함수
fun numberStream(): Flow<Int> = flow {
    for (i in 1..3) {
        delay(500)
        emit(i) // 데이터 방출
    }
}

suspend fun consumeStream() {
    numberStream()
        .filter { it % 2 != 0 }
        .map { "스트림 데이터: $it" }
        .collect { value -> // 수집(구독) 시점에 실행되는 Cold Stream
            println(value)
        }
}
```

## 11. 지연 초기화 & 위임 프로퍼티 (Delegated Properties)
```kotlin
// [1] by lazy - 최초 접근 시점에 1회만 계산되고 캐싱됨 (Thread-Safe)
val expensiveResource: String by lazy {
    println("무거운 초기화 로직 실행...")
    "데이터베이스 연결 풀"
}

// [2] lateinit - 나중에 초기화할 var 변수 (의존성 주입 등에 사용, 원시타입 불가)
class UserService {
    lateinit var client: HttpClient

    fun setup() {
        client = HttpClient()
    }
}

// [3] Delegates.observable - 값 변경 감지 리스너
import kotlin.properties.Delegates

var watchedProperty: Int by Delegates.observable(0) { prop, old, new ->
    println("${prop.name} 변경: $old -> $new")
}
```

## 12. 실무 Spring Boot & Kotlin 팁 (Spring & Pragmatics)
```kotlin
// build.gradle.kts 권장 플러그인:
// plugins {
//     kotlin("plugin.spring") version "1.9.23" // @Component, @Transactional 등 자동 open
//     kotlin("plugin.jpa") version "1.9.23"    // JPA Entity 기본 생성자 자동 생성
// }

@RestController
@RequestMapping("/api/v1/users")
class UserController(
    private val userService: UserService // 간결한 생성자 주입
) {

    @GetMapping("/{id}")
    suspend fun getUser(@PathVariable id: Long): ResponseEntity<UserResponse> {
        val user = userService.findById(id)
            ?: return ResponseEntity.notFound().build()
        return ResponseEntity.ok(UserResponse.from(user))
    }
}
```
💬
Kotlin 치트시트

의견 및 질문

댓글 수정

댓글 삭제
