1.  while 문

int i=1; // 초기화
while (조건식) {
    // 조건식이 연산결과가 참인 동안, 반복될 문장들을 적는다.
    System.out.println(i);
    i++; // 증감식
}

💡  먼저 조건식을 평가해서 조건식이 거짓이면 문장 전체를 벗어나고, 참이면 블럭 {} 내의 문장을 수행하고 다시 조건식으로 돌아간다.

        ➡️  조건식이 거짓이 될 때까지 이 과정이 계속 반복

💡 조건식에는 비교 또는 논리 연산식이 주로 옴

💡  for문과 while문은 항상 서로 변환이 가능. 단, for문과 달리 조건식 생략 불가!

public class MyWhile_02 {

	public static void main(String[] args) {
		/* for문을 while문으로 변경 */
		
		int num;
		int sum = 0;
		
		for (num=1; num <= 10; num++) {
			sum += num;
		}
		System.out.println("1부터 10까지의 합은 " + sum + "입니다.");
		
		// While문도 초기값, 조건식, 증감식이 존재.
		num = 1;
		sum = 0;
		while(num <= 10) {
			sum += num;
			num++;
		}
	    System.out.println("1부터 10까지의 합은 " + sum + "입니다.");

	}

}

 

 중첩 while문
public class MyWhile_11 {

	public static void main(String[] args) {
		/* 중첩 while, 구구단 출력 */
		int i = 2;
		while(i <= 9) {
			System.out.println("*** " + i + "단 ***");
			int j = 1;
			while(j <= 9) {
				System.out.println(i +" * "+j+" = " + i*j);
				j++;
			}
			System.out.println();
			i++;
		} // end of while(i<=9)

	}
}
 
 
응용 문제
public class Exam022 {

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		String answer = "Y"; // while이 시작될 수 있도록 응답 값을 초기화.
		int count = 0;
		
		while (answer.equals("Y")|| answer.equals("y")) {
			System.out.println("음악을 재생하시겠습니까?(Y or y)");
			answer = scanner.nextLine(); // 사용자의 응답을 받습니다.
		    answer = answer.toUpperCase(); // 입력받은 문자열을 대문자로 변경.
			
			if (answer.equals("Y") || answer.equals("y")) {
				count++;
				System.out.println("음악을 "+count+"번 재생했습니다.");
				
			}		    
		}
	    System.out.println("재생종료");
	    scanner.close();
	}
}
 

 


2.  do-while 문

💡  while문의 변형으로 기본적인 구조는 while문과 같으나 조건식과 블럭{}의 순서를 바꿔놓은 것

       ➡️  블럭{}을 먼저 수행한 후에 조건식을 평가

       ➡️  while문은 조건식의 결과에 따라 블럭{}이 한 번도 수행되지 않을 수 있지만, do-while문은 최소한 한번은 수행될 것을 보장한다.

💡  실무에서 잘 사용하지는 않음

do {
  // 조건식의 연산결과가 참일 때 수행될 문장들을 적는다.
} while (조건식);
public class Exam023 {

	public static void main(String[] args) {
		/* do~while문은 조건이 거짓이라도 적어도 한번은 문장이 출력된다. */
		int num = 100;
		do {
			System.out.println("적어도 한번은 출력되는 문장");
		} while(num < 10);

	}
}
 
 
 
응용 문제
public class Ex_03_dowhile_01 {

	public static void main(String[] args) {
		/* do while 문을 사용해서 사용자로 부터 월의 번호를 입력받는 프로그램을 작성해 보세요.
		 * 사용자가 올바른 월 번호를 입력할 때 까지 반복을 계속합니다.
		 * 사용자가 올바른 월 번호를 입력해야만 다음 문장으로 넘어갑니다. */
		Scanner scanner = new Scanner(System.in);
		int month;
		
		do {
			System.out.print("올바른 월을 입력하세요 [1-12] ");
		    month = scanner.nextInt();
		} while (month < 1 || month > 12);
		
        System.out.println("사용자가 입력한 월은 " + month + "입니다.");
		scanner.close();

	}
}
 

📄   Random random = new Random();

  -  Random 클래스의 인스턴스를 생성하여 random이라는 변수에 저장하는 코드

  -  Random : Java에서 무작위 숫자를 생성하기 위한 클래스로, java.util 패키지에 포함되어 있다. 이 클래스는 난수를 생성하는 다양한 메서드를 제공함.

