본문 바로가기
Kotlin

Kotlin #3 : 기본 연산자, 비트 연산자, 변수와 함수, 반복문, 조건문, 람다식 230213

by haheehee 2023. 2. 15.

++ 기본 연산자 ++

- 산술, 대입, 증가, 감소, 비교, 논리 연산자...

 

- 산술 연산자

operator description example
+ 덧셈 1+2
- 뺄셈 2-1
* 곱셈 3*5
/ 나눗셈 10/3
% 나머지(Modulus) 10%3

 

- 대입 연산자

operator description example
= 오른쪽 항의 내용을 왼쪽 항에 대입 num = 2
+= 두 항을 더한 후 왼쪽 항에 대입 num += 2
-= 왼쪽 항을 오른쪽 항으로 뺀 후 왼쪽 항에 대입 num -=2
*= 두 항을 곱한 후 왼쪽 항에 대입 num *=2
/= 왼쪽 항을 오른쪽 항으로 나눈 후 왼쪽 항에 대입 num /= 2
%= 왼쪽 항을 오른쪽 항으로 나머지 연산 후 왼쪽 항에 대입 num %= 2

 

- 증감 연산자

operator description example
++ 항의 값에 1 증가 ++num 혹은 num++
-- 항의 값에 1 감소 --num 혹은 num--

 

- 비교 연산자

operator description
> 왼쪽이 크면 true, 작으면 false 반환
< 왼쪽이 작으면 true, 크면 false 반환
>= 왼쪽이 크거나 같으면 true, 아니면 false
<= 왼쪽이 작거나 같으면 true, 아니면 false
== 두 개 항의 값이 같으면 true, 아니면 false
!= 두 개 항의 값이 다르면 true, 아니면 false
=== 두 개 항의 참조가 같으면 true, 아니면 false
!== 두 개 항의 참조가 다르면 true, 아니면 false

** 이항연산자에서 왼쪽이 기준 (사실 상으로는 description열으로 이해해서 사용하면 안된다.)

** 참조나 값들 중에 ...~~

 

- 논리 연산자

operator description example
&& 논리곱으로 두 항이 모두 true일 때 true, 아니면 false exp1 && exp2
|| 논리합으로 두 항 중 하나의 항이 true일 때 true, 아니면 false exp1 || exp2
! 부정 단항 연산자로 true를 false로, false를 true로 바꿈 !exp 
package com.example.p30

fun main() {
    var num1 = 10
    var num2 = 10
    val result1 = ++num1
    val result2 = num2++

    println("result1: $result1")
    println("result2: $result2")
    println("num1: $num1")
    println("num2: $num2")
}

 

package com.example.p34

fun main() {
    var check = (5>3) && (5>2)
    println(check)
    check = (5>3) || (2>5)
    println(check)
    check = !(5>3)
    println(check)
}

 

++ 비트 연산자 ++

- 가장 왼쪽에 있는 비트는 양(+), 음(-)을 판단하는 데 사용

- shift 연산자

- 속도를 보완하기 위하여 사용

 

표현식 설명
4.shl(bits) 4를 표현하는 비트를 bits만큼 왼쪽으로 이동(부호 있음)
7.shr(bits) 7을 표현하는 비트를 bits만큼 오른쪽으로 이동(부호 있음)
12.ushr(bits) 12를 표현하는 비트를 bits만큼 오른쪽 이동(부호 없음)
9.and(bits) 9를 표현하는 비트와 bits를 표현하는 비트로 논리곱 연산
4.or(bits) 4를 표현하는 비트와 bits를 표현하는 비트로 논리합 연산
24.xor(bits) 23를 표현하는 비트와 bits를 표현하는 비트의 배타적 연산
78.inv( ) 78을 표현하는 비트를 모두 뒤집음

 

++ 함수 ++

fun 함수 이름([변수 이름: 자료형, 변수 이름: 자료형..]): [반환값의 자료형] { 
	표현식...
	[return 반환값] 
}

- 함수를 선언하려면 fun이라는 키워드를 이용

- 반환 타입을 선언할 수 있으며 생략하면 자동으로 Unit 타입이 적용

- 함수의 매개변수에는 var나 val 키워드를 사용할 수 없으며 val이 자동으로 적용 

 

