1. 안정성

var a = 10 var list: MutableList<Int> = mutableListOf()

fun main() { val lock = Any() var num = 0 for (i in 1..1000) { thread { Thread.sleep(10) synchronized(lock) { num += 1 } } } Thread.sleep(1000) println(num) }

val a = 10 a = 20 //Error

val list = mutableListOf(1,2,3) list.add(4) println(list.size) // 4

var firstName: String = "한솔" var lastName: String = "이" val fullName get() = "$lastName $firstName"

val firstName: String? = "한솔" val lastName: String = "이" val fullName: String? get() = firstName?.let {"$it $lastName"} val fullName2: String? = firstName?.let {"$it $lastName"} fun main() { if(fullName != null) { println(fullName.length) //Smart cast to 'String' is impossible, because 'fullName' is a property //that has open or custom getter } if (fullName2 != null) { println(fullName2.length) } }

fun main() { val immutableList = listOf(1, 2, 3, 4, 5) val convertedList = immutableList.map { it + 1 } println("convertedList = ${convertedList}") //convertedList = [2, 3, 4, 5, 6] }

public inline fun <T, R> Iterable<T>.map(transform: (T) -> R): List<R> { return mapTo(ArrayList<R>(collectionSizeOrDefault(10)), transform) } public inline fun <T, R, C : MutableCollection<in R>> Iterable<T>.mapTo(destination: C, transform: (T) -> R): C { for (item in this) destination.add(transform(item)) return destination }

val list = listOf(1, 2, 3, 4, 5) //해선 안되는 다운 캐스팅 if(list is MutableList) { list.add(4) }

val list = listOf(1, 2, 3, 4, 5) val mutableList = list.toMutableList() mutableList.add(4)

class FullName(var first: String, var second: String) : Comparable<FullName> { private val name: String get() = "$first $second" override fun compareTo(other: FullName): Int = name.compareTo(other.name) override fun toString(): String { return "FullName(name='$name')" } } fun main() { val names: SortedSet<FullName> = TreeSet() val person = FullName("AAA", "AAA") names.add(person) names.add(FullName("ONE", "TWO")) names.add(FullName("THREE", "FOUR")) println(names) //[FullName(name='AAA AAA'), FullName(name='ONE TWO'), FullName(name='THREE FOUR')] println(person in names) // true person.first = "ZZZ" println(names) //[FullName(name='ZZZ AAA'), FullName(name='ONE TWO'), FullName(name='THREE FOUR')] println(person in names) // false }

class User( val name: String, val surname: String) { fun withSurname(surname: String) = User(name, surname) } var user = User("lee", "hansol") user = user.withSurname("catsbi") println(user)//User(name=lee, surname=catsbi)

data class User( val name: String, val surname: String) { fun withSurname(surname: String) = User(name, surname) } var user = User("lee", "hansol") user = user.copy(surname="catsbi") println(user)//User(name=lee, surname=catsbi)

val list1: MutableList<Int> = mutableListOf() var list2: List<Int> = listOf() list1.add(1) list2 = list2 + 1 list1 += 1 //list1.plusAssign(1) list2 += 1 //list2 = list2.plus(1)

var names by Delegates.observable(listOf<String>()) {_, old, new -> println("Names changed from $old to $new") } fun main() { names += "One" names += "Two" //Names changed from [] to [One] //Names changed from [One] to [One, Two] }

var announcements = listOf<Announcedment>() private set

var list3 = mutableListOf<Int>() // bad case

val a = 1 fun fizz() { val b = 2 print(a + b) } val buss = { val c = 3 print(a + c) } //이 위치에서는 a를 사용할 수 있지만, b와 c는 사용할 수 없다.

//case 1 var user: User for(i in users.indices) { user = users[i] print("User at $i is $user") } //case 2 for(i in users.indices) { val user = users[i] print("User at $i is $user") } //case 3 for((i, user) in users.withIndex()) { print("User at $i is $user") }

//bad case val user: User if(hasValue) { user = getValue() } else { user = User() } //normal case val user: User = if(hasValue) getValue() else User()

//bad case fun updateWeather(degrees: Int) { val description: String val color: Int if(degrees < 5) { description = "cold" color = Color.BLUE } else if(degrees < 23) { description = "mild" color = Color.YELLOW } else { description = "hot" color = Color.RED } //.... } //good case fun updateWeather(degrees: Int) { val (description, color) = when { degrees < 5 -> "cold" to Color.BLUE degrees < 23 -> "mild" to Color.YELLOW else -> "hot" to Color.RED } }

val primes: Sequence<Int> = sequence { var numbers = generateSequence(2) { it + 1 } var prime: Int while (true) { prime = numbers.first() yield(prime) numbers = numbers.drop(1) .filter { it % prime != 0 } } } fun main() { println(primes.take(10).toList()) }

[2, 3, 5, 7, 11, 13, 17, 19, 23, 29]

[2, 3, 5, 6, 7, 8, 9, 10, 11, 12]

public class JavaTest { public String giveName() { ... } } //kotlin fun main() { val java = JavaTest() val name : ? = java.giveName() // 무슨 타입인가? }

public class UserRepo { public List<User> getUsers() { .. } } val users: List<User> = UserRepo().users!!.filterNotNull()

public class UserRepo { public List<User> getUsers() { .. } } val repo = UserRepo() val user1 = repo.user // user1의 타입은 User! val user2: User = repo.user // user2의 타입은 User val user3: User? = repo.user // user3의 타입은 User?

val users: List<User> = UserRepo().users

open class Animal class Dog: Animal() fun main() { var animal = Zebra() animal = Animal() // error: Type mismatch }

val DEFAULT_CAR: Car = Fiat126P() interface CarFactory { fun produce(): Car }

interface CarFactory { fun produce() = DEFAULT_CAR }

val DEFAULT_CAR = Fiat126P()

fun method(param: String) { require(validate(param) { "invalid parameter Input: $param" } }

//특정 객체가 미리 초기화되어 있어야만 처리를 하게 하고 싶은 함수 fun speak(text: String) { check(isInitialized) } //사용자가 로그인 했을 때만 처리를 하게 하고 싶은 함수 fun getUserInfo(): UserInfo { checkNotNull(token) } //객체를 사용할 수 있는 시점에 사용하고 싶은 함수 fun next(): T { check(isOpen) }

test("Stack pops correct number of elements") { val stack = Stack(10) { it } val actual = stack.pop(5) actual shoudHavSize 5 }

fun pop(num: Int = 1): List<T> { //... assert(ret.size == nul) return ret }

fun changeDress(person: Person) { require(person.outfit is Dress) val dress: Dress = person.outfit }

class Person(val email: String?) fun sendEmail(person: Person, message: String) { require(person.email != null) //이 이후로 email은 not null임이 보장된다. val email: String = person.email }

fun sendEmail(person: Person, message: String) { val email: String = person.email ?: return //... }

fun sendEmail(person: Person, message: String) { val email: String = person.email ?: run { log("Email not sent, no email address") return } //... }

inline fun <reified T> String.readObject(): T { //... if(incorrectSign) { throw JsonParsingException() } //... return result }

inline fun <reified T> String.readObjectOrNull(): T? { //... if(incorrectSign) { return null } //... return result } inline fun <reified T> String.readObjectOrNull(): T? { //... if(incorrectSign) { return Failure(JsonParsingException()) } //... return Success(result) } sealed class Result<out T> class Success<out T>(val result: T):Result<T>() class Failure<out T>(val throwable: Throwable):Result<Nothing>() class JsonParsingException: Exception()

val age = userText.readObjectOrNull<Person>()?.age ?: -1

val age = userText.readObjectOrNull<Person>() val age = when(person) { is Success -> person.age is Failure -> -1 }

val printer: Printer? = getPrinter()

printer?.print() // safe call if(printer != null) { printer.print() // smart cast } printer?.print() ?: DefaultPrinter.print() // Elvis operator

fun process(user: User) { requireNotNull(user.name) val context = checkNotNull(context) val networkService = getNetworkService(context) ?: throw NoInternetConnection() networkService.getData { data, userData -> show(data!!, userData!!) }

fun countCharactersInFile(path: String): Int { val reader = BufferedReader(FileReader(path)) reader.use { return reader.lineSequence().sumBy { it.length } } }

fun countCharactersInFile(path: String): Int { BufferedReader(FileReader(path)).use { reader -> return reader.lineSequence().sumBy { it.length } } }

fun countCharactersInFile(path: String): Int { File(path).useLines { lines -> lines.sumBy { it.length } } }