코틀린 - 반복문(for, while)

반복문은 for문과 while문이 있습니다.

간단하게 비교하자면 for문은 특정 횟수만큼 코드를 반복하기 위해서 사용하는 경우가 많고,

while문은 어느 조건이 달성될 때까지 수없이 반복하는 경우가 많습니다.

 

for문

var numbers = mutableListOf<Int>()

for(num in 1..10) {
    numbers.add(num)
}

Log.d("for문 결과", "${numbers}")		// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

num(변수)에 in 1(시작값)..10(종료값)이 가장 기본적인 코틀린 for문의 문법입니다.

시작값이 1이였으니까 numbers 리스트에서 인덱스0 자리에 1이 할당된 것을 볼 수 있습니다.

종료값이 10이였으니까 numbers 리스트에 1부터 10까지 할당이 된 결과를 볼 수 있습니다.

 

var numbers = mutableListOf<Int>()

for(num in 1 until 10) {
    numbers.add(num)
}

Log.d("for문 결과", "${numbers}")

위 코드의 결과는 어떻게 되었을까요???

어찌보면 첫번째 for 코드와 비슷해보이죠.

num in 1..10 이라는 조건이 num in 1 until 10 이라고 되어있으니, 그저 유식하게 영어를 쓴 게 아닐까?라는 의문이 듭니다.

왜냐하면 until이 ~까지라는 의미니까!

신기하게도 결과는 다릅니다.

첫번째 for 코드는 [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]이였다면 두번째 until 코드는 [1, 2, 3, 4, 5, 6, 7, 8, 9]라는 결과가 나옵니다.

즉, until을 사용하면 마지막 종료값 이전까지만 반복이 됩니다.

 

var numbers = mutableListOf<Int>()

for(num in 1..10 step 3) {
    numbers.add(num)
}

Log.d("for문 결과", "${numbers}")		// [1, 4, 7, 10]

위 코드의 결과는 적어놨습니다.

느낌이 오시나요???

시작값은 1, 종료값은 10이다. 그래서 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 전부 반복합니다.

근데 리스트의 값을 보면 1, 4, 7, 10이 들어있습니다.

바로 step은 3번째 값만 실행한다는 의미를 말합니다. 즉, 두번 건너뛰어서 할당합니다.

for문이 처음 돌아가니까 1이 할당이 되고 2, 3 빼고 세번째인 4값, 5, 6 뺴고 7값, 8, 9 빼고 10값을 할당 됐습니다.

num in 1..10 step 4으로 반복문을 돌리면 결과는 어떻게 될까요??

 

바로 [1, 5, 9]가 된다. 3번 건너뛰게 되니 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 가 됩니다.

 

util을 사용해서 num in 1 until 10 step 3으로 반복문을 돌리면 결과는 어찌 될까요?

당연히 [1, 4, 7]가 된다. util은 마지막 종료값 이전까지만 실행을 합니다.

 

var numbers = mutableListOf<Int>()

for(num in 10 downTo 1) {
    numbers.add(num)
}

Log.d("for문 결과", "${numbers}")		// [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

downTo 를 사용하면 숫자를 거꾸로 감소시킬 수 있다. step도 사용이 될까요? 됩니다.

 

var numbers = mutableListOf<Int>()

for(num in 10 downTo 1 step 3) {
    numbers.add(num)
}

Log.d("for문 결과", "${numbers}")		// [10, 7, 4, 1]

아까 결과값에 역순이 되었습니다.

그럼 until은?? 아쉽게도 downTo와 until은 사용할 수 없습니다.

 

var numbers = mutableListOf<Int>()
val num = 5

for(i in num downTo 1) {
    numbers.add(i)
}

Log.d("for문 결과", "${numbers}")

이번에는 변수에 정수값을 넣고 조건에 넣으면 어떻게 될까요??

조건은 5 downTo 1로 [5, 4, 3, 2, 1]이 들어갑니다.

 

var numbers = mutableListOf<Int>(1, 2, 3)

for((index, value) in numbers.withIndex()) {
    print("$value")
    if(index !== numbers.size-1) print(", ")	// 1, 2, 3 출력됨
}

withIndex함수를 사용해서 배열의 인덱스를 사용할 수 있습니다.

따로 인덱스를 출력할 수 있죠

var numbers = mutableListOf<Int>(1, 2, 3, 4, 5)

for(i in numbers.indices) {
    println("$i")	// 0부터 4까지 줄바뀜으로 출력됨
}

이번엔 indices키워드를 통해서 배열의 인덱스를 범위로 지정할 수 있습니다.

 

 

for문 두 명의 친구가 있습니다. break와 continue

 

for문의 break와 continue로 for문 제어하기

for(num in 1..10) {
    if(num == 7) {
        Log.d("break", "행운의 숫자!! ${num}")	// 1번 출력
        break
    } else Log.d("for문", "음... 행운의 숫자가 안 나왔어요.")	// 6번 출력
}

결과가 이상하지 않은가요???

분명히 시작값 1, 종료값 10인데... 총 7번만 출력이 되었습니다.

break 때문이죠. 이유를 세세히 보시죠.

반복문이 처음 돌면 num은 1이 됩니다.

조건문에 num이 1이니, 7과 같지 않아서 else가 출력이 됩니다.

다시 반복문으로 가면 이번엔 num이 2가 됩니다.

조건문에 num이 2이니, 아까와 동일하게 7과 같지 않아 else가 출력됩니다.

이젠 7번째 반복문을 봅시다.

num이 7이 되었다. 조건문을 보니 num이 7과 동일합니다.

조건문 안에 "행운의 숫자!! 7"이 출력됩니다.