**  반환형이 따로 명시되어있지 아니면 Unit이 디폴트 반환형.. (void)

** 매개변수는 형이 따로 명시되어 있지 않으면, 상수가 디폴트

 

// 일반적인 함수의 모습
fun sum(a: Int, b: Int): Int {
	return a + b
}

// 간략화된 함수
fun sum(a: Int, b: Int): Int = a + b


// 반환 자료형 생략
fun sum(a: Int, b: Int) = a + b

** Any : 모든 타입 가능
** Unit : 반환문이 없는 함수

 

- 함수일 때 정의문인지 파악하기..(fun 예약어로)

package com.example.p38

fun main() {
    var x = 4
    var y = 0b0000_1010 // 10진수 10
    var z = 0x0F    // 10진수 15

    println("x shl 2 -> ${x shl 2}")    // 16
    println("x.inv -> ${x.inv()}")  // -5

    println("y shr 2 -> ${y/4}, ${y shr 2}") // 2, 2
    println("x shl 4 -> ${x*16}, ${x shl 4}")   // 64, 64
    println("z shl 4 -> ${z*16}, ${z shl 4}")   // 240, 240

    x = 64
    println("x shr 4 -> ${x/4}, ${x shr 2}")    // 16, 16
}

비트연산자 예제

 

package com.example.p41

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

fun main() {
    val result1 = sum(3, 2)
    val result2 = sum(6, 7)

    println(result1)
    println(result2)
}

함수선언(기본형) 예제

 

 

package com.example.p42

fun main() {
    val num1 = 10
    val num2 = 3
    val result: Int
    result = max(num1, num2)
    println(result)
}

fun max(a: Int, b: Int) = if(a>b) a else b // a와 b는 max의 임시 변수

2차 간략화 함수 선언 예제

 

package com.example.p45

fun main() {
    val name="홍길동"
    val email="hong@email.com"

    add(name)
    add(name, email)
    add("둘리", "dooly@email.com")
    defaultArgs()
    defaultArgs(200)
}

fun add(name: String, email: String="default") {
    val output = "${name}님의 email은 ${email}입니다."
    println(output)
}

fun defaultArgs(x: Int=100, y: Int=200) {
    println(x + y)
}

매개변수의 기본값 예제

 

package com.example.p47

fun main(arg: Array<String>) {
    namedParam(x=200, z=100) // x, z의 이름과 함께 함수 호출(y는 기본값 사용)
    namedParam(z=150) // z의 이름과 함께 함수 호출(x, y는 기본값 사용)
}

fun namedParam(x: Int=100, y: Int=200, z: Int) {
    println(x + y + z)
}

매개변수 기본값 사용 예제

 

++ 컬렉션 타입 (Collection Type) ++

- Array : 배열 표현

- 배열은 Array 클래스로 표현

- 배열의 데이터에 접근할 때는 대괄호([])를 이용해도 되고 set()이나 get() 함수를 이용

   set(인덱스, 값) : 배열에서 인덱스번째 데이터를 값으로 설정

   get(인덱스) : 인덱스번째 데이터 가져오기

 

기초 타입의 배열

- 기초 타입이라면 Array를 사용하지 않고

  •    BooleanArray
  •    ByteArray
  •    CharArray
  •    DoubleArray
  •    FloatArray
  •    IntArray
  •    LongArray
  •    ShortArray 

  위의 클래스를 이용할 수 있음

 

- arrayOf()라는 함수를 이용하면 배열을 선언할 때 값을 할당할 수 있음

- 기초 타입을 대상으로 하는

  •    booleanArrayOf()
  •    byteArrayOf()
  •    char ArrayOf()
  •    doubleArrayOf()
  •    floatArrayOf()
  •    intArrayOf()
  •    longArrayOf()
  •    shortArrayOf()

   함수를 제공

package com.example.p48

fun main(args: Array<String>) {
    normalVarargs(1, 2, 3, 4) // 4개의 인자 구성
    normalVarargs(4, 5, 6) // 3개의 인자 구성
}

fun normalVarargs(vararg counts: Int) {
    for(num in counts) {
        println("$num")
    }
    print("\n")
}

가변적인 매개변수 받기 예제

 

