개발일기

■ 명시적 형변환

큰 범위에서 작은 범위 대입은 명시적 형변환이 필요하다.

#double 은 실수를 표현할 수 있다. 이에 따라 1.5 가 가능한데 int 는 실수를 표현할 수 없다.

  double을 int 로 대입하면 어떻게 될까?

예제 코드)

package casting;

public class Casting2 {
    public static void main(String[] args) {

        double doubleValue = 1.5;
        int intValue = 0;

//        intValue = doubleValue; //컴파일 오류 발생
        intValue = (int)doubleValue; // 형변환
        System.out.println(intValue); // 출력 : 1
    }
}

실행 결과)

# int 형은 double 형보다 숫자의 표현 범위가 작으며, 실수 표현이 불가하다.

  이 경우 숫자가 손실되는 문제가 발생할 수 있다.

   쉽게 설명하면 큰 컵에 담긴 물을 작은 컵에 옮겨 담으려고 하니 손실이 발생할 수 있는 것이다.

- 형변환

# 이런 위험을 개발자가 감수하고 값을 대입하고 싶다면 데이터 타입을 강제로 변경할 수 있다.

   예를들어 설명하면 대략적인 결과를 보고 싶은데, 이 때 소수점을 버리고 정수로만 보고싶을 수 있다.

# 형변환은 아래와 같이 변경하고 싶은 데이터 타입을 ( int ) 와 같이 괄호를 사용해서 명시적으로 입력하면 끝!

   >> intValue = (int)doubleValue; // 형변환

# 이를 형(타입)을 바꾼다고 하여 형변환이라 하며, 영어로는 캐스팅이라 한다.

   개발자가 직접 형변환 코드를 입력한다고 해서 명시적 형변환이라 한다.

※ 캐스팅 용어

    캐스팅은 영어 단어 cast 에서 유래 되었다. cast 는 금속이나 다른 물질을 녹여 특정한 형태나 모양을 만드는 과정 의미

- 명시적 형변환 과정

// doubleValue = 1.5
intValue = (int)doubleValue;
intValye = (int)1.5;  // doubleValue에 있는 값을 읽는다.
intValue = 1; // (int) 로 형변환 한다. intValue의 int 형인 숫자 1을 대입한다.

# 형변환을 한다고 하여 doubleValue 자체의 타입이 변경되거나 그 안에 있는 값이 변경되는 것은 아니다.

   doubleValue 에서 읽은 값을 형변환 하는 것이다. doubleValue 안에 있는 값은 1.5 그대로 유지!

   변수의 값은 대입연산자 ( = ) 를 사용해서 직접 대입할 때만 변경된다.

- 형변환과 오버플로우

# 형변환을 할 때 작은 숫자가 표현할 수 있는 범위를 넘어서면?

예제 코드)

package casting;

public class Casting3 {
    public static void main(String[] args) {
        long maxIntValue = 2147483647; // int 최고 값
        long maxIntOver = 2147483648L; // int 최고값 + 1(초과)
        int intValue = 0;

        intValue = (int)maxIntValue; //형변환
        System.out.println("maxIntValue casting = " + intValue);

        intValue = (int)maxIntOver; //형변환
        System.out.println("maxIntOver casting = " + intValue);
    }
}

실행 결과)

- 정상 범위
long maxIntValue = 2147483647 를 보면 int 로 표현할 수 있는 가장 큰 수를 입력했다.
이 경우 int 로 표현할 수 있는 범위에 포함되기 때문에 long >> int 로 형변환을 해도 문제가 없다.

- 수행 내용
intValue = (int)maxIntValue; // 형변환
maxIntValue = 2147483647; // int 최고값
intValue = (int)2147483647L; 형변환
intValue = 2147483647;

- 초과 범위
long maxIntOver = 2147483648L를 보면 int 로 표현할 수 있는 가장 큰 숫자보다 1큰 숫자를 입력했다.
이 숫자 리터럴은 int 범위를 넘어가기 때문에 L을 붙여 long 형을 사용해야 한다.
이 경우 int로 표현할 수 있는 범위를 넘기 때문에 long >> int 로 형변환 시 문제가 발생한다.

