코틀린 기본 문법

Basic Java Kotlin

Word count: 740Reading time: 4 min

 2024/08/17   Share

코틀린 기본 문법


fun main() {
    //kotlin print
    println("hello World!")
    print("11")
    println("12")

    //val -> immutable
    val valInt = 1
    val valInt2: Int
    valInt2 = 2

    //var -> mutable
    var varInt: Int
    varInt = 2
    varInt = 3

    //System input
    val yourWord = readln()

    val sum = sum(1, 2)
    println(sum)
    printSum(2, 3)

    var rectangle: Rectangle = Rectangle(5.0, 4.0)
    println(rectangle.perimeter)

    //String expressing
    var a = 1
    val s1 = "a is $a"
    a = 2
    val s3 = "${s1.replace("is", "was")}, but now is $a"
    println(s3)

    //function expressing1
    val maxOf = maxOf(1, 2)
    println(maxOf)
    //function expressing2
    fun maxOf2(a: Int, b: Int) = if (a > b) a else b
    val maxOf2 = maxOf2(1, 2)
    println(maxOf2)


    //nullable function return
    getStringLength("ss")


    //array and for
    val items = listOf("apple", "banana", "kiwifruit")
    for (index in items.indices) {
        println("item at $index is ${items[index]}")
    }

    // when
    fun describe(obj: Any): String =
        when (obj) {
            1 -> "One"
            "Hello" -> "Greeting"
            is Long -> "Long"
            !is String -> "Not a string"
            else -> "Unknown"
        }

    // when function usecase
    val describe = describe("Hello")
    println("뭐냐? $describe 이거다")


    val x = 10
    val y = 9
    if (x in 1..y + 1) {
        println("fint in range")
    }


    val list = listOf("a", "b", "c")
    if (2 !in 0..list.lastIndex) {
        println("-1 is out of range")
    }
    if (list.size - 1 !in list.indices) {
        println("list size is out of valid list indices range, too")
    }

    // when
    when {
        "orange" in items -> print("오랜지")
        "apple" in items -> print("사과")
    }

    //stream filter
    val fruits = listOf("banana", "avocado", "apple", "kiwifruit")
    fruits.filter { it.startsWith("a") }
        .sortedBy { it }
        .map { it.uppercase() }
        .forEach { println(it) }


//    y = 12
//    print(y)
    printProduct("a", "b")
}

//string to int and nullable function
fun parseInt(str: String): Int? {
    return str.toIntOrNull()
}


fun printProduct(arg1: String, arg2: String) {
    val x = parseInt(arg1)
    val y = parseInt(arg2)

    // Using `x * y` yields error because they may hold nulls.
    if (x != null && y != null) {
        // x and y are automatically cast to non-nullable after null check
        println(x * y)
    } else {
        println("'$arg1' or '$arg2' is not a number")
    }
}

fun sum(a: Int, b: Int): Int {
    return a + b
}

fun printSum(a: Int, b: Int) {
    println("sum of $a and $b is ${a + b}")
}


fun maxOf(a: Int, b: Int): Int {
    if (a > b) {
        return a
    } else {
        return b
    }
}

fun getStringLength(obj: Any): Int? {
    if (obj !is String)
        return null
    return obj.length
}

Advanced

엘비스 연산자

?: (엘비스 연산자)의 동작 방식:
왼쪽의 값이 null이 아니면 그 값을 반환하고,
만약 왼쪽 값이 null이면 오른쪽의 값을 반환하거나, 오른쪽에 특정 연산(예: 예외 던지기)을 수행합니다.

1 2	val value: String? = null val result = value ?: "default value"

인라인 (inline)

인라인 함수(inline function)는 함수 호출 오버헤드를 줄이기 위한 최적화 기법입니다. 함수가 호출될 때, 보통은 호출된 함수로 제어가 이동하고, 함수가 끝난 후 다시 호출 지점으로 돌아가는 과정이 필요합니다. 이 과정은 특히 작은 함수일 때도 오버헤드가 발생할 수 있습니다.

인라인 함수는 이 문제를 해결하기 위해 함수 호출을 제거하고, 함수의 본문을 호출한 곳에 직접 복사하는 방식으로 처리합니다. 이를 통해 성능을 최적화할 수 있습니다.

Kotlin에서는 inline 키워드를 사용하여 인라인 함수를 정의할 수 있습니다. 인라인 함수는 특히 람다를 인자로 받는 고차 함수에서 성능 최적화 효과가 큽니다.

인라인 함수의 특징

함수 호출 오버헤드 제거: 호출된 함수로 제어가 이동하지 않고, 코드가 호출된 곳에 복사되므로 성능이 향상됩니다.
람다식의 성능 최적화: 인라인 함수에 전달되는 람다식은 객체로 변환되지 않고 인라인 처리됩니다.
재귀 함수는 인라인 불가능: 재귀 함수는 반복적으로 자기 자신을 호출하므로 인라인으로 변환할 수 없습니다.

예시

inline fun <reified T, ID> CrudRepository<T, ID>.findByIdOrThrow(id: ID, message: String = "해당 ID의 데이터가 존재하지 않습니다."): T = findByIdOrNull(id) ?: throw NoSuchElementException(message)

inline fun runIfTrue(condition: Boolean, block: () -> Unit) {
    if (condition) {
        block()  // block()은 여기서 호출되기 전에 인라인 처리됨
    }
}

fun main() {
    runIfTrue(true) {
        println("Condition is true!")
    }
}

companion object

java static 객체라고 생각하면됨.
클래스에 정의된 static class

class SignUtils(private val signService: SignService) {
  companion object {
        fun numberOperation(message:String,a:Int, b:Int, operation: (Int, Int)->Int):Int {
        println(message)
        return operation(a, b)
    }
    }

호출시 다음과같이 가능

1	SignUtils.numberOperation("실행쌉가능", 1,2,{x,y->x*y+x})

Next Post

SpringSecurity + jwt를 이용한 인증, 인가
Previous Post

Spring Transactional에 대한 5가지 옵션

CATALOG

1. 코틀린 기본 문법
2. Advanced



缺失模块。
1、请确保node版本大于6.2
2、在博客根目录（注意不是archer根目录）执行以下命令：
npm i hexo-generator-json-content --save
3、在根目录_config.yml里添加配置：

jsonContent:
  meta: false
  pages: false
  posts:
    title: true
    date: true
    path: true
    text: false
    raw: false
    content: false
    slug: false
    updated: false
    comments: false
    link: false
    permalink: false
    excerpt: false
    categories: true
    tags: true