codeahn

break문은 근접한 단 하나의 반복문만 벗어날 수 있기 때문에, 여러 개의 반복문이 중첩된 경우에는 break문으로 중첩된 반복문을 완전히 벗어날 수 없다. 이때 이름 붙은 반복문으로 하나 이상의 반복문을 벗어나거나 반복을 건너뛸 수 있다.

public class FlowEx33 {
	public static void main(String[] args) {
		// for문에 Loop1이라는 이름을 붙였다.
		Loop1:
			for (int i = 2; i <= 9; i++) {
			for (int j = 1; j <= 9; j++) {
				if (j == 5)
//				break Loop1;
//				break;
//				continue Loop1;
				continue;
				System.out.println(i + "*" + j + "=" + i * j);
			} // end of for i
			System.out.println();
		} // end of Loop1
	}
}

2*1=2
2*2=4
2*3=6
2*4=8
2*6=12
2*7=14
2*8=16
2*9=18

3*1=3
3*2=6
3*3=9
3*4=12
3*6=18
3*7=21
3*8=24
3*9=27

4*1=4
4*2=8
4*3=12
4*4=16
4*6=24
4*7=28
4*8=32
4*9=36

5*1=5
5*2=10
5*3=15
5*4=20
5*6=30
5*7=35
5*8=40
5*9=45

6*1=6
6*2=12
6*3=18
6*4=24
6*6=36
6*7=42
6*8=48
6*9=54

7*1=7
7*2=14
7*3=21
7*4=28
7*6=42
7*7=49
7*8=56
7*9=63

8*1=8
8*2=16
8*3=24
8*4=32
8*6=48
8*7=56
8*8=64
8*9=72

9*1=9
9*2=18
9*3=27
9*4=36
9*6=54
9*7=63
9*8=72
9*9=81

i * 5의 식이 생략되었다.

public class FlowEx34 {
	public static void main(String[] args) {
		int menu = 0, num = 0;
		
		Scanner scanner = new Scanner(System.in);
		
		outer:
			while(true) {
				System.out.println("(1) square");
				System.out.println("(2) square root");
				System.out.println("(3) log");
				System.out.println("원하는 메뉴(1~3)를 선택하세요.(종료0)>");
				
				String tmp = scanner.nextLine();	// 화면에서 입력받은 내용을 tmp에 저장
				menu = Integer.parseInt(tmp);		// 입력받은 문자열(tmp)를 숫자로 변환
				
				if(menu==0) {
					System.out.println("프로그램을 종료합니다.");
					break;
				}else if (!(1<= menu && menu <=3)) {
					System.out.println("메뉴를 잘못 선택하셨습니다.(종료는0)");
					continue;
				}
				
				for(;;) {
					System.out.print("계산할 값을 입력하세요.(계산 종료:0, 전체 종료:99)>");
					tmp = scanner.nextLine();		// 화면에서 입력받은 내용을 tmp에 저장
					num = Integer.parseInt(tmp);	// 입력받은 문자열(tmp)를 숫자로 변환
					
					if(num==0)
						break;
					
					if(num==99)
						break outer;
					
					switch(menu) {
					case 1:
						System.out.println("result="+ num*num);
						break;
					case 2:
						System.out.println("result="+ Math.sqrt(num));
						break;
					case 3:
						System.out.println("result="+ Math.log(num));
						break;
					}
				} // for(;;)
			} // while의 끝
	}// main의 끝
}

(1) square
(2) square root
(3) log
원하는 메뉴(1~3)를 선택하세요.(종료0)>
1
계산할 값을 입력하세요.(계산 종료:0, 전체 종료:99)>2
result=4
계산할 값을 입력하세요.(계산 종료:0, 전체 종료:99)>0
(1) square
(2) square root
(3) log
원하는 메뉴(1~3)를 선택하세요.(종료0)>
2
계산할 값을 입력하세요.(계산 종료:0, 전체 종료:99)>4
result=2.0
계산할 값을 입력하세요.(계산 종료:0, 전체 종료:99)>99

예제 4-32에서 코드를 추가한 것이다.

반복문만 떼어놓고 보면 무한 반복문인 while문 안에 또 다른 무한 반복문 for문의 중첩된 구조이다.