- 수행 내용
intValue = (int)maxIntOver; //형변환
maxIntOver = 2147483648L; // int 최고값 + 1
intValue = (int)maxIntOver; // 변수 값 읽기
intValue = (int)2147483648L; //형변환 시도
intValue = -214748648;

• 결과 확인 시 -2147483648 이란 전혀 다른 수가 보인다.
  int 형은 2147483648L 을 표현할 수 있는 방법이 없어 기존 범위를 초과해서 표현하면 다른 숫자가 표현되며,
  이런 현상을 오버플로우라 한다.
• 보통 오버플로우가 발생하면 마치 시계가 한 바퀴 돈 것 처럼 다시 처음부터 시작한다.
  -2147483648 숫자는 int 의 가장 작은 숫자이다.
• 오버플로우가 발생하는 것이 문제이며, 오버플로우 발생 시 결과가 어떻게 되는지 계산하는데 시간 낭비되므로
  오버플로우가 발생하지 않도록 막아야 한다.
  이 경우 단순히 대입하는 변수 (intValue) 의 타입을 int > long 으로 변경하면 오버플로우 문제 해결!

long longValue = 0;
longValue = maxIntOver; //형변환
       System.out.println("maxIntOver casting = " + longValue);

# 이런식으로 오버플로우가 발생한 변수를 담을 수 있도록 더 큰 타입의 신규 변수 생성 필요

■ 자동 형변환

형변환
● 작은 범위에서 큰 범위로 값을 넣을 수 있다.
 - 예) int >> long >> double
● 큰 범위에서 작은 범위는 아래와 같은 문제가 발생할 수 있다.
 - 소수점 버림
- 오버 플로우

※ 작은 범위에서 큰 범위로 대입은 허용한다.
자바에서 숫자를 표현할 수 있는 범위
int < long < double
int 보다는 long이, long 보다는 double가 더 큰 범위를 표현할 수 있다.

# 작은 범위에서 큰 범위에 값을 대입하는 경우 특별한 문제 없이 잘 수행된다.

예제 코드)

package cond;

public class Casting1 {
    public static void main(String[] args) {
        int intValue = 10;
        long longValue;
        double doubleValue;

        longValue = intValue; // int > long
        System.out.println("longValue = " + longValue); //10

        doubleValue = intValue; // int > double
        System.out.println("double = " + doubleValue); // 10.0

        doubleValue = 20L; // long > double
        System.out.println("doubleValue2 = " + doubleValue);
    }
}

실행 결과)

• 자바는 기본적으로 같은 타입에 값을 대입할 수 있따.
• int >> long 을 비교해보면 long 이 int 보다 더 큰 숫자 범위를 표현한다.
  작은 범위 숫자 타입에서 큰 범위 숫자 타입에 대입하면 문제되지 않는다.
• long >> double 의 경우에도 double 은 부동 소수점을 사용하기 때문에 더 큰 숫자 범위를 표현한다.
• 정리하면 작은 범위에서 큰 범위로의 대입은 자바 언어에서 허용한다.
  쉽게 설명하면 큰 그릇은 작은 그릇에 담긴 내용을 담을 수 있다.

■ 자동 형변환

# 하지만 결국 대입하는 형(타입)을 맞춰야하기 땜누에 개념적으로는 아래와 같이 동작한다.

// intValue = 10
doubleValue = intValue
doubleValue = (double) intValue // 형 맞추기
doubleValue = (double) 10 // 변수 값 읽기
doubleValue = 10. 0 // 형변환

# 앞에 (double) 과 같이 적어주면 int 형이 double 형으로 형이 변한다.
# 이렇게 형이 변경되는 것을 형변환이라 한다.