​ random() 메소드는 0.0과 1.0 사이의 double 타입 난수를 리턴

⚡️  0.0 <= Math.random() < 1.0

💡  start 부터 시작하는 n개의 정수 중에서 하나의 정수를 얻기 위한 코드
      int num = (int) (Math.random() * n) + start;

 

public class Ex_03_while_01_pr {

	public static void main(String[] args) {
		/* while 문과 Random.nextInt() 메소드를 이용해서 2개의 주사위를 던졌을 때 나오는 눈을 (눈1,눈2)
		 * 형태로 출력하고, 눈의 합이 5가 되는 조합은 (1,4) (4,1) (2,3) (3,2) 입니다.
		 * 예) (5,1)
		 * (4,4)
		 * (6,5)
		 * (5,2)
		 * (3,6)
		 * (1,2)
		 * (2,3)
		 */
		
		Random random = new Random();
		
		while(true) {
			int num1 = random.nextInt(6) + 1; 
			int num2 = random.nextInt(6) + 1;
			System.out.println("(" + num1 + ", " + num2 + ")");
		
			if ((num1+num2) == 5) {
				break;
			}
		}
	}
}

 

 

응용 문제
public class Ex_03_while_02 {

	public static void main(String[] args) {
		/* 컴퓨터가 주사위를 던지면 사용자가 주사위의 숫자를 맞히는 프로그램을 완성하세요.
		   사용자가 맞힐 때까지 게임은 계속 됩니다. 
		   예) 
		   주사위 값은 얼마일까요? >>> 5 
		   오답입니다. 다시 시도하세요. 
		   주사위 값은 얼마일까요? >>> 1
		   1! 정답입니다. 
		   
		   1) break를 사용
		   2) break를 사용안하는 경우 */
		Scanner scanner = new Scanner(System.in);
		Random random = new Random();
		
		
		int answer = random.nextInt(6) + 1;
		// System.out.println(answer);
		
		while(true) {
        
			System.out.print("주사위 값은 얼마일까요? >>> ");
			int num  = scanner.nextInt();
			
			if (answer == num) {
				break;
			}
			
            System.out.println("오답입니다. 다시 시도하세요.");
		}
        
	    System.out.println(answer + "! 정답입니다.");
	    scanner.close();
	}
		
}
 
 
 

3.  break 문

💡 자신이 포함된 가장 가까운 반복문을 벗어난다. 주로 if문과 함께 사용되어 특정 조건을 만족하면 반복문을 벗어나도록 한다.

public class Exam024 {

	public static void main(String[] args) {
		/* 반복문을 빠져나오는 방법은 1) 조건식이 false가 되거나 2) break문이 실행.
		 * break문은 반복을 멈추게 함.
		 * 반복문이 진행되다가 break문을 만나면 곧 바로 반복문을 벗어나서 반복문 다음의 코드를 수행. */
		Scanner scanner = new Scanner(System.in);
		int sum = 0;
		int num;
		
		while(true) {
			System.out.println("더할 숫자를 입력하세요:(종료하려면 0입력)");
			num = scanner.nextInt(); //정수 입력받아서 num에 저장
            
			if (num == 0) { // 만약 0을 입력하였다면 종료.
				break;
			}
            
			sum += num; //입력받은 값 더해주기.
		}
		System.out.println("현재까지의 총합 = " + sum);
        scanner.close();
	}
}

 

 


 

4.  continue 문

💡 반복문 내에서만 사용될 수 있으며, 반복이 진행되는 도중에 continue문을 만나면 반복문의 끝으로 이동하여 다음 반복으로 넘어간다.

 

  🔅  break 문  ➡️  반복을 종료, 실행 후 코드 아래의 반복문 코드는 실행되지 않음

  🔅  continue 문  ➡️  다음 반복으로 이동, 실행 후 코드 아래의 반복문 코드는 실행되지 않음

 

public class MyContinue_01 {

