Kotlin in Action - 드미트리 제메로프, 스베트라나 이사코바

// 함수 정의 fun greet(name: String, message: String) { println("$message, $name!") } fun main() { // 이름 붙인 인자로 함수 호출 greet(name = "Alice", message = "Hello") }

// 함수 정의 fun greet(name: String, message: String = "Hello") { println("$message, $name!") } fun main() { // message의 경우 기본 인자인 "Hello"가 전달됨 greet(name = "Alice") }

// MyCustomClass.kt 파일 class MyCustomClass(val value: Int){ // ... } // MyCustomClassExtensions.kt 파일 fun MyCustomClass.double(): Int { return this.value * 2 } // Main.kt 파일 import MyCustomClass import double // 확장 함수 import fun main() { val obj = MyCustomClass(10) val doubledValue = obj.double() println("The doubled value is $doubledValue") }

// List, Set, Map 등에서 사용할 수 있는 확장 함수 fun <T> Collection<T>.secondOrNull(): T? { return if (this.size >= 2) this.elementAt(1) else null } // String, CharSequence 등에서 사용할 수 있는 확장 함수 fun CharSequence?.isNullOrEmpty(): Boolean { return this == null || this.isEmpty() }

// 확장 함수에 대한 인터페이스 정의 interface SecondOrNullProvider<T> { fun getSecondOrNull(): T? } // 확장 함수 정의 fun <T> SecondOrNullProvider<T>.secondOrNull(): T? { return this.getSecondOrNull() } // String 타입 대상 확장 함수 정의 class StringSecondOrNullProvider(val str: String) : SecondOrNullProvider<Char> { override fun getSecondOrNull(): Char? { return if (str.length >= 2) str[1] else null } } // StirngBuilder 대상 확장 함수 정의 class StringBuilderSecondOrNullProvider(val sb: StringBuilder) : SecondOrNullProvider<Char> { override fun getSecondOrNull(): Char? { return if (sb.length >= 2) sb[1] else null } }

// vararg 활용 함수 정의 fun sum(vararg numbers: Int): Int { var result = 0 for (num in numbers) { result += num } return result } // vararg 활용 함수 호출 val result = sum(1, 2, 3, 4, 5) println("Result is $result") // 출력 결과: Result is 15

// 중위 함수 정의 infix fun Int.add(other: Int): Int { return this + other } // 중위 함수 호출 val result = 1 add 2 println("Result is $result") // 출력 결과: Result is 3

val (x, y, z) = listOf(1, 2, 3) println("x: $x, y: $y, z: $z") // 출력 결과: x: 1, y: 2, z: 3

class Person(val name: String, val age: Int) { operator fun component1() = name operator fun component2() = age } val (name, age) = Person("John", 30) println("Name: $name, Age: $age") // 출력 결과: Name: John, Age: 30

data class Person(val name: String, val age: Int) val (name, age) = Person("John", 30) println("Name: $name, Age: $age") // 출력 결과: Name: John, Age: 30

// 중복 로직이 존재하는 예시 fun processData(data: List<Int>) { var sum = 0 for (item in data) { sum += item } println("합계: $sum") var product = 1 for (item in data) { product *= item } println("곱: $product") }

// 로컬 함수로 중복 로직을 제거한 예시 fun processData(data: List<Int>) { fun calculate(initialValue: Int, operation: (Int, Int) -> Int): Int { var result = initialValue for (item in data) { result = operation(result, item) } return result } val sum = calculate(0) { a, b -> a + b } println("합계: $sum") val product = calculate(1) { a, b -> a * b } println("곱: $product") }

// 로컬 함수를 확장 함수로 빼서 개선한 예시 fun List<Int>.calculate(initialValue: Int, operation: (Int, Int) -> Int): Int { var result = initialValue for (item in this) { result = operation(result, item) } return result } fun processData(data: List<Int>) { val sum = data.calculate(0) { a, b -> a + b } println("합계: $sum") val product = data.calculate(1) { a, b -> a * b } println("곱: $product") }