# 작은 범위 숫자 타입에서 큰 범위 숫자 타입으로의 대입은 개발자가 직접 형변환을 안해도 된다.
   이런 과정이 자동으로 일어나기 때문에 자동 형변환 또는 묵시적 형변환 이라 한다.

■ 스코프 존재 이유

예제 코드)

package scope;

public class Scope3_1 {
    public static void main(String[] args) {
        int m = 10;
        int temp = 0;
        if (m > 0) {
            temp = m * 2;
            System.out.println("temp = " + temp);
        }
        System.out.println("m = " + m);
    }
}

실행 결과)

# 조건이 맞으면 변수 m 의 값을 2배 증가해서 출력하는 코드로 2배 증가한 값을 저장하기 위해 temp 사용

   해당 코드는 좋은 코드라 조기 어렵다. 이유는 temp의 경우 if 조건이 만족할 때 임시로 잠깐 사용하는 변수이다.

   하지만 임시 변수 temp  는 main() 코드 블록에 선언되어 있기 떄문에 아래와 같은 문제가 발생한다.

• 비효율적인 메모리 사용 : temp 는 if 코듭 블록에서만 필요하지만, main() 코드 블록이 종료될때 까지 메모리에 유지
  따라서 불필요한 메모리가 낭비되며, if 코드 블록 안에 temp를 선언했다면 자바를 구현하는 곳에서
  if 코드 블록의 종료 시점에 이 변수를 메모리에서 제거하여 더 효율적인 메모리를 사용할 수 있다.
• 코드 복잡성 증가 : 좋은 코드는 군더더기 없는 단순한 코드이다.
  temp는 if 보드 블록에서만 필요하고. 해당 블록에서만 사용하면 된다.
  만약 if 코드 블록 안에 temp를 선언했다면 if가 끝나고 나면 temp를 전혀 생각하지 않아도 된다.
  하지만 위 예제 코드는 if 블록이 끝나도 main() 어디서나 temp 를 여전히 접근할 수 있다.
  누군가 위 코드를 유지보수할 때 m은 물론 temp까지 계속 신경써야하기 떄문에 스코프가 불필요하게 넓다.
  현재 코드는 단순해서 이해할 수 있지만 실무에서는 코드가 복잡한 경우가 많다.

temp 스코프가 필요한 곳에 이동한 예제)

package scope;

public class Scope3_2 {
    public static void main(String[] args) {
        int m = 10;
        if (m > 0) {
            int temp = m * 2;
            System.out.println("temp = " + temp);
        }
        System.out.println("m = " + m);
    }
}

실행 결과)

# temp 를 if 코드 블록 안에 선언하여 temp는 if 코드 블록 안으로 스코프가 줄어든다.
   덕분에 temp는 메모리를 빨리 제거하여 효율적으로 메모리 사용이 가능하며, temp 변수를 생각해야 하는 범위르 줄여
   보다 유지보수 하기 좋은 코드로 만들었다.

■ while문 vs for문 - 스코프 관점

while 예시)

package scope;

public class ScopeWhile {
    public static void main(String[] args) {
        int sum = 0;
        int i = 1;
        int endNum = 3;

        while (i <= endNum) {
            sum = sum + i;
            System.out.println("i = " + i + " sum = " + sum);
            i++;
        }
    }
}

 For 예시)

package scope;