	public static void main(String[] args) {
		/* 
		  continue문은 현재의 반복을 뛰어넘고 다음 반복을 진행.
		  반복문이 진행되다가 continue문을 만나면 반복문의 제일 끝으로 가서 다음 반복을 계속 수행.
          0 ~ 100까지의 홀수만 더 함 
        */
        
		int total = 0;
		int num;
		
		for(num=0; num<=100; num++) {
        
			if(num%2 == 0) {
				continue;
			}
			
			total += num;
			
		}
        
		System.out.println("1부터 100까지의 홀수의 합은 " + total + "입니다.");
	}
}

 

 

응용 문제
public class Exam025_01 {

	public static void main(String[] args) {
		/* 한번에 출금할 수 있는 금액은 1000원 이하, break 사용하지 말것 */
		// break 사용하지 않는 방법 -> while의 조건식을 이용해서 반복문은 빠져 나올것.
		// -> 조건식에 뭘 써야 하나? -> break의 if 조건식은 반복을 종료하는 조건.
		// -> while의 조건식은?
		
	    Scanner scanner = new Scanner(System.in); 
		
		int money = 10000;

		System.out.println("현재 가진 돈은 " + money + "원 입니다.");
		
		while(money > 0) {
			System.out.print("얼마를 사용하시겠습니까? >>> ");
			int spendMoney = scanner.nextInt(); // 정수를 입력받음.
			
			if(spendMoney <= 0 || spendMoney > money) {
				System.out.println("다시 입력해 주세요(사용범위가 틀렸습니다.)");
				continue; // 현재의 반복을 벗어나서 다시 반복을 시작
			} else if (spendMoney > 1000) {
				System.out.println("1000원 이상은 출금할 수 없습니다.");
				continue;
			}
			
		    money -= spendMoney;
		    System.out.println("이제 " + money + "원이 남았습니다.");
		    
		}
		System.out.println("모든 돈을 사용합니다. 종료");
	    scanner.close();
	}
}

 

 

 

 

 

[ 출처 ; 학원 강의 및 자바의 정석 책 ]


1. while 문

1) 일반적인 while 반복문


👩🏻‍💻  for문과는 다르게 증감되는 인덱스가 있으면 코드에서 직접 처리해야 함

fun main() {
    // current 변수가 인덱스의 역할
    var current = 1
    val until = 12
    while (current < until) {
        println("현재 값은 ${current}입니다.")
        current++
    }
}
/*
현재 값은 1입니다.
현재 값은 2입니다.
현재 값은 3입니다.
...
현재 값은 9입니다.
현재 값은 10입니다.
현재 값은 11입니다.
*/


2) do와 함께 사용하기


👩🏻‍💻  do와 함께 사용하면 while 문의 조건식과 관계없이 do 블록 안의 코드를 한 번 실행

fun main() {
    var game = 1
    val match = 6
    do {
        println("${game}게임 이겼습니다. 우승까지 ${match - game}게임 남았습니다.")
        game++
    } while (game < match)
}    
/*
1게임 이겼습니다. 우승까지 5게임 남았습니다.
2게임 이겼습니다. 우승까지 4게임 남았습니다.
3게임 이겼습니다. 우승까지 3게임 남았습니다.
4게임 이겼습니다. 우승까지 2게임 남았습니다.
5게임 이겼습니다. 우승까지 1게임 남았습니다.
*/


3) while과 do ~ while의 차이점


👩🏻‍💻  가장 큰 차이점은 최초 값이 조건식을 만족하지 않았을 경우 실행 코드가 달라지는 것
👩🏻‍💻  do ~ while 은 조건과 상관없이 처음 한 번 로그가 출력

fun main() {
    game = 6
    while (game < match) {
        println("while 테스트입니다.")
        game++
    }

    // do ~ while 테스트
    game = 6
    do {
        println("do ~ while 테스트 입니다.")
        game++
    } while (game < match)
}
/*
do ~ while 테스트 입니다.
*/

 


2. 반복문 제어하기


👩🏻‍🚀  반복문이 실행되는 도중에 특정 조건에서 반복문을 벗어나거나 다음 반복문으로 넘어가야 하는 상황에서 사용

1) break : 반복문 탈출하기


    👾  반복문 안에서 break를 만나면 반복문을 탈출할 수 있음
    👾  특정 조건에서 무조건 반복문 블록에서 벗어날 때 사용