그리고 break를 만났습니다.

바로 반복문이 종료가 됩니다.

 

이해가 되었나요??

 

break를 만나면 반복문의 횟수가 더 있다고 해도 반복문을 빠져나옵니다.

멈쳐! 그만! 이라고 말해주는 친구라고 생각하면 되겠네요.

 

for(num in 1..10) {
    if(num < 7) {
        continue
    }
    Log.d("continue", "지금 숫자는 ${num}")
}

4번 실행이 된다. 로그에 숫자는 7, 8, 9, 10이 출력 됩니다.

그 이유는 간단하죠.

컨티뉴가 있으면 컨티뉴 아래는 실행하지 않고 반복문으로 돌아갑니다.

그래서 첫번째 반복문이 조건문을 보니 true다. 그래서 조건문에 들어가니 컨티뉴가 "올라가~~"하며 내쫒습니다.

할 수 없이 올라가니 num은 2가 되고 또 조건문이 true라서 조건문을 들어가니 컨티뉴가 "올라가~~"합니다.

그래서 6번째까지 내쫒고 7번째부터 조건문이 7 < 7이라서 false가 되어 컨티뉴를 안 만납니다.

정상적으로 로그가 출력됩니다.

 

그래서 컨티뉴는 길을 막아서는 하는 친구라고 생각하면 되겠죠?

 

while문

var numbers = mutableListOf<Int>()
var count = 1

while(count < 10) {
    numbers.add(count)
    count += 1
}

Log.d("while문 결과", "${numbers}")		// [1, 2, 3, 4, 5, 6, 7, 8, 9]

for문보다 조금 단순하지 않은가요?

아까도 말했지만 조건이 false가 될 때까지 수없이 반복합니다. 그게 무슨 소리냐구요??

 

while(조건) {
	// 실행코드
}

while문의 문법입니다. 조건이란 부분이 true이여야 실행코드가 실행합니다.

만일 조건이 false로 바뀌면? 당연히 while문은 종료가 되어버립니다.

그래서 while문에 위험성이 여기에 있습니다.

 

자 아래의 코드를 보시죠.

var num = 1

while(num == 1) {
    Log.d("while문 결과", "${num}")
}

어떤 생각이 드시나요???

'아무런 문제가 없다'는 생각이 들지 않나요?

 

만일 위 코드를 실행하게 된다면 무한히 1의 값을 Log에서 찍고 있을 겁니다.

"무한히"... 그렇습니다 일명 무한루프에 빠지게 되는 것이죠.

이유는 조건부분이 계속 true이고 이 조건을 false로 바꿀 요소가 없습니다.

 

무한 루프에 빠지지 않으려면 아래와 같이 바꾸면 됩니다.

var num = 1

while(num == 1) {
    Log.d("while문 결과", "${num}")
    num += 1
}

그러면 한번만 실행이 되고 반복문이 종료 될 것입니다.

 

궁금증이 하나 생기지 않는가요??

아까 필자는 조건부분이 true면 반복문이 실행이 된다고 했습니다.

그럼 조건을 true로 할당하면 반복문이 실행이 될까요? 당연히 됩니다.

 

var boolean = true
var count = 1

while(boolean) {
    println("${num}")
    num += 1
    if(count == 9) boolean = false
}

위와 같이 코드를 실행하면 8번 작동하는 것을 할 수 있습니다.

여기서도 왜 9번이 아니고 8번이냐고 물을 수 있는데..

처음 반복문이 실행할때 num의 값이 1이다. 한번 끝날 때마다 num은 1씩 증가를 합니다.

그러면 8번째 반복문 실행을 보시죠.

맨 처음에 있는 Log.d를 출력할 것입니다. "while문 결과": 8 이라고

그 다음에 num += 1를 수행하게 되겠죠. 이번 코드에서 num은 9가 됩니다.

그 다음 수행하려고 보니까 num이 마침 9가 되어있죠. 조건문에 true가 되어서 조건문을 실행합니다.

조건문을 보니까 boolean 변수에 false를 할당하라고 합니다. boolean 변수는 false이 되었습니다.

다시 반복문을 실행하려고 했더니 조건이 false로 바뀌었네요. 반복문은 실행하지 않고 종료됩니다.

 

while문은 친구가 한명 있습니다. do라는 친구죠.

 

do while문

var product = 1
val stock = 5
do {
    Log.d("do while문 결과", "제품이 팔렸습니다. 남은 재고는 ${stock - product}개 입니다.")
    product += 1
} while (product < stock)

위 코드는 while문과 동일한 역할을 합니다.

하지만 while문을 do와 같이 사용하면 조건식에 상관없이 한번은 무조건 실행이 됩니다.

이게 무슨 말이냐구요??

 

var product = 6
val stock = 5

while (product < stock) {
    Log.d("while문 결과", "제품이 팔렸습니다. 남은 재고는 ${stock - product}개 입니다.")
    product += 1
}

위 코드를 한번 보시죠.

while문이 실행이 될까요??

조건에 6 < 5가 되어있어서 반복문을 실행하기 전에 false가 되어서 반복문이 실행되질 않습니다.

 

var product = 6
val stock = 5

do {
    Log.d("do while문 결과", "제품이 팔렸습니다. 남은 재고는 ${stock - product}개 입니다.")
    product += 1
} while (product < stock)

그럼 위 코드는 어떨까요?? 당연히 실행됩니다.

결과값은 "do while문 결과: 제품이 팔렸습니다. 남은 재고는 -1개 입니다."라고 나옵니다.

do가 있으면 한번은 무조건 실행이 된다고 생각하시면 됩니다.

 

 

그럼 이만~!!