public class ScopeFor {
    public static void main(String[] args) {
        int sum = 0;
        int endNum = 3;

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

# 변수 스코프 관점에서 카운터 변수 i 비교

• while 문의 경우 변수 i 의 스코프가 main( ) 메소드 전체가 된다.
  반면 for 문의 경우 변수 i 스코프가 for 문 안으로 한정되어 있다.
• 이에 따라 변수 i 와 같이 for 문 안에서만 사용되는 카운터 변수가 있다면 while문 보다는 for문을 사용해서
  스코프의 범위를 제한하는 것이 메모리 사용과 유지보수 관점에 더 좋다.

※ 정리

• 변수는 꼭 필요한 범위로 한정해서 사용하는 것이 좋다.
  변수의 스코프는 꼭 필요한 곳으로 한정해서 아용하자!
  메모리를 효율적으로 사용하고 더 유지보수하기 좋은 코드를 만들 수 있다.
  
  
• 좋은 프로그램은 무한한 자유가 있는 프로그램이 아닌 적절한 제약이 있는 프로그램이다.

■ 지역 변수와 스코프

스코프1 - 지역변수와 스코프

변수는 선언한 위치에 따라 지역 변수, 멤버 변수(클래스 변수, 인스턴스 변수)와 같이 분류도니다.
지금까지 배운 변수들은 모두 지역 변수(Local Variable) 영어로 로컬 변수라 한다.

※ 지역 변수란?
이름 그대로 특정 지역에서만 사용할 수 있는 변수라는 뜻
특정 지역을 벗어나면 사용할 수 없다.
여기서 말하는 지역은 변수가 선언된 코드 블록 ({ }) 이다.
지역 변수는 자신이 선언된 코드 블록({ }) 안에서만 생존하고 자신이 선언된 코드 블록을 벗어나면 제거된다.

에제 코드)

package scope;

public class Scope1 {
    public static void main(String[] args) {
        int m = 10; // 생존 시작
        if (true) {
            int x = 20;
            System.out.println("if m = " + m);
            System.out.println("if x = " + x);
        } // x 생존 종료

        System.out.println("main x = " + x);
        System.out.println( "main m = " + m);
    } // m 생존 종료
}

실행 결과)

# int m

  - int m 은 main { } 의 코드 블록 안엔서 선언되었다.
    따라서 변수를 선언한 시점부터 main { }의 코드 블록이 종료될 때 까지 생존한다.

  - if { } 블록 내부에서도 외부 블록에서 선언된 m 에 접근할 수 있다.

   쉽게 설명하면 생존 범위만 맞으면 다 접근이 가능하다.

# int x

   - int x  는 if {} 블록 안에서 선언되었다. 따라서 변수를 선언한 시점부터

     if { } 으 코드 블록이 종료 될때까지 생존한다.

   - if { } 내부에서는 자신의 범위에서 선언한 x 에 당연히 접근 가능하다.

   - if { } 코드 블록이 끝나버리면 x  는 제거된다. 

     따라서 이후에 접근하면 cannot find symbol 이라는 변수명을 찾을 수 없다는 컴파일 오류 발생!

이렇게 변수의 접근 가능한 범위를 스코프(Scope) 라 한다.
int m 은 main { } 전체에서 접근할 수 있기 때문에 스코프가 넓고,
int x 는 if { } 코드 블록안에서만 접근이 가능하기 때문에 스코프가 좁다.

for {} 를 사용하는 예제)

package scope;

public class Scope2 {
    public static void main(String[] args) {
        int m = 10;
        for (int i = 0; i < 2; i++) { //블록 내부, for문 내
            System.out.println("for m = " + m); //블록 내부에서 외부 접근 가능
            System.out.println("for i = " + i);
        } // i 생존 종료

        System.out.println("main i = " + i); // 오류, i에 접근 불가
        System.out.println("main m = " + m);
    }
}

실행 결과)

# for 문으로 바뀐것을 제외하면 앞의 예제와 비슷한 예제이다.

# for 문의 경우 for(int i = 0; ...)과 같이 for 문안에서 초기식에 직접 변수 선언이 가능하다.

  초기식에 선언한 변수는 for 문 블록 안에서만 사용이 가능하다.

■ 반복문 문제 풀이2

문제 : 구구단 출력
중첩 for 문을 사용해서 구구단을 완성하자

문제 코드)

package loop.ex;

public class NestEx1 {
    public static void main(String[] args) {
        for (int i = 2; i <= 9; i++) {
            System.out.println(i + "단");
            for (int j = 1; j <= 9; j++) {
                System.out.println(i + "*" + j + " = " + i * j);
            }
        }
    }
}