fun main() {    
    for (index in 1..10) {
        println("현재 index는 ${index}입니다.")
        if (index > 5) { // index가 5보다 크면 break 명령어로 현재 반복문을 벗어남
            break
        }
    }
}

/*
현재 index는 1입니다.
현재 index는 2입니다.
현재 index는 3입니다.
현재 index는 4입니다.
현재 index는 5입니다.
현재 index는 6입니다.
*/

 



2)  continue : 다음 반복문으로


    👾  반복문 내에서 continue를 만나면 continue 다음 코드는 실행하지 않고  반복문의 코드의 처음으로 돌아감

fun main() {

    for (except in 1..10) {
        // except가 3보다 크고 8보다 작으면 continue 명령으로 로그를 찍지 않고 다음 반복문으로 이동
        if (except > 3 && except < 8) {
            continue
        }
        println("현재 index는 ${except}입니다.")
    }
}
/*
현재 index는 1입니다.
현재 index는 2입니다.
현재 index는 3입니다.
현재 index는 8입니다.
현재 index는 9입니다.
현재 index는 10입니다.
*/

 


응용 예제


   📌  while문과 Range.random() 메소드를 이용해서 2개의 주사위를 던졌을 때 나오는 눈을 (눈1, 눈2) 형태로 출력하고,
         눈의 합이 5가 아니면 계속 주사위를 던지고, 눈의 합이 5이면 실행을 멈추는 코드를 작성해 보세요.
         눈의 합이 5가 되는 조합은 (1, 4), (4, 1), (2, 3), (3, 2)입니다.
       예 ) (5, 1)
              (4, 4)
              (6, 5)
              (5, 2)
              (3, 6)
              (1, 2)
              (2, 3)

💡  Range.random() : 어떤 숫자 범위가 정의된 Range 객체의 random() 메소드를 호출하면 그 범위의 무작위 숫자가 리턴
fun main() {

    while (true) {
        val num1 = (1..6).random()
        val num2 = (1..6).random()
        println("($num1, $num2)")

        if (num1 + num2 == 5) {
            break;
        }
    }
    println()

    do {
        val num1 = (1..6).random()
        val num2 = (1..6).random()
        println("($num1, $num2)")

    } while (num1 + num2 != 5)

}

 


 
    📌  음수가 입력될 때까지, 사용자가 입력한 정수의 합계를 계산하여 출력하는 프로그램을 작성하세요.
          while문을 사용, break 사용하지 말 것
          1) while문으로 작업
          2) do while문으로 작업

fun main() {

    var sum = 0
    var value = 0

    while (value >= 0) {
        sum += value
        print("정수를 입력하세요.")
        value = readln().toInt()
    }
    println("정수의 합계는 ${sum}입니다.")

    do {
        print("정수를 입력하세요.")
        val value = readln().toInt()
        if (value >= 0) {
            sum += value
        }
    } while (value >= 0)
    println("정수의 합계는 ${sum}입니다.")
}

 



    📌  컴퓨터가 주사위를 던지면 사용자가 주사위의 숫자를 맞히는 프로그램을 완성하세요.
          사용자가 맞힐 때까지 게임은 계속 됩니다.
          예)
          주사위 값은 얼마일까요? >>> 5
          오답입니다. 다시 시도하세요.
          주사위 값은 얼마일까요? >>> 1
          1! 정답입니다.
         

fun main() {

    // 1. break 사용
    val num = (1..6).random()
    while (true) {
        print("주사위 값은 얼마일까요? >>> ")
        var inputNum = readln().toInt();
        if (num == inputNum) {
            println("$inputNum! 정답입니다.")
            break
        } else {
            println("오답입니다. 다시 시도하세요.")
        }
    }

    println()

    // 2. break 사용 x
    val num2 = (1..6).random()
    do {
        print("주사위 값은 얼마일까요? >>> ")
        var inputNum = readln().toInt()
        if (num2 == inputNum) {
            println("$inputNum! 정답입니다.")
        } else {
            println("오답입니다. 다시 시도하세요.")
        }
    } while (num2 != inputNum)

}

 

 

 

[ 내용 참고 : IT 학원 강의 ]

'Programming Language > Kotlin' 카테고리의 다른 글