package com.example.p49

fun main() {
    val data1: Array<Int> = Array(3, {0})
    data1[0] = 10
    data1[1] = 20
    data1.set(2, 30)

    println(
        """
        array size : ${data1.size}
        array data : ${data1[0]}, ${data1[1]}, ${data1.get(2)}
        """
    )
}

컬렉션 타입 예제

배열의 데이터 접근 : 대괄호 사용 혹은 set(), get()사용

 

package com.example.p51

fun main() {
    val data1 = arrayOf<Int>(10, 20, 30)
    println(
        """
            array size : ${data1.size}
            array data : ${data1[0]}, ${data1[1]}, ${data1.get(2)}
        """
    )
}

배열 선언과 동시에 값 할당 예제

 

++ List ++

- List: 순서가 있는 데이터 집합으로 데이터의 중복을 허용

 

++ Set ++

- Set: 순서가 없으며 데이터의 중복을 허용하지 않음

 

++ Map ++

- Map: 키와 값으로 이루어진 데이터 집합으로 순서가 없으며 키의 중복은 허용하지 않음

 

++ Collection 타입의 클래스 ++

1. 가변 클래스 : 가변 클래스는 초깃값을 대입한 이후에도 데이터를 추가하거나 변경 가능

2. 불변 클래스 : 불변 클래스는 초기에 데이터를 대입하면 더 이상 변경할 수 없는 타입

 

구분 Type function 특징
List List listOf() 불변
MutableList mutableListOf() 가변
Set Set setOf() 불변
MutableSet mutableSetOf() 가변
Map Map mapOf() 불변
MutableMap mutableMapOf() 가변

- Map 객체는 키와 값으로 이루어진 데이터의 집합

- Map 객체의 키와 값 ->

   1. Pair 객체를 이용

   2. ‘키 to 값’ 형태로 이용

 

package com.example.p53

fun main() {
    var list = listOf<Int>(10, 20, 30)
    println(
        """
            list size : ${list.size}
            list data : ${list[0]}, ${list.get(1)}, ${list.get(2)}
        """
    )
}

리스트 예제

 

package com.example.p53

fun main() {
    var mutableList = mutableListOf<Int>(10, 20, 30)
    mutableList.add(3, 40)
    mutableList.set(0, 50)
    println(
        """
            list size: ${mutableList.size}
            list data : ${mutableList[0]}, ${mutableList.get(1)}, ${mutableList.get(2)}, ${mutableList.get(3)}
        """
    )
}

가변 리스트 사용 예제

 

package com.example.p54

fun main() {
    var map = mapOf<String, String>(Pair("one", "hello"), "two" to "world")
    println(
        """
            map size : ${map.size}
            map data : ${map.get("one")}, ${map.get("two")}
        """
    )
}

집합 사용 예제

 

++ 표준 입력 함수 ++

readLine()

- val score = readLine()!!.toDouble() 이런식으로 사용 // 콘솔로부터 입력 받음

 

++ 비교 연산자와 논리 연산자의 복합 ++