실행 결과)

문제 : 피라미드 출력
int rows 선언
해당 수 만큼 피라미드를 출력하면 된다.

참고 : println()은 출력 후 다음 라인으로 넘어간다.
라인을 넘기지 않고 출력하려면 print() 사용 필요

문제 코드)

package loop.ex;

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

        for (int i = 1; i <= rows; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

실행 결과)

■ 반복문 문제 풀이1

문제 : 자연수 출력
처음 10개의 자연수를 출력하는 프로그램을 작성하자.
변수 = count 사용
while 문, for문 2가지 버전 정답 만들기

while문 코드)

package loop.ex;

public class WhileEx1 {

    public static void main(String[] args) {
        int count = 1;
        while (count <= 10){
            System.out.println(count);
            count++;
        }
    }
}

for문 코드)

package loop.ex;

public class ForEx1 {

    public static void main(String[] args) {
        for(int count = 1; count <= 10; count++){
            System.out.println(count);
        }
    }
}

while문 / for문 실행 결과)

문제 : 짝수 출력
반복문을 사용하여 처음 10개의 짝수를 출력하는 프로그램을 만들자.
변수 = num
while문 , for 문 2가지 버전 정답 필요

while문 코드)

package loop.ex;

public class WhileEx2 {

    public static void main(String[] args) {
        int num = 2;
        int count = 1;
        while (count <=10){
            System.out.println(num);
            num += 2;
            count++;
        }
    }
}

for문 코드)

package loop.ex;

public class ForEx2 {

    public static void main(String[] args) {
        for (int num = 2, count = 1; count <=10; num+=2, count++){
            System.out.println(num);
        }
    }
}

실행 결과)

문제 : 누적 합 계산
반복문을 사용하여 1부터 max 까지 합을 꼐산하고 출력하는 프로그램을 만들자.
sum 이라는 변수를 사용하여 누적합을 표현하고 i 라는 변수를 사용하여 카운트(1 ~ max까지 증가하는 변수)를 수행
while문, for문 2가지 버전 정답 필요

while문 코드)

package loop.ex;

public class WhileEx3 {

    public static void main(String[] args) {
        int max = 100;
        int i = 1;
        int sum = 0;

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

for문 코드)

package loop.ex;

public class ForEx3 {

    public static void main(String[] args) {
        int sum = 0;
        int max = 100;
        for (int i = 1; i <= max; i++) {
            sum += i;
        }
        System.out.println(sum);
    }
}

실행 결과)

■ 중첩 반복문

중첩 반복문이란?
반복문은 내부에 또 반복문을 만들 수 있다.
for, while 모두 가능하다.

예제 코드)

package loop;

public class Nested1 {
    public static void main(String[] args) {
        for (int i = 0; i < 2; i++) {
            System.out.println("외부 for 시작 i : " + i);
            for (int j = 0; j < 3; j++) {
                System.out.println("-> 내부 for " + i + "-" + j);
            }
            System.out.println("외부 for 종료 i : " + i);
            System.out.println(); // 라인 구분을 위해 실행
        }
    }
}

실행 결과)

# 외부 for문은 2번, 내부 for문은 3번 실행된다.
   외부 for문 1 번당 내부 for문이 3번 실행되기 때문에 외부(2) * 내부(3)으로 총 6번의 내부 for문 코드가 실행된다.

■ 중첩 반복문의 장 단점

장점:

• 다차원 데이터 처리: 배열이나 컬렉션과 같은 복잡한 데이터 구조를 손쉽게 처리할 수 있다.
• 패턴 생성: 반복적인 패턴을 출력하거나 생성하는 데 유용하다
• 다양한 조건 처리: 복잡한 조건을 효율적으로 처리할 수 있다.

단점:

• 성능 저하: 중첩된 반복문은 실행 시간이 기하급수적으로 증가할 수 있기 때문에
  큰 데이터셋을 처리할 때 성능 문제가 발생할 수 있습니다.