[Kotlin] 함수 function  (0) 2024.04.09
[Kotlin] 배열 Array  (0) 2024.04.08
[Kotlin] for 반복문  (0) 2024.04.05
[Kotlin] when 조건문, 범위 클래스  (1) 2024.04.05
[Kotlin] if 조건문  (0) 2024.04.05


1.  for 반복문

👩🏻‍🚀  반복문 : 반복작업을 할 때 사용

자바스크립트 반복문 특징

    -  while문 자바와 거의 동일
    -  삼항 for문 존재
    -  for in, for of

 

(1) for 반복문

    

  ✏️  특정 횟수 만큼 반복하고 싶을 때 사용

<!-- 기본 형식 -->    
for(초기값, 조건식, 증감식) // 초기값에는 const 대신 let 사용
for (let i = 0; i < 반복 횟수; i++) {
    문장
}
<script>
    /* for 반복문 기본 */
    for (let i = 0; i < 5; i++) { // 0 부터 5미만 까지 반복
        console.log(`${i}번째 반복입니다.`);
    }

    /* 1부터 N까지 더하기 */
    let output = 0; // 합계에 사용할 변수. 복합 대입 연산자에 사용해야 되서 반드시 초기화.
    for (let i = 1; i <= 100; i++) {
        output += i; // 1부터 100까지 더함.
    }
    //console.log(i); // i is not defined -> 변수i가 효력을 가지는 범위는 for문 안쪽.
    console.log(`1~100까지 숫자를 모두 더하면 ${output}입니다.`);
</script>

 

for 반복문과 배열
  📁  배열을 출력할 경우 배열.length 사용 
<script>
    const todos = ['우유 구매', '업무 메일 확인하기', '필라테스 수업'];

    for (let i = 0; i < todos.length; i++) {
        console.log(`${i}번째 할 일: ${todos[i]}`);
    }

    /* for 반복문으로 배열을 반대로 출력하기 */
    /* 2번째 할 일: 필라테스 수업
       1번째 할 일: 업무 메일 확인하기
       0번째 할 일: 우유 구매  */

    for (let i = todos.length-1; i >= 0; i--) {
        console.log(`${i}번째 할 일: ${todos[i]}`);
    }

    for (const i in todos) { // i는 인덱스 번호를 가져옴
        const ii = todos.length - i - 1;
        console.log(`${ii}번째 할 일: ${todos[ii]}`); // 인덱스번호를 이용해 값에 접근.
    }

 


(2) for 요소 in 반복문

 

✏️  인덱스 기반으로 출력 배열 요소를 하나하나 꺼내서 특정 문장을 실행할 때 사용

<!-- 기본 형식 -->
for(const 반복변수(인덱스) in 배열 또는 객체) { 문장 }
<script>
    const todos = ['우유구매', '업무 메일 확인하기', '필라테스 수업'];
    const times = ['8시', '3시', '12시'];

    // 배열 출력을 위한 전통적인 방법
    for (let i = 0; i < todos.length; i++) {
        console.log(`${i}번 째 할 일: ${todos[i]}`);
        console.log(typeof i); // number
    }

    for (const i in todos) {
        console.log(`${i}번 째 할 일: ${todos[i]}`); // 인덱스 번호를 이용해 값에 접근.
        console.log(i); // 0 1 2
        console.log(typeof i); // string -> 인덱스 값이 문자열
    }

    // 시간과 같이 출력
    for (const i in todos) {
        console.log(`${i}번 째 할 일: ${times[i]} : ${todos[i]}`);
    }
</script>

 


(3) for of 반복문

 

✏️  반복문 내부의 반복변수에 인덱스 대신 요소의 값이 들어감
✏️  자바의 foreach, 파이썬의 for in과 유사

for(const 반복변수 of 배열 또는 객체) {
    문장
}
<script>
    const todos = ['우유구매', '업무 메일 확인하기', '필라테스 수업'];
    for (const todo of todos) { // todo에 요소의 값이 들어감
        console.log(`오늘의 할 일: ${todo}`);
    }
</script>

 


(4) 중첩 for문

 

✏️  for문 안에 다른 for문을 넣어 사용

✏️  안쪽 for문을 모두 실행한 후 바깥쪽 for문을 실행