outer :
while(true) {
	...
    for( ; ; )
    	...
        if(num==0) // 계산 종료. for문을 벗어난다.
        	break;
            if*num==99) // 전체 종료. for문과 while문 모두 벗어난다.
            	break outer;
                ...
            } // for( ; ; )
        } // while(true)

break outer에 의해 for문과 while문 모두를 벗어나 프로그램이 종료된다.

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

for문의 경우 증감식으로 이용하며 while문의 경우 조건식으로 이용한다.

import java.util.*;

public class FlowEx32 {
	public static void main(String[] args) {
		int menu = 0;
//		int num = 0;

		Scanner scanner = new Scanner(System.in);

		while (true) {
			System.out.println("(1) square");
			System.out.println("(2) square root");
			System.out.println("(3) log");
			System.out.println("원하는 메뉴(1~3)를 선택하세요. (종료:0)>");

			String tmp = scanner.nextLine();// 화면에서 입력받은 내용을 tmp에 저장
			menu = Integer.parseInt(tmp);

			if (menu == 0) {
				System.out.println("프로그램을 종료합니다.");
				break;
			} else if (!(1 <= menu && menu <= 3)) {
				System.out.println("메뉴를 잘못 선택하셨습니다.(종료는 0)");
				continue;
			}

			System.out.println("선택하신 메뉴는 " + menu + "번입니다.");
		}
		scanner.close();
	}
}

(1) square
(2) square root
(3) log
원하는 메뉴(1~3)를 선택하세요. (종료:0)>
4
메뉴를 잘못 선택하셨습니다.(종료는 0)
(1) square
(2) square root
(3) log
원하는 메뉴(1~3)를 선택하세요. (종료:0)>
1
선택하신 메뉴는 1번입니다.
(1) square
(2) square root
(3) log
원하는 메뉴(1~3)를 선택하세요. (종료:0)>
0
프로그램을 종료합니다.

메뉴를 보여주고 선택하게하는 예제이다.

잘못 선택한경우 다시 while문의 처음으로 돌아간다.

앞서 switch문에서 break문에 대해 배웠던 것 처럼 반복문에서도 break문을 사용할 수 있다.

주로 if문과 함께 사용되어 조건을 만족하면 반복문을 벗어나도록한다.

public class FlowEx30 {
	public static void main(String[] args) {
		int sum = 0;
		int i = 0;
		
		while(true) {
			if(sum > 100)
				break;
			++i;
			sum +=i;
		}// end of while
		
		System.out.println("i=" + i);
		System.out.println("sum=" + sum);
	}
}

i=14
sum=105

숫자를 1부터 더해서 몇까지 더하면 합이 100을넘는지 알아내는 예제이다.

14에서 합105가되어 반복문을 벗어난다.

for문에 비해 while문은 구조가 간단하다.

while (조건식) {
	//조건식의 연산결과가 참(true)인 동안, 반복될 문장들을 적는다.
}

1. 조건식이 참(true)이면 블럭{}안으로 들어가고, 거짓(false)이면 while문을 벗어난다.
2. 블럭{}의 문장을 수행하고 다시 조건식으로 돌아간다.

for문과 while문의 비교

for(int i=1;i<=10;i++) {
	System.out.println(i);
}

while(i<=10) {
	System.out.println(i);
    i++;
}

for문과 while문은 항상 서로 변환이 가능하다.

초기화나 증감 식이 없다면 while문이 더 적합할 것이다.

while문의 조건식은 생략불가

for문은 조건식을 생략할 수 있으나 for( ; ; )이 가능하나

while문의 조건식은 생략할 수 없다. while( ) 은 불가능

따라서 while문은 적어도 while(true)를 적어줘야한다.

public class FlowEx23 {
	public static void main(String[] args) {
		int i = 5;

		while (i-- != 0) {
			System.out.println(i + " - I can do it.");
		}
	}	//main의 끝
}

4 - I can do it.
3 - I can do it.
2 - I can do it.
1 - I can do it.
0 - I can do it.

for문이나 while문에 속한 문장은 조건에 따라 한 번도 수행되지 않을 수 있지만 do-wheile문에 속한 문장은 무조건 최소한 한 번은 수행될 것이 보장된다.

주로 게임에서 이를 이용한다.(e.g. UI 튜토리얼)