• 복잡성 증가: 코드가 복잡해지고 가독성이 떨어질 수 있으며, 유지보수가 어렵다.

요약

• 중첩 반복문은 주로 2차원 배열, 문자열 조작, 패턴 출력, 복잡한 데이터 처리에 사용
• 중첩 반복문을 사용할 때는 성능과 가독성에 주의해야 한다.

■ for문

for문 구조

for (초기식; 조건식; 증감식) {
    // 코드
}

# for 문에서 초기식, 조건식, 증감식은 선택으로 아래와 같이 생략해도 된다. 단, 각 영역을 구분하는 세미콜론( ; )은 유지!

for (;;) {
    //
}

# 위와 같이 작성하면 조건이 없기 때문에 무한 반복하는 코드가 된다.

while (true) {
    // 코드
}

# while문의 무한 반복 코드

문제 : 1부터 시작하여 숫자를 계속 누적해서 더하다가 합계가 10보다 큰 처음 값은 얼마인가?
1 + 2 + 3 .. 계속 더하다가 처음으로 합이 10 보다 큰 경우를 찾으면 된다.

for문을 통한 break 활용 문제 코드)

package loop;

public class Break2 {
    public static void main(String[] args) {
        int sum = 0;
        int i = 1;

        for (;;) {
            sum += i;
            if (sum > 10) {
                System.out.println("i = " + i + " sum = " + sum);
                break;
            }
            i++;
        }
    }
}

실행 결과)

• for (;;) 를 보면 조건식이 없으므로 무한반복!
• sum > 10 조건을 만족하면 break를 사용해서 for문 탈출!

문제 : 위 코드와 동일한 기능이나 증가하는 i 를 for 문에 넣어 관리해보자

문제 코드)

package loop;

public class Break3 {
    public static void main(String[] args) {
        int sum = 0;

        for (int i = 1; ; i++){
            sum += i;
            if(sum > 10){
                System.out.println("i = " + i + " sum = " + sum);
                break;
            }
        }
    }
}

실행 결과)

※ for 문 없이 while 문으로 모든 반복문을 다룰 수 있다.

   하지만 카운터 변수(인덱스 변수)가 명확하거나, 반복 횟수가 정해진 경우에는 for 문을 사용하는 것이 좋다.

■ for문

for문이란?
while문과 같은 반복문이고, 코드를 반복 실행하는 역할을 한다.
※ for문은 주로 반복 횟수가 정해져 있을 때 사용한다.

for문 구조

for (1.초기식; 2.조건식; 4. 증감식) {
    // 3. 코드
}

- for문은 실행 순서

1. 초기식이 실행된다. 주로 반복 횟수와 관련된 변수를 선언하고 초기화 할 때 사용
   초기식은 딱 1번 사용된다.
2. 조건식을 검증한다. 참이면 코드를 실행하고, 거짓이면 for 문 탈출
3. 코드 실행
4. 코드가 종료되면 증감식 실행. 주로 초기식에 넣은 반복 횟수와 관련된 변수의 값을 증가할 때 사용
5. 다시 2번의 조건식 부터 시작. (무한 반복)

※ for 문은 복잡해 보이지만 while 문을 조금 더 편하게 다룰 수 있도록 구조화한 것이다.

예제 코드)

# 1 ~ 10까지 출력하는 for문

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

1. 초기식이 실행된다. >> int 1 = 1
2. 조건식을 검증한다. >> i <= 10
3. 조건식이 참이면 코드를 실행한다. System.out.println(i);
4. 코드가 종료되면 증감식을 실행한다. i++
5. 다시 2번의 조건식을 검증한다. (무한 반복) >> 이후 i <= 10 조건이 거짓이 되면 for문 탈출

에제 코드)

package loop;

public class For1 {
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            System.out.println(i);
        }
    }
}

실행 결과)

문제 : i부터 하나씩 증가하는 수를 endNum(마지막 수 )까지 더해라 ( i ~ endNum 더하기)
for문 사용