data class Person(val name: String, val age: Int) { fun copy(name: String = this.name, age: Int = this.age) : Person { return Person(name, age) } } fun main() { val person1 = Person("John", 25) val person2 = person1.copy(age = 30) println(person1) // Person(name=John, age=25) println(person2) // Person(name=John, age=30) }

data class Image(val name: String, val format: String, val fileSize: Long) fun printImageNames(images: List<Image>, predicate: (Image) -> Boolean) { images.filter(predicate).forEach { println(it.name) } } fun main() { val images = listOf( Image("image1", "jpeg", 2000), Image("image2", "png", 3000), Image("image3", "jpeg", 1000) ) // 람다를 함수의 인자로 전달 printImageNames(images) { image -> // 중괄호({})로 람다 표현식 표현, 화살표(→)로 인자와 본문 구분 // 람다 내 매개변수와 반환값의 타입을 자동으로 추론 image.format == "jpeg" && image.fileSize > 1500 } // it 키워드 사용 printImageNames(images) { it.format == "jpeg" && it.fileSize > 1500 } // 멤버 참조 사용 val imageNames = images.map(Image::name) println(imageNames) // 람다를 변수에 대입 val jpegPredicate: (Image) -> Boolean = { it.format == "jpeg" } printImageNames(images, jpegPredicate) // 람다를 함수의 리턴 값으로 사용 fun createSizePredicate(minSize: Long): (Image) -> Boolean = { it.fileSize > minSize } val sizePredicate = createSizePredicate(1500) printImageNames(images, sizePredicate) }

data class Image(val id: Int, val name: String, val format: String, val fileSize: Long, val category: String, val author: String) fun main() { val images = listOf( Image(1, "image1", "jpeg", 4096, "Nature", "Alice"), Image(2, "image2", "png", 6144, "City", "Bob"), Image(3, "image3", "jpeg", 2048, "Nature", "Alice"), Image(4, "image4", "png", 8192, "City", "Charlie"), Image(5, "image5", "jpeg", 5120, "Nature", "Alice") ) // 이미지를 카테고리별로 그룹화하고 각 그룹의 이미지 크기 합계를 구함 val categoryGroups = images.groupBy { it.category } categoryGroups.forEach { (category, imageList) -> println("$category:") imageList.forEach { image -> println(" Image: ${image.name}, File size: ${image.fileSize} Bytes, Author: ${image.author}") } } }

// 출력 결과 Nature: Image: image1, File size: 4096 Bytes, Author: Alice Image: image3, File size: 2048 Bytes, Author: Alice Image: image5, File size: 5120 Bytes, Author: Alice City: Image: image2, File size: 6144 Bytes, Author: Bob Image: image4, File size: 8192 Bytes, Author: Charlie

val fileSizeSumByCategory = categoryGroups.flatMap { (category, imageList) -> println("imageList: $imageList") listOf(Pair(category, imageList.sumByLong { it.fileSize })) } println("File size sum by category using flatMap:") fileSizeSumByCategory.forEach { (category, fileSizeSum) -> println(" Category: $category, File size sum: $fileSizeSum Bytes") } val aliceImages = images.filter { it.author == "Alice" } val bobImages = images.filter { it.author == "Bob" } val charlieImages = images.filter { it.author == "Charlie" } val allImages = listOf(aliceImages, bobImages, charlieImages).flatten() println("All images combined using flatten:") allImages.forEach { image -> println(" Image: ${image.name}, Category: ${image.category}, Author: ${image.author}") }

// 출력 결과 imageList: [Image(id=1, name=image1, format=jpeg, fileSize=4096, category=Nature, author=Alice), Image(id=3, name=image3, format=jpeg, fileSize=2048, category=Nature, author=Alice), Image(id=5, name=image5, format=jpeg, fileSize=5120, category=Nature, author=Alice)] imageList: [Image(id=2, name=image2, format=png, fileSize=6144, category=City, author=Bob), Image(id=4, name=image4, format=png, fileSize=8192, category=City, author=Charlie)] File size sum by category using flatMap: Category: Nature, File size sum: 11264 Bytes Category: City, File size sum: 14336 Bytes All images combined using flatten: Image: image1, Category: Nature, Author: Alice Image: image3, Category: Nature, Author: Alice Image: image5, Category: Nature, Author: Alice Image: image2, Category: City, Author: Bob Image: image4, Category: City, Author: Charlie

data class Image(val name: String, var format: String, var fileSize: Long) val image = Image("sampleImage", "jpeg", 2048) // with 함수 예시 val withResult = with(image) { format = format.toUpperCase() fileSize /= 1024 "Name: $name, Format: $format, File Size: $fileSize KB" } println(withResult) // Name: sampleImage, Format: JPEG, File Size: 2 KB // apply 함수 예시 val modifiedImage = image.apply { format = format.toUpperCase() fileSize /= 1024 } println(modifiedImage) // Image(name=sampleImage, format=JPEG, fileSize=2) // run 함수 예시 val runResult = image.run { val upperFormat = format.toUpperCase() val fileSizeInKb = fileSize / 1024 "Name: $name, Format: $upperFormat, File Size: $fileSizeInKb KB" } println(runResult) // Name: sampleImage, Format: JPEG, File Size: 2 KB // also 함수 예시 val loggedImage = image.also { it.format = it.format.toUpperCase() println("Image format has been changed to: ${it.format}") } println(loggedImage) // Image format has been changed to: JPEG // Image(name=sampleImage, format=JPEG, fileSize=2) // let 함수 예시 val letResult = image.let { val upperFormat = it.format.toUpperCase() val fileSizeInKb = it.fileSize / 1024 "Name: ${it.name}, Format: $upperFormat, File Size: $fileSizeInKb KB" } println(letResult) // Name: sampleImage, Format: JPEG, File Size: 2 KB

data class Image( val creatorId: Int, val url: String, val fileSize: Long, val format: String, val tags: List<String> ) // 특정 사용자가 업로드한 이미지 중 일부 조건에 맞는 이미지만 반환 fun findMatchingImages(images: List<Image>, userId: Int): List<Image> { return images.map { it.copy(tags = it.tags.sorted()) } // Image.tags 정렬하여 새로운 이미지 객체 생성 .sortedByDescending { it.fileSize } .filter { it.creatorId == userId } .distinctBy { it.format } .take(10) }

// 이미지 목록에서 크기가 sizeThreshold보다 큰 이미지의 개수를 반환 fun countLargeImages(images: List<Image>, sizeThreshold: Long): Int { return images.filter { it.fileSize > sizeThreshold }.size }

// 주어진 이미지 목록 중에서 크기가 sizeThreshold보다 큰 JPEG 이미지가 존재하는지 확인 // 조건에 맞는 이미지가 있다면, true를 반환하고 그렇지 않으면 false를 반환 fun hasLargeJpegImages(images: List<Image>, sizeThreshold: Long): Boolean { // 구현 필요 }

// 주어진 이미지 목록의 모든 이미지 크기가 minSize와 maxSize 범위 내에 있는지 확인 // 모든 이미지가 해당 범위 내에 있다면 true를 반환하고, 그렇지 않으면 false를 반환 fun areAllImagesWithinSizeRange(images: List<Image>, minSize: Long, maxSize: Long): Boolean { // 구현 필요 }

data class Image(val name: String, val format: String, val fileSize: Long) // Image::fileSize 기본 단위(Bytes)를 KB 단위로 반환하는 함수 fun fileSizeInKB(image: Image): Long { // 구현 필요 } // 람다 표현식을 사용하여 이미지 필터링하는 함수 fun filterImages(images: List<Image>, predicate: (Image) -> Boolean): List<Image> { // 구현 필요 } fun main() { val images = listOf( Image("image1", "jpeg", 4096), Image("image2", "png", 6144), Image("image3", "jpeg", 2048) ) // 3KB 이상인 이미지만 반환 val largeImages = filterImages(images) { // 수신 객체 람다로 구현 필요 } }

data class Image(val name: String, val format: String, val fileSize: Long) // 구현 필요 fun Image.isMatchingFormatAndFileSize(format: String, minimumSize: Long): Boolean fun printImageNames(images: List<Image>, predicate: (Image) -> Boolean) { images.filter(predicate).forEach { println(it.name) } } fun main() { val images = listOf( Image("image1", "jpeg", 2000), Image("image2", "png", 3000), Image("image3", "jpeg", 1000) ) // 괄호 밖 람다(trailing lambda) 개념을 적용하여, 마지막 매개변수로 정의된 람다를 소괄호 밖으로 빼서 사용함 printImageNames(images) { it.isMatchingFormatAndFileSize("jpeg", 1500) } }

fun buildString( builderAction: (StringBuilder) -> Unit ) : String { val sb = StringBuilder() builderAction(sb) return sb.toString() } val s = builderString { string -> string.append("Hello, ") stirng.append("World!") }

fun buildString( builderAction: (StringBuilder) -> Unit ) : String { val sb = StringBuilder() builderAction(sb) return sb.toString() } val s = builderString { it.append("Hello, ") it.append("World!") }

fun buildString( builderAction: StringBuilder.() -> Unit ) : String { val sb = StringBuilder() sb.builderAction() return sb.toString() } val s = builderString { this.append("Hello, ") this.append("World!") }

fun buildString( builderAction: StringBuilder.() -> Unit ) : String { val sb = StringBuilder() sb.builderAction() return sb.toString() } val s = builderString { append("Hello, ") append("World!") }

fun buildString( builderAction: StringBuilder.() -> Unit ) : String = StringBuilder().apply(builderAction).toString() val s = builderString { append("Hello, ") append("World!") }

fun buildString( builderAction: StringBuilder.() -> Unit, ): String = with(StringBuilder()) { builderAction() toString() } val s = builderString { append("Hello, ") append("World!") }

// 중위 함수 정의 infix fun Int.add(other: Int): Int { return this + other } // 중위 함수 호출 val result = 1 add 2 println("Result is $result") // 출력 결과: Result is 3

val dependencies = DependencyHandler() dependencies.compile("io.kotest:kotest-runner-junit5") dependencies { compile("io.kotest:kotest-runner-junit5") compile("io.kotest:kotest-assertions-core") compile("io.kotest:kotest-property") } // 위의 invoke 관례의 변환 결과 // dependencies.invoke({ // this.compile("io.kotest:kotest-runner-junit5") // this.compile("io.kotest:kotest-assertions-core") // this.compile("io.kotest:kotest-property") // }) class DependencyHandler { fun compile(coordinate: String) { println("~~") } operator fun invoke(body: DependencyHandler.() -> Unit) { this.body() } }

// 중위 함수 호출 연쇄 "kotlin" should start with "kot" // 일반 함수 호출 연쇄 "kotlin".should(start).with("kot") object start infix fun String.should(x: start): StratWrapper = StartWrapper(this) class StartWrapper(val value: String) { infix fun with(prefix: String) = // ... }

class MobileTokenUnitTest : FunSpec({ lateinit var authCode: MobileAuthCode beforeEach { authCode = TestDataUtils.createAuthCode() } test("인증코드 생성 후 20분이 되면 만료된다") { authCode shouldBeExpired 20.minutes.fromNow } test("인증코드 생성 후 20분 이후에는 만료된다") { authCode shouldBeExpired 21.minutes.fromNow } test("인증코드 생성 후 20분 이전에는 만료되지 않는다") { authCode shouldNotBeExpired 19.minutes.fromNow } }) infix fun MobileAuthCode.shouldBeExpired(fromNow: LocalDateTime) { this.expiredAt shouldBe lt(fromNow) } infix fun MobileAuthCode.shouldNotBeExpired(fromNow: LocalDateTime) { this.expiredAt shouldNotBe lt(fromNow) } val Int.minutes: Duration get() = Duration.ofMinutes(this.toLong()) val Duration.fromNow: LocalDateTime get() = LocalDateTime.now() + this

class Column<T> class Table { fun integer(name: String): Column<Int> { TODO() } fun varchar(name: String, length: Int): Column<String> { TODO() } fun <T> Column<T>.primaryKey(): Column<T> { TODO() } fun Column<Int>.autoIncrement(): Column<Int> { TODO() } val id = integer("id").autoIncrement().primaryKey() // 1번 // val id = varchar("id").autoIncrement().primaryKey() // 2번 } fun main() { // val id = integer("id").autoIncrement().primaryKey() // 3번 // val id = Table().integer("id").autoIncrement().primaryKey() // 4번 }

val TotalNumber = input as Num

// if condition의 연산 결과에 따라 // x or y의 값을 반환한다. val z = if (x > y) x else y

// if condition의 연산 결과(true or false)에 따라 // 이하의 출력문의 호출여부를 제어한다. if (x > 0) { System.out.println("x is positive"); } // 예외 int y = x > 0 ? 1 : -1;

Java의 예외 처리 Java에서는 두 가지 유형의 예외가 있습니다: Checked Exception과 Unchecked Exception. 1. Checked Exception: 이 예외는 컴파일 타임에 체크되며, 개발자가 이를 명시적으로 처리하도록 강제합니다. 예를 들어, IOException은 Checked Exception에 해당합니다. 이러한 예외는 try-catch 블록을 사용하거나 throws 키워드를 통해 메소드 시그니처에 선언하여 처리해야 합니다. 2. Unchecked Exception: RuntimeException과 그 서브 클래스는 Unchecked Exception에 해당하며, 이들은 컴파일 타임에 강제되지 않습니다. 즉, 개발자가 명시적으로 이를 처리하지 않아도 컴파일 에러가 발생하지 않습니다. --- Kotlin의 예외 처리 Kotlin에서는 Checked Exception과 Unchecked Exception의 구분이 없습니다. 모든 예외는 기본적으로 Unchecked로 취급됩니다. • 예외 처리의 간소화: Kotlin은 Java와 달리 Checked Exception을 명시적으로 처리하도록 강제하지 않습니다. 따라서, 개발자는 try-catch 블록을 사용하여 예외를 처리할 수도 있고, 아니면 전혀 처리하지 않을 수도 있습니다. • 유연성 증가: 이 접근 방식은 코드의 유연성을 증가시키고, 과도한 예외 선언으로 인한 코드의 복잡성을 감소시킵니다. 비교 및 결론 • Java: Checked Exception을 통해 더 엄격한 에러 처리를 강제하지만, 이로 인해 코드가 더 복잡해질 수 있습니다. 또한, 예외 처리를 강제함으로써 개발자가 예외에 더 주의를 기울이도록 유도합니다. • Kotlin: 모든 예외를 Unchecked로 취급함으로써 개발자에게 더 많은 유연성을 제공합니다. 이는 코드를 더 간결하고 읽기 쉽게 만들지만, 예외 처리에 대한 개발자의 주의가 필요합니다.