기본적으로 while문과 구조가 같으나 조건식과 블록{}의 순서를 바꿔놓은 것이다.

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

그리 많이 쓰는 반복문은 아니다.

public class FlowEx28 {
	public static void main(String[] args) {
		int input = 0, answer = 0;

		answer = (int) (Math.random() * 100) + 1; // 1~100사이의 임의의 수를 저장
		Scanner scanner = new Scanner(System.in);

		do {
			System.out.print("1과 100사이의 정수를 입력하세요.>");
			input = scanner.nextInt();

			if (input > answer) {
				System.out.println("더 작은 수로 다시 시도해보세요.");
			} else if (input < answer) {
				System.out.println("더 큰 수로 다시 시도해보세요.");
			}
		} while (input != answer);

		System.out.println("정답입니다.");
		scanner.close();
	}
}

1과 100사이의 정수를 입력하세요.>50
더 큰 수로 다시 시도해보세요.
1과 100사이의 정수를 입력하세요.>75
정답입니다.

반복문은 어떤 작업이 반복적으로 수행되도록 할 때 사용된다.

for문과 while문은 구조와 기능이 유사하여 어느 경우에나 서로 변환이 가능하다.

for문

for문은 반복 횟수를 알고 있을 때 적합하다.

구조가 객관적이라 이해하기 쉽다.

for(int i=1i<=5;i++) {
	System.out.println("I can do it.");
}

변수에 i를 저장한 다음, 매 반복마다 i값을 i 증가시키고, 반복할 때마다 "I can do it"을 출력한다.

for문의 구조와 수행 순서

for문은 초기화, 조건식, 증감식, 블록{}으로 이루어져 있으며, 조건식이 참인 동안 블록{ } 내의 문장들을 반복한다.

for (초기화;조건식;증감식) {
	// 조건식이 참일 때 수행될 문장들을 적는다.
)

1. 초기화 수행
2. 조건식 참거짓 판별
3. 수행될 문장
4. 증감식
5. 다시 2로

초기화

반복문에 사용될 변수를 초기화하는 부분이며 처음에 한 번만 수행된다.

조건식

조건식의 값이 (boolean) 참(true)이면 반복을 계속하고, false이면 반복을 중단한다.

조건식을 잘못 만들면 한 번도 수행되지 않거나, 영원히 반복된다.

증감식

반복문을 제어하는 변수의 값을 증가 또는 감소시키는 식이다.

public class FlowEx14 {
	public static void main(String[] args) {
		for (int i = 1; i <= 10; i++) { // 반복횟수 가급적 for문에서는 시작의 변수는 하나만
			System.out.printf("%d \t%n", i);
		}
	}
}

1 	
2 	
3 	
4 	
5 	
6 	
7 	
8 	
9 	
10

중첩 for문

if안에 또 다른 if문을 넣을 수 있는 것처럼, for문 안에 또 다른 for문을 포함시키는 것도 가능하다.

public class FlowEx16 {
	public static void main(String[] args) {
		for(int i=1; i<=5;i++) {
			for(int j=1;j<=10;j++) {
				System.out.print("*");// 2 10
			}
			System.out.println();
		}
	}

}

**********
**********
**********
**********
**********

for( i증가식 ) {

for( j증가식) {

"*"}

}

연산순서

1. i 증가
2. j 증가
3. * 출력
4. j 증가 * 4
5. 다시 1번부터 4회 추가로 반복

향상된 for문(enhanced for statement)

JDK1.5부터 배열과 컬렉션에 저장된 요소에 접근할 때 기존보다 편리한 방법으로 처리할 수 있도록 for문의 새로운 문법이 추가되었다.

향상된 for문을 사용하려면 객체가 필요하다.

for ( 타입 변수명 : 배열 또는 컬렉션) {
	// 반복할 문장
}

int[] arr = {10,20,30,40,50);

for(int i=0; i < arr.length; i++) {
	System.out.println(arr[i]);
}

이 문장을 배열을 선언했을 때

int[] arr = {10,20,30,40,50);

for(int tmp : arr) {
	System.out.println(tmp);
}

이런 식으로 표현이 가능해진다.

그러나 향상된 for문은 일반적인 for문과 달리 배열이나 컬렉션에 저장된 요소들을 읽어오는 용도로만 사용할 수 있다.