기초
변수 & 타입
var(가변)보다 val(불변)을 선호. Kotlin은 타입을 추론하지만 명시적 어노테이션 허용. 타입 확인에는 'is' 사용(자동 스마트 캐스트). 모든 것이 객체—Kotlin 구문에 프리미티브 없음.
val name = "Alice" // immutable (preferred)
var age = 30 // mutable
val pi: Double = 3.14159
val isDev: Boolean = true
val nums: List<Int> = listOf(1, 2, 3)
println(name::class) // class kotlin.String
println(age is Int) // true문자열 템플릿
단순 변수는 $var, 표현식은 ${expr}. 삼중 따옴표 문자열은 줄바꿈 보존—깔끔한 포맷팅을 위해 trimIndent() 사용. 문자열 템플릿이 포맷 문자열 없이 문자열 빌드를 간결하고 읽기 쉽게 만듭니다.
val name = "Alice"
val age = 30
println("Name: $name, Age: $age") // simple var
println("Length: ${name.length}") // expression
println("Upper: ${name.uppercase()}")
val multiline = """
Hello, $name
Age: $age
""".trimIndent()Null 안전
Kotlin의 null 안전: ?가 nullable 타입 표시, ?. 안전 호출(null이면 null 반환), !!가 non-null 단언(null이면 NPE throw), ?: elvis(null이면 기본값). 컴파일 타임에 NullPointerException 제거—Kotlin 핵심 기능.
var name: String? = null // nullable type
println(name?.length) // null (safe call)
name = "Alice"
println(name!!.length) // 5 (non-null assertion)
val len: Int = name?.length ?: 0 // elvis operator
// Non-null types can never be null
val s: String = "hi" // not nullable타입 변환
Kotlin은 명시적 타입 변환 필요(Java 같은 암시적 확장 없음). 변환에 toInt()/toDouble()/toString() 사용. toIntOrNull()은 실패 시 null 반환—throw하는 toInt()보다 안전. 파싱의 null을 항상 처리하세요.
val n: Int = 42
val d: Double = n.toDouble()
val s: String = n.toString()
val fromStr: Int? = "100".toIntOrNull()
val invalid: Int? = "abc".toIntOrNull() // null
println(d, s, fromStr, invalid)타입 확인 & 스마트 캐스트
is가 타입 확인하고 해당 분기에서 변수를 스마트 캐스트—명시적 캐스트 불필요. !is는 부정. 안전하지 않은 캐스트에는 as(ClassCastException throw), 안전한 캐스트에는 as?(실패 시 null 반환) 사용. 스마트 캐스트는 주요 Kotlin 편의 기능.
fun describe(x: Any): String =
when (x) {
is Int -> "Int: ${x + 1}" // x smart-cast to Int
is String -> "String of length ${x.length}"
is List<*> -> "List with ${x.size} items"
else -> "Unknown"
}
println(describe(42)) // Int: 43
println(describe("hello")) // String of length 5문자열
일반적인 문자열 메서드
Kotlin 문자열은 표준 라이브러리의 풍부한 확장 함수 가짐. 대부분 새 문자열 반환(불변). 수동 루프 대신 사용. uppercase() 같은 함수는 로케일 인식—일관된 결과를 위해 uppercase(Locale.ROOT) 사용.
val s = "Hello, World"
println(s.length) // 12
println(s.uppercase()) // HELLO, WORLD
println(s.lowercase()) // hello, world
println(s.split(", ")) // [Hello, World]
println(s.replace("o", "0")) // Hell0, W0rld
println(s.reversed()) // dlroW ,olleH
println(s.startsWith("Hello")) // true여러 줄 & Raw 문자열
삼중 따옴표 문자열은 raw—이스케이프 시퀀스 불필요(삼중 큰따옴표 제외). trimMargin('|')가 | 이후의 텍스트만 유지하여 깔끔한 들여쓰기. trimIndent()가 공통 공백 제거. SQL, JSON, HTML에 이상적.
val text = """
|Hello,
|World!
""".trimMargin() // | marks line start
println(text)
val json = """{"name": "Alice", "age": 30}"""
println(json) // no escape needed for quotes
// trimIndent() removes common leading whitespace문자열 빌딩
joinToString가 구분자, 접두사, 접미사로 컬렉션을 결합하는 관용적 방법. buildString가 간결한 빌딩을 위해 StringBuilder 스코프 제공. 루프에서 반복되는 + 피하기—효율성을 위해 joinToString나 StringBuilder 사용.
val parts = listOf("apple", "banana", "cherry")
println(parts.joinToString(", ")) // apple, banana, cherry
println(parts.joinToString(prefix="[", postfix="]"))
val sb = StringBuilder()
for (p in parts) sb.append(p).append(" ")
println(sb.toString().trim())
// buildString for concise building
val result = buildString {
parts.forEach { append(it).append(";") }
}문자열을 숫자로
toInt()/toDouble()은 잘못된 입력에 NumberFormatException throw. toIntOrNull()은 null 반환—안전한 기본값을 위해 ?:와 짝꿍. toBooleanStrict()는 'true'/'false'만 허용. 사용자 입력이나 신뢰할 수 없는 데이터에는 OrNull variant 사용.
val n = "42".toInt() // 42 (throws if invalid)
val d = "3.14".toDouble() // 3.14
val safe = "abc".toIntOrNull() // null
val withDefault = "x".toIntOrNull() ?: 0 // 0
val bool = "true".toBooleanStrict() // true
println(n, d, safe, withDefault)정규식
Regex 클래스가 Java의 Pattern 래핑. find가 MatchResult? 반환(첫 매치), findAll이 모두 반환. matches가 전체 매치 확인, containsMatchIn이 부분 확인. 이중 이스케이프 백슬래시 피하기 위해 패턴에 삼중 따옴표 문자열 사용.
val email = Regex("[\w.]+@[\w]+\.[a-z]+")
val text = "Contact: [email protected]"
val match = email.find(text)
println(match?.value) // [email protected]
println(email.matches("[email protected]")) // true
val replaced = text.replace(Regex("\d+"), "#")
println(email.containsMatchIn(text)) // true데이터 구조
List
listOf가 불변 리스트 생성, mutableListOf는 가변. 리스트는 0부터 시작. 끝에는 first()/last()(빈 경우 throw), 안전에는 firstOrNull() 사용. contains가 멤버십 확인. 수정 필요 없는 한 불변 리스트 선호.
val nums = listOf(1, 2, 3) // immutable
val mutable = mutableListOf(1, 2, 3)
mutable.add(4)
mutable[0] = 0
println(nums.size) // 3
println(nums.first()) // 1
println(nums.last()) // 3
println(nums.contains(2)) // true
println(nums.indexOf(2)) // 1Map
mapOf가 불변 map 생성, mutableMapOf는 가변. 'to' infix가 쌍 생성. [] 접근은 nullable V? 반환(누락 시 null). getOrDefault나 getValue(누락 시 throw) 사용. 분해(k, v)로 반복.
val ages = mapOf("Alice" to 30, "Bob" to 25)
println(ages["Alice"]) // 30
println(ages.getOrDefault("Eve", 0)) // 0
println(ages.containsKey("Alice")) // true
for ((k, v) in ages) println("$k: $v")
val mutable = mutableMapOf("a" to 1)
mutable["b"] = 2 // add/updateSet
setOf가 불변 set 생성, mutableSetOf는 가변. union/intersect/subtract가 새 set 반환. Set은 고유성 강제—요소가 존재하면 add가 false 반환. 중복 제거와 집합 연산에 사용. LinkedHashSet은 삽입 순서 보존.
val a = setOf(1, 2, 3)
val b = setOf(3, 4, 5)
println(a union b) // [1,2,3,4,5]
println(a intersect b) // [3]
println(a subtract b) // [1,2]
println(a.contains(2)) // true
val mutable = mutableSetOf(1, 2)
mutable.add(3) // true if addedArray & 프리미티브 배열
arrayOf가 Array<T> 생성(프리미티브는 박싱). 박싱되지 않은 프리미티브 배열에는 intArrayOf/doubleArrayOf 사용(더 나은 성능). Array(size) { init }로 init 함수로 생성. 배열은 가변; 대부분의 사용 사례에는 List 선호.
val arr = arrayOf(1, 2, 3) // Array<Int>
arr[0] = 10
println(arr.size) // 3
// Specialized arrays for primitives (no boxing)
val ints = intArrayOf(1, 2, 3)
val doubles = doubleArrayOf(1.0, 2.0)
// Array constructor
val squares = Array(5) { it * it } // [0,1,4,9,16]
println(squares.toList())Pair & Triple
Pair와 Triple이 2-3개 값 그룹화. 'to' infix가 Pair 생성(map에 흔함). val (a, b) = pair로 분해. 3개 이상의 값이나 이름 있는 필드에는 data class 사용—더 명확하고 유지보수 가능.
val pair = "Alice" to 30 // Pair<String, Int>
println(pair.first) // Alice
println(pair.second) // 30
val (name, age) = pair // destructuring
val triple = Triple(1, "a", 2.0)
println(triple.first, triple.third)
// Useful for returning two values
fun minMax(list: List<Int>): Pair<Int, Int> =
Pair(list.min(), list.max())제어 흐름
If / Else (표현식)
Kotlin에서 if/else는 값을 반환하는 표현식. 삼항 연산자 대체. 양쪽 분기는 호환 가능한 타입 반환. 간결한 조건부 할당에 사용. 문장으로 사용(else 없이) 시 Unit 반환.
val score = 85
val grade = if (score >= 90) "A"
else if (score >= 80) "B"
else if (score >= 70) "C"
else "F"
println(grade) // B
// if returns a value—no ternary needed
// Both branches must have compatible typesWhen (Switch)
when은 Kotlin의 강력한 switch—리터럴, 범위(in), 부정(!in), 여러 값(쉼표), is-확인 지원. sealed 타입으로 표현식으로 사용 시 완전해야 함. 대상 없이 더 깔끔한 if/else 체인.
val n = 2
val label = when (n) {
0 -> "zero"
1, 2, 3 -> "small"
in 4..10 -> "medium"
!in 1..100 -> "out of range"
else -> "large"
}
println(label) // small
// When without subject = multi-condition if
when {
n > 0 -> println("positive")
n < 0 -> println("negative")
else -> println("zero")
}For 루프 & 범위
..은 포함 범위, until은 제외, downTo는 카운트다운, step은 증분 설정. withIndex()가 인덱스 반복 제공. for-in은 모든 Iterable에 작동. 이 범위는 카운팅 루프에 간결하고 읽기 쉬움.
for (i in 0 until 5) print(i) // 01234 (excludes 5)
for (i in 1..5) print(i) // 12345 (includes 5)
for (i in 5 downTo 1) print(i) // 54321
for (i in 1..10 step 2) print(i) // 13579
val list = listOf("a", "b", "c")
for ((index, value) in list.withIndex()) {
println("$index: $value")
}While & Do-While
while은 전에 확인, do-while은 후에 확인(최소 한 번 실행). 둘 다 가변 상태 필요. 불변성을 위해 for 루프나 함수형 연산(map, filter) 선호. 카운트를 모를 때 조건 중심 루프에 while 사용.
var count = 0
while (count < 3) {
println(count)
count++
}
var j = 0
do {
println(j)
j++
} while (j < 3)
// do-while runs at least once
// Prefer for loops when possibleBreak & Continue (레이블)
continue는 다음 반복으로 건너뛰고, break는 루프 종료. 레이블(@outer)이 중첩 루프에서 빠져나오기 가능—루프 전에 label@로 정의, break/continue에 @label. 신중하게 사용; 함수로 리팩토링이 종종 더 깔끔함.
for (i in 1..5) {
if (i == 3) continue // skip 3
if (i == 5) break // stop at 5
println(i) // 1, 2, 4
}
// Labeled breaks for nested loops
outer@ for (i in 1..3) {
for (j in 1..3) {
if (i == 2 && j == 2) break@outer
println("$i,$j")
}
}함수 & Lambda
함수 정의
함수는 fun name(params): ReturnType 사용. 단일 표현식은 표현식 본문(= expr). 기본 매개변수와 이름 있는 인자 지원. Unit 반환 타입 = 부작용만. 기본 매개변수가 오버로딩 필요 감소.
fun add(a: Int, b: Int): Int = a + b // expression body
fun greet(name: String, greeting: String = "Hello"): String {
return "$greeting, $name!"
}
println(add(3, 4)) // 7
println(greet("Alice")) // Hello, Alice!
println(greet("Bob", greeting = "Hi")) // named arg
fun log(msg: String): Unit = println(msg) // Unit = voidLambda & 고차 함수
Lambda: { params -> body }. 'it'이 단일 매개변수 약어. map/filter/reduce 같은 고차 함수에 lambda 전달. 후행 lambda 구문: 마지막 매개변수가 함수면 () 밖에 올 수 있음. 관용적 Kotlin.
val square: (Int) -> Int = { x -> x * x }
println(square(5)) // 25
val nums = listOf(1, 2, 3)
println(nums.map { it * 2 }) // [2, 4, 6]
println(nums.filter { it > 1 }) // [2, 3]
println(nums.reduce { a, b -> a + b }) // 6
// 'it' is the implicit single parameter