...} else if (score >= 80.0 && score <= 89.9) {...

비교 연산자(>=, <=)와 논리곱 연산자(&&)가 사용

 

++ 범위(range) 연산자 ++

변수명 in 시작값..마지막값

score in 80..89이면 score 범위에 80부터 89까지 포함

package com.example.p57

fun main() {
    val a = 12
    val b = 7
    
    // 블록과 함께 사용
    val max = if(a>b) {
        println("a 선택")
        a   // 마지막 식인 a가 반환되어 max에 할당
    } else {
        println("b 선택")
        b   // 마지막 식인 b가 반환되어 max에 할당
    }
    
    println(max)
}

조건식 표현식 사용 예제

 

package com.example.p59

fun main() {
    print("Enter the score: ")
    val score = readLine()!!.toDouble() // 콘솔로부터 입력받음
    var grade: Char = 'F'

    if(score >= 90.0) {
        grade = 'A'
    } else if(score>=80.0 && score<=89.9) {
        grade = 'B'
    } else if(score>=70.0 && score<=79.9) {
        grade = 'C'
    }
    println("Score : $score, Grade : $grade")
}

else if 사용 예제

시험 출제!!

85를 입력해보았다. 결과 => Grade : B

 

 

package com.example.p62

fun main() {
    print("Enter the score: ")
    val score = readLine()!!.toDouble() // 콘솔로부터 입력받음
    var grade: Char = 'F'

    if(score >= 90.0) {
        grade = 'A'
    } else if(score in 80.0..89.9) {
        grade = 'B'
    } else if(score in 70.0..79.9) {
        grade = 'C'
    }
    println("Score : $score, Grade : $grade")
}

in 연산자 사용 예제 (범위 연산자 예제)

76을 입력 결과 => Grade : C

 

package com.example.p62

fun main() {
    var data = 10
    if(data > 0) {
        println("data > 0")
    } else {
        println("data <= 0")
    }
}

if-else 예제

 

package com.example.p62

fun main() {
    var data = 10
    if(data > 10) {
        println("data > 10")
    } else if(data >0 && data <= 10) {
        println("data > 0 && data <= 10")
    } else {
        println("data <= 0")
    }
}

다중 if-else 예제

 

package com.example.p63

fun main() {
    var data = 10
    val result = if(data > 0) {
        println("data > 0")
        true
    } else {
        println("data <= 0")
        false
    }
    println(result)
}

if-else 표현식 예제

여기서 표현식 : 결과값을 반환하는 계산식

 

++ when문 ++

when (인자) {
	인자에 일치하는 값 혹은 표현식 -> 수행할 문장
	인자에 일치하는 범위 -> 수행할 문장
	...
	else -> 문장
}

 

- 인자가 없는 when    => 특정 인자에 제한하지 않고 다양한 조건을 구성

when {
	조건[혹은 표현식] -> 실행문
	...
}

 

** 매개변수는 생략하면, Any형이 기본

** 반환형은 생략하면, Unit형이 기본

 

- when 문의 조건으로 정수가 아닌 다른 타입의 데이터를 지정할 수 있음

- when 문에서는 조건을 데이터 타입, 범위 등으로 다양하게 명시 가능 

- is는 타입을 확인하는 연산자

- in은 범위 지정 연산자

- when은 표현식으로도 사용 가능 (if 문과 마찬가지)

package com.example.p65

fun main() {
    val x = readLine()!!.toInt() // 콘솔로부터 입력받음
    when(x) {
        1 -> print("x==1")
        2 -> print("x==2")
        else -> { // 블록 구문 사용 가능
            print("x는 1, 2가 아닙니다.")
        }
    }

    println()
    when(x) {
        0, 1 -> print("x==0 or x==1")
        else -> print("기타")
    }

    println()
    println()
    val s = readLine()!!.toString()
    println()
    when(x) {
        Integer.parseInt(s) -> print("일치함!")
        else -> print("기타")
    }
    
    println()
    when(x) {
        in 1..10 -> print("x는 1이상 10이하입니다.")
        !in 10..20 -> print("x는 10이상 20이하의 범위에 포함되지 않습니다.")
        else -> print("x는 어떤 범위에도 없습니다.")
    }

    println()
    val str = "안녕하세요."
    val result = when(str) {
        is String -> "문자열입니다."
        else -> false
    }
}

when문 예제

 

package com.example.p68_2

import java.lang.Integer.parseInt
import java.lang.NumberFormatException

fun main() {
    print("x변수 입력 : ")
    val x = readLine()!!.toInt()
    println()

    print("s변수 입력 : ")
    val s = readLine()!!.toString()
    println()

   try {
        when(x) {
            parseInt(s) -> print("일치함!")
            else -> print("기타")
        }
    } catch (e: NumberFormatException) {
        print("숫자가 아님")
    }
}

try-catch추가해서 문자열일 때 "숫자가 아님" 출력 예제

 

package com.example.p68

fun main() {
    print("Enter the score: ")
    val score = readLine()!!.toDouble()
    var grade: Char = 'F'

    when(score) {
        in 90.0..100.0 -> grade = 'A'
        in 80.0..89.9 -> grade = 'B'
        in 70.0..79.9 -> grade = 'C'
        !in 70.0..100.0 -> grade = 'F'
    }
    println("Score: $score, Grade: $grade")
}

when 예제 #2

 

package com.example.p71

fun main() {
    print("Enter the score : ")
    var score = readLine()!!.toDouble()
    var grade: Char = 'F'

    // 인수 없는 when의 사용
    when {
        score >= 90.0 -> grade = 'A' // 인자 있는 when 과 다르게 조건식을 구성할 수 있음
        score in 80.0..89.9 -> grade = 'B'
        score in 70.0..79.9 -> grade = 'C'
        score < 70.0 -> grade = 'F'
    }
    println("Score: $score, Grade: $grade")
}

인자가 없는 when 예제 #3

 

package com.example.p71_2

class MyClass

fun main() {
    cases("Hello")  // String
    cases(1)    // Int
    cases(System.currentTimeMillis())   // Long
    cases(MyClass())    // 객체
}

fun cases(obj: Any) {
    when(obj) {
        1 -> println("Int: $obj")
        "Hello" -> println("String: $obj")
        is Long -> println("Long: $obj")
        !is String -> println("Not a String")
        else -> println("Unknown")
    }
}

다양한 자료형의 인자 받기 예제

- 다양한 값을 인자로 받아 처리할 수 있다.

- 선택하는 것이기 때문에 처리속도가 빠르다.

 

package com.example.p72

fun main() {
    var data = "hello"
    when(data) {
        "hello" -> println("data is hello")
        "world" -> println("data is world")
        else -> {
            println("data is not valid data")
        }
    }
}

when 문의 조건으로 정수가 아닌 다른 타입의 데이터를 지정 가능

 

package com.example.p73

fun main() {
    var data: Any = 10
    when(data) {
        is String -> println("data is String") // data가 문자열 타입이면
        20, 30 -> println("data is 20 or 30")   // data 가 20 또는 30이면
        in 1..10 -> println("data is 1..10")    // data가 1~10의 값이면
        else -> println("data is not valid")
    }
}

when 문에서는 조건을 데이터 타입, 범위 등으로 다양하게 명시가능

 

package com.example.p74

fun main() {
    var data = 10
    val result = when {
        data <= 0 -> "data is <= 0"
        data > 100 -> "data is > 100"
        else -> "data is valid"
    }
    println(result)
}

when을 표현식으로 사용

 

++ for문 ++

- 코틀린에서는 자바와 같은 세미콜론 표현식을 사용하지 않음

for (요소 변수 in 컬렉션 혹은 범위) {
	반복할 본문 
}

- for 문은 제어 변숫값을 증감하면서 특정 조건이 참일 때까지 구문을 반복해서 실행

- or 문의 조건에는 주로 범위 연산자인 in을 사용

  • for (i in 1..10) { ... } → 1부터 10까지 1씩 증가
  • for (i in 1 until 10) { ... } → 1부터 9까지 1씩 증가(10은 미포함)
  • for (i in 2..10 step 2) { ... } → 2부터 10까지 2씩 증가
  • for (i in 10 downTo 1) { ... } → 10부터 1까지 1씩 감소
package com.example.p75

fun main() {
    for ( x in 1..5 ) {
        println(x)
    }

    for(x in 1..5) println(x)
}

for문 예제 #1

 

package com.example.p76

fun main() {
    var sum = 0
    for(i in 1..10) {
        sum += i
    }
    println(sum)

    println()
    for(i in 1..10) {
        if(i%2==0) {
            print("$i ~ ")
        }
    }
}

for문 예제 #2

 

package com.example.p77

fun main() {
    var sum1 = 0
    print("첫 번째")
    for(i in 1..10 step 2) {
        sum1 += i
        print("$i ~ ")
    }
    print(" 총 합 => $sum1")

    println()
    var sum2 = 0
    print("두 번째")
    for(i in 2..10 step 2) {
        sum2 += i
        print("$i ~ ")
    }
    print(" 총 합 => $sum2")

    println()
    var sum3 = 0
    print("세 번째")
    for(i in 9 downTo 1 step 2) {
        sum3 += i
        print("$i ~ ")
    }
    print(" 총 합 => $sum3")
}

for문사용 짝수, 홀수 출력, 홀수 내림차순 출력 예제

 

++ 조건문과 반복문 ++

- 컬렉션 타입의 데이터 개수만큼 반복

- indices는 컬렉션 타입의 인덱스값을 의미

- 인덱스와 실제 데이터를 함께 가져오려면 withIndex() 함수를 이용

 

while문

while (조건식) { // 조건식이 true인 동안 본문의 무한 반복
	본문
	....
}
package com.example.p78

fun main() {
    var data = arrayOf<Int>(10, 20, 30)
    for(i in data.indices) {
        print(data[i])
        if(i !== data.size -1) print(", ")
    }
}

반복 조건에 컬렉션 타입 활용

 

package com.example.p78

fun main() {
    var data = arrayOf<Int>(10, 20, 30)
    for((index, value) in data.withIndex()) {
        print(value)
        if(index !== data.size -1) print(", ")
    }
}

인덱스와 데이터를 가져오는 withIndex()함수

 

package com.example.p80

fun main() {
    print("Enter the lines: ") 
    val n = readLine()!!.toInt()    // 콘솔로부터 입력받음
    
    for(line in 1..n) {
        for(space in 1..(n-line)) print(" ") // 공백출력
        for(star in 1..(2*line-1)) print("*") // 별표출력
        println()   // 개행
    }
}

피라미드 출력하기 (줄 수는 입력받기) 예제

 

package com.example.p81

fun main() {
    var i = 1
    while(i<=5) {
        println("$i")
        ++i // 계속 반복하다 보면 조건식이 5이상으로 넘어갈 때 false가 되어 탈출
    }
}

while문 예제

 

package com.example.p82

fun main() {
    print("Enter the number: ")
    var number = readLine()!!.toInt()
    var factorial: Long = 1

    while(number > 0) { // nX...X4X3X2X1
        factorial *= number
        --number
    }
    println("Factorial: $factorial")
}

팩토리얼 (factorial) 예제

 

++ do~while문 ++

do {
	본문
} while (조건식)
package com.example.p83

fun main(args: Array<String>) {
    var x = 0
    var sum1 = 0
    while(x<10) {
        sum1 += ++x
    }
    println(sum1)
}

while문 예제

 

package com.example.p85

fun main() {
    do {
        print("Enter an integer: ")
        val input = readLine()!!.toInt()

        for(i in 0..(input-1)) {
            for(j in 0..(input-1)) {
                print((i+j) % input +1)
                println()
            }
        }
    } while(input != 0)
}

do-while문 예제

 

++ 흐름 제어 ++

- 흐름 제어문

  • return: 함수에서 결괏값을 반환하거나 지정된 라벨로 이동 (문의끝과 값전달에 쓰였음.
  • break: for나 while의 조건식에 상관없이 반복문을 끝냄
  • continue: for나 while의 반복문의 본문을 모두 수행하지 않고 다시 조건으로 넘어감

- 예외 처리문

  • try{...} catch{...} : try블록의 본문을 수행하는 도중 예외가 발생하면 catch 블록의 본문을 실행
  • try {...} catch {...} finally {...}: 예외가 발생해도 finally 블록 본문은 항상 실행

- return으로 Unit 반환하기

        1. Unit을 명시적으로 반환

fun hello(name: String): Unit {
	println(name)
	return Unit
}

        2. Unit 이름을 생략한 반환

fun hello(name: String): Unit {
	println(name)
	return
}

        3. return문 자체를 생략

fun hello(name: String) {
	println(name)
}

 

++ 람다식 ++

- 람다식에서 라벨 사용

람다식 함수명 라벨이름@ {
	...
	retrun@라벨이름
}
package com.example.p89

fun main() {
    retFunc()
}

inline fun inlineLambda(a: Int, b: Int, out: (Int, Int) -> Unit) {
    out(a, b)
}

fun retFunc() {
    println("start of retFunc")
    inlineLambda(13, 3) { a, b ->
        val result = a + b
        if(result > 10) return
        println("result: $result")
    }
    println("end of retFunc")
}

람다식에서 return 사용하기

13행의 코드를

inlineLambda(13, 3) { a, b ->

로 변경하면

 

 

package com.example.p90

fun main() {
    retFunc()
}

fun inlineLambda(a: Int, b: Int, out: (Int, Int) -> Unit) {
    out(a, b)
}

fun retFunc() {
    println("start of retFunc")
    inlineLambda(13, 3) lit@ { a, b ->
        val result = a + b
        if(result > 10) return@lit
        println("result: $result")
    }
    println("end of retFunc")
}

람다식에서 라벨 사용하기 예제

lit@ ~ @lit은 무조건 실행

 

package com.example.p91

fun main() {
    retFunc()
}

fun inlineLambda(a: Int, b: Int, out: (Int, Int) -> Unit) {
    out(a, b)
}

fun retFunc() {
    println("start of retFunc")
    inlineLambda(13, 3) { a, b ->
        val result = a + b
        if(result > 10) return@inlineLambda
        println("result: $result")
    }
    println("end of retFunc")
}

암묵적 라벨 (람다식에서)

inlineLambda(13, 3)의 inlineLambda가 라벨이 되는 것!

 

++ 익명 함수 ++

- 함수 명이 없는 것.

package com.example.p92

fun main() {
    com.example.p91.retFunc()
}

fun inlineLambda(a: Int, b: Int, out: (Int, Int) -> Unit) {
    out(a, b)
}
fun retFunc() {
    println("start of retFunc")
    inlineLambda(13, 3, fun(a, b) {
        val result = a + b
        if(result>10) return
        println("result: $result")
    })
    println("end of retFunc")
}

 

- 람다식 방법

...
	val getMessage = lambda@ { num: Int ->
	if(num !in 1..100) {
		return@lambda "Error" // 레이블을 통한 반환
	}
	"Sucess" // 마지막 식이 반환
	}
...

- 익명함수 방법

val getMessage = fun(num: Int): String {
	if(num !in 1..100) {
		return "Error" 
	}
	return "Success"
}
...
val result = getMessge(99)

 

for나 while, do...while문 루프를 빠져나옴

- break (문의 끝으로)

- continue (문의 시작으로)

package com.example.p95

fun main() {
    for(i in 1..5) {
        if(i==3) break
        print(i)
    }
    println()
    println("outside")
}

break 예제

==> break를 continue로 바꾸면?

package com.example.p95

fun main() {
    for(i in 1..5) {
        if(i==3) continue
        print(i)
    }
    println()
    println("outside")
}

continue 예제

package com.example.p96

fun main() {
    labelBreak()
}

fun labelBreak() {
    println("labelBreak")
    for(i in 1..5) {
        second@ for(j in 1..5) {
            if(j==3) break
            println("i: $i, j: $j")
        }
        println("after for j")
    }
    println("after for i")
}

라벨 없는  break 예제

 

package com.example.p97

fun main() {
    labelBreak2()
}

fun labelBreak2() {
    println("labelBreak")
    first@ for(i in 1..5) {
        second@ for(j in 1..5) {
            if(j==3) break@first
            println("i: $i, j: $j")
        }
        println("after for j")
    }
    println("after for i")
}

라벨 사용한  break 예제

 

package com.example.p96

fun main() {
    labelContinue()
}

fun labelContinue() {
    println("labelBreak")
    for(i in 1..5) {
        second@ for(j in 1..5) {
            if(j==3) continue
            println("i: $i, j: $j")
        }
        println("after for j")
    }
    println("after for i")
}

라벨 없는  continue 예제

 

package com.example.p97

fun main() {
    labelContinue2()
}

fun labelContinue2() {
    println("labelContinue")
    first@ for(i in 1..5) {
         second@ for(j in 1..5) {
            if(j==3) continue@first
            println("i: $i, j: $j")
        }
        println("after for j")
    }
    println("after for i")
}

라벨 사용한  continue 예제

 

저작자표시 비영리 변경금지

'Kotlin' 카테고리의 다른 글

Kotlin #6 : 상속과 클래스 230217  (0) 2023.02.20
Kotlin #5 : 객체지향 프로그래밍 230216  (0) 2023.02.17
Kotlin #4 : 예외처리 230216  (0) 2023.02.16
Kotlin #2 : 변수, 함수, null, 세이프콜, 엘비스 연산자, 스마트 캐스트 230213  (0) 2023.02.13
Kotlin #1 : 기본 설정, 기초문법 230210  (0) 2023.02.10

관련글

댓글

티스토리툴바