<script>
    /* for문으로 5번 반복 */
    for (let i = 0; i < 30; i++) {
        document.write('*');
    }
    document.write('<br>');
    for (let i = 0; i < 30; i++) {
        document.write('*');
    }
    document.write('<br>');
    for (let i = 0; i < 30; i++) {
        document.write('*');
    }
    document.write('<br>');
    for (let i = 0; i < 30; i++) {
        document.write('*');
    }
    document.write('<br>');
    for (let i = 0; i < 30; i++) {
        document.write('*');
    }
    document.write('<br>');

    /* 중첩 for문으로 5번 반복 */
    for (let k = 0; k < 5; k++) {
        for (let i = 0; i < 30; i++) {
            document.write('*');
        }
        document.write('<br>');
    }
</script>

구구단 출력
<head>
    <style>
        div {
            display:inline-block;
            padding:0 20px 30px 20px;
            margin:15px;
            border:1px solid #ccc;
            line-height:2;
        }
        div h3 {
            text-align:center;
            font-weight:bold;
        }
    </style>
</head>
<body>
    <h1>구구단</h1>
    <script>
     for(let i = 2; i <= 9; i++) {
         document.write('<div>');
         document.write('<h3>' + i + '단</h3>');
         for (let j = 2; j <= 9; j++) {
             document.write(`${i} X ${j} = ${i * j} <br>`);
         }
         document.write('</div>');
     }
    </script>
</body>


2.  while 문

🐰  if 조건문과 형태가 비슷하지만 문장을 한 번만 실행하고 끝내는 것이 아니라 

      불 표현식이 true이면 계속해서 문장을 실행한다는 점이 다르다.
🐰  while 반복문의 경우 조건이 변하지 않는다면 무한히 반복 실행하므로 조건을 거짓으로 만들 수 있는 문장이 있어야 함
🐰  반복문이 무한 반복 되는 것을 무한 루프 infinite loop

<!-- 기본형식 -->
while (불 표현식) {
    문장
}
<script>
    /* while 반복문 기본 */
    let i = 1;
    // confirm() : 사용자가 [확인] 버튼을 클릭하면 true 반환. [취소]를 클릭하면 false 반환.
    while (confirm('계속 진행하시갰습니까?')) {
        alert(`${i}번째 반복입니다.`);
        i = i + 1;
    }
</script>

 

while 문으로 배열 출력하기
while 반복문과 for 반복문은 서로 대체해서 사용할 수 있음
보통 특정 횟수 반복할 때 for, 조건에 큰 비중이 있을 때는 while.
  예) 특정 시간동안 어떤 데이터를 받을 때 까지
<script>
    const array = [1, 2, 3, 4, 5];

    for(let i = 0; i < array.length; i++){
        console.log(`${i} : ${array[i]}`);
    }

    // 1. 인덱스 번호가 필요 : 0 ~ 4
    // 2. 반복문은 5번 반복
    let i = 0;
    while(i < array.length) {
        console.log(`${i} : ${array[i]}`);
        i++;
    }
</script>

 


3.  break 문

🐰  switch문이나 반복문을 벗어날 때 사용하는 키워드

while(true) {
    if(조건식) {
        break;
    }
}
<script>
    for (let i = 0; true; i++) { // 조건문이 true라서 무한 반복.
        alert(i + '번째 반복문입니다.');

        // 진행 여부를 물어봄
        const isContinue = confirm('계속하시겠습니까?'); // confirm()에서 취소를 누르면 반복을 종료.
        if(!isContinue) { // 취소를 누르면 false가 반환이 되므로 not연산자를 사용해서 true로 변경.
            break;
        }
    }
    alert('프로그램 종료'); // 프로그램의 종료를 확인.
</script>

 


4.  continue 문

🐰  반복문 안의 반복을 멈추고 반복문의 처음으로 돌아가 다음 반복 작업을 진행

<script>
    // alert() 명령문 위에 continue 키워드가 있어서 실행되지 않음.
    for(let i = 0; i < 5; i++) {
        console.log(i);
        // 현재 반복 작업을 중지하고 다음 반복 작업을 수행
        continue;
        alert(i); // 경고창이 출력되지 않음
    }
</script>

 

 

 

 

[ 내용 참고 : IT 학원 강의 및 책 'Do it HTML+CSS+자바스크립트 웹 표준의 정석' ]

+ Recent posts