문제 코드)

package loop;

public class For2 {
    public static void main(String[] args) {
        int sum = 0;
        int endNum = 3;

        for (int i = 1; i <= endNum; i++) {
            sum = sum + i;
            System.out.println("i = " + i + ", sum = " + sum);
        }
    }
}

실행 결과)

- for vs while

while 코드)

package loop;

public class While2_4 {
    public static void main(String[] args) {
        int sum = 0;
        int i = 1;
        int endNum = 100;

        while (i <= endNum) {
            sum = sum + i;
            System.out.println("i=" + i + ", sum=" + sum);
            i++;
        }
    }
}

# while문과 for문의 두 코드를 비교했을 때 for 문의 코드가 더 깔끔하다.

# for 문은 초기화, 조건 검사, 반복 후 작업 등이 규칙적으로 한 줄에 모두 들어가있어 이해하기 쉽다.

# 특히 반복을 위해 값이 증가하는 카운터 변수를 다른 부분과 명확하게 구분할 수 있다.

# while은 변수 i 를 선언하는 부분과 i++ 로 증가하는 부분이 분산되어 있다.

for (int i = 1; i <= endNum; i++)

위 코드에서 변수 i 가 카운터 변수다.

증가하면서 반복 횟수가 올라가고, 또 변수 i 를 사용해서 반복여부를 체크한 후 판단할 수 있다.

for문을 통해 반복 횟수에 직접적인 영향을 주는 변수 선언, 값 증가, 조건식 활용까지

for (초기식; 조건식; 증감식) 구조를 활용해 처리가 가능하다.

■ break, continue

# break 와 continue 는 반복문에서 사용할 수 있는 키워드다.

break 란?
break는 반복문을 즉시 종료하고 나간다.

continue 란?
continue 는 반복문의 나머지 부분을 건너뛰고 다음 반복으로 진행하는데 사용된다.
※ while, do-while, for 와 같은 모든 반복문에서 사용할 수 있다.

break 사용 예제)

while(조건식) {
    코드1;
    break; // 즉시 while문 종료로 이동
    코드2;
}
// while문 종료
※ break를 만나면 코드2가 실행되지 않고 while 문이 종료 된다.

continue 사용 예제)
while (조건식) {
    코드1;
    continue; // 즉시 조건식으로 이동
    코드2;
}
※ continue 를 만나면 코드2가 실행되지 않고 다시 조건식으로 이동한다.
조건식이 참이면 while 문을 실행한다.

문제 : 1부터 시작해서 숫자를 계속 누적해서 더하다가 합계가 10보다 처음으로 큰 값은 얼마인가?
1 + 2 + 3 ... 계속 더하다가 처음으로 합이 10보다 큰 경우를 차즈면 된다.

break 문제 코드)

package loop;

public class Break1 {
    public static void main(String[] args) {
        int sum = 0;
        int i = 1;

        while (true) {
            sum += i;
            if (sum > 10) {
                System.out.println("합이 10보다 크면 종료 : i =" + i + ", sum = " + sum );
                break;
            }
            i++;
        }
    }
}

실행 결과)

# 조건식을 살펴보면 true라 되어있다. 조건이 항상 참이기 때문에 while 문은 무한 반복된다.
   하지만 break 문이 있기 때문에 중간에 빠져나올 수 있다.

# 만약 sum > 10 조건을 만족하면 결과를 출력하고, break를 사용해서 while 문을 빠져나간다.

문제 : 1부터 5까지 숫자를 출력하는데, 숫자가 3일 떄는 출력을 건너 뛰어야한다.

continue 문제 코드)

package loop;

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

        while (i <= 5) {
            if (i == 3) {
                i++;
                continue;
            }
            System.out.println(i);
            i++;
        }
    }
}

실행 결과)

# i ==3 인 경우 i 를 하나 증가하고 continue 를 실행한다. 이 경우 i 를 바로 출력하지 않고 while ( i <= 5 ) 조건식 이동