---
title: "Java 정리 06"
date: "2018-11-20"
tags: ["Java"]
status: archived
verified: false
---

## Java 정리 06 - switch, 반복문 for

---

### switch case
	
* 특정 case만 사용하고 빠져나갈 때 분기문 break; 사용
     * **break 는 필수아닌 옵션**
     * case별로 break를 넣는게 처리행수를 줄이기 때문에 좋음
* case값은 작은값에서 큰값순으로 배치하는게 좋음
     * 또한 규칙이 있는 증가값을 갖는게 좋음

```java
swtich(변수명) {
    case 상수 : 
        // 실행될 코드 
        break; 
    ...

    default :
        // 상수와 같은 값이 아닐 때 실행될 코드
}
```

```java
// switch~case를 사용한 학점 구하기
// 100~90점은 A, 89~80점은 B, 79~70점은 C, 69~60은 D, 59~0 F 학점을 부여
public class TestSwitchCase {
     
     public static void main(String[] args) {

           // char는 공백문자(white space)로 초기화
           // 공백문자 unicode '\u0000', 코딩으로 직접 쓸순 없다           // ''는 문자없음, error
           char grade = ' ';
           int score = Integer.parseInt(args[0]);
           
           // 자바에선 정수/정수 = 정수
           switch(score/10) {
           case 10 :
           case 9  : grade = 'A'; break;
           case 8  : grade = 'B'; break;
           case 7  : grade = 'C'; break;
           case 6  : grade = 'D'; break;
           default : grade = 'F';
           }
           System.out.println(score+"점은 "+ grade+" 학점");
     }
}
```

![01](/md/legacy-assets/java/06/01.webp)

```java
// 위에 코드를 ASCII를 사용해서 아래같이 짤 수도 있다
public class TestSwitchCase2 {
     public static void main(String[] args) {

           int score = 96;
           char grade = 64;

           // ASCII
           // 65-A, 66-B, 67-C, 68-D, 69-E, 70-F
           switch(score/10) {
           case 6: grade++; // 68
           case 7: grade++; // 67
           case 8: grade++; // 66
           case 9:
           case 10: grade++; break; // 65 - A
           default: grade+=6;   // 70 - F
           }
           
           System.out.println(score + "점은 " + grade + "  학점");
     }
}
// 이렇게 구현 시 가독성이 많이 떨어짐(6이 뭔데? 7은? 8은?..) = 나쁜코드
// case에 변수 못 들어옴, 상수를 쓰면 가독성이 떨어짐  -> Constant를 사용
```

```java
// switch~case에는 상수보단 Constant를 넣어 가독성을 높이는게 좋은 코드!
public class TestSwitchCase2 {
     
     public static final int GRADE_A_PLUS = 10;
     public static final int GRADE_A = 9;
     public static final int GRADE_B = 8;
     public static final int GRADE_C = 7;
     public static final int GRADE_D = 6;
     
     public static void main(String[] args) {
           int score = 96;
           char grade = 64;
           
           // case의 상수는 가독성이 떨어지기 때문에
           // 읽기 편하도록 Constant를 사용
           switch(score/10) {
           case TestSwitchCase2.GRADE_D: grade++; // 68
           case TestSwitchCase2.GRADE_C: grade++; // 67
           case TestSwitchCase2.GRADE_B: grade++; // 66
           case TestSwitchCase2.GRADE_A:
           case TestSwitchCase2.GRADE_A_PLUS: grade++; break; //  65 - A
           default: grade+=6;   // 70 - F
           }
           
           System.out.println(score + "점은 " + grade + "  학점");
     }
}
```

```java
// if문으로 유효성 검사를 할 수 있다
if (score <= 100 && score >= 0) {
     ...
} else {
     System.out.println("점수는 0~100점 사이만 입력  가능");
}
```

---

### 반복문

* 코드의 실행을 여러번 해야 할 때 사용
* **for, while, do~while**
     * for - 시작과 끝을 알 때 사용
     * while - 시작과 끝을 모를 때 사용
          * while은 0~n번 수행
          * do ~while - while과 다르게 **최소 1번**은 수행
* 조건을 잘못 부여하면 **무한LOOP**에 빠지게 됨

### for

* **시작과 끝을 알 때 사용**
* **비교식에 \&lt;= 는 작은지 한번 같은지 한번 두번 묻는다!**
     * 추가연산발생하므로 **가급적이면 \&lt;, \>사용**


![02](/md/legacy-assets/java/06/02.webp)

```java
for (int i=0; i<5 ;i++) {
    System.out.println(i);
}
// i는 0, i<5와 비교 참, 0 출력, i++
// i는 1, i<5와 비교 참, 1 출력, i++
// i는 2, i<5와 비교 참, 2 출력, i++
// i는 3, i<5와 비교 참, 3 출력, i++
// i는 4, i<5와 비교 참, 4 출력, i++
// i는 5, i<5와 비교 거짓, 반복문 빠져나옴
```

```java
public class TestFor2 {
     public static void main(String[] args) {
           
           int cnt = 0;
           // 1에서 부터 100까지 홀수만 출력
           for (int i=1; i<101; i++) {
                cnt++;
                if(i%2 == 1) {
                     System.out.print(i+" ");
                }
           }
           System.out.println();
           System.out.println(cnt); // 100
           
           // 증감소식은 변수에 값을 변환시키고 유지 시킬 수  있는
           // 모든 연산자를 사용할 수 있다.
           cnt = 0;
           for (int i=1; i<101; i+=2) {
                cnt++;
                System.out.print(i+" ");
           }
           System.out.println();
           System.out.println(cnt); // 50
     }
}
```

![03](/md/legacy-assets/java/06/03.webp)

```java
public class TestFor3 {
     
     public static void main(String[] args) {
           
           // 1~100까지 출력하기 3의 배수마다 숫자대신 "짝"을  출력
           for (int i=1; i<101; i++) {
                if (i%3 == 0) {
                     System.out.println("짝");
                     continue;
                }
                System.out.println(i);
           }
     }
}
```

![04](/md/legacy-assets/java/06/04.webp)

```java
public class TestFor4 {
     
     public static void main(String[] args) {
           
           // 1~100까지의 합 출력 : 1에서 100까지의 합은 5050
           int sum = 0;
           for (int i=1; i<101; i++) {
                sum += i;
           }
           System.out.println(sum);
     }
}
```

```java
public class TestFor5 {
     
     public static void main(String[] args) {
           
           // A~Z까지 출력 65~90
           // ASCII casting 사용하는 방법
           for (int i=65; i<91; i++) {
                System.out.print((char)i+" ");
           }
           System.out.println();
           
           // char로 바로 하는 방법
           for (char c='A'; c<='Z'; c++) {
                System.out.print(c + " ");
           }
           System.out.println();
     }
}
```

![05](/md/legacy-assets/java/06/05.webp)

### 다중 for

* for안에 for문을 정의하는 것

```java
for (초기값; 조건식; 증감식) {
    // 단일 for 영역
    for (초기값; 조건식; 증감식) {
        // 다중 for 영역
        // 바깥 for index와 안에있는 for index를 같이 사용가능 
    }
    // 단일 for 영역
}
```

![06](/md/legacy-assets/java/06/06.webp)

```java
for(int i=0;i<2;i++) {
    for(int j=0;j<3;j++) {
        System.out.println(i+"  "+j);
    }
}
```

```java
public class TestFor7 {
      public static void main(String[] args) {
            
            // 구구단 전단 출력
            for (int i=2; i<10; i++) { // 단
                  
                  System.out.println(i+"단 시작");
                  for (int j=1;j<10;j++) {
                        System.out.println(i+" * "+j+" = "+(i*j));
                  }
                  System.out.println(i+"단 끝");
            }
      }
}
```

```java
/**
*  0 0
*  1 0 1 1
*  2 0 2 1 2 2
*  3 0 3 1 3 2 3 3
*  출력하기
*/
public class TestFor8 {
     public static void main(String[] args) {
           
           for(int i=0; i<4; i++) {
                for(int j=0; j<=i; j++) {
                     System.out.print(i+" "+j+" ");
                }
                System.out.println();
           }
     }
}
```

![07](/md/legacy-assets/java/06/07.webp)

```java
/**
*  0 1 0 2 0 3 0 4
*  1 2 1 3 1 4
*  2 3 2 4
*  3 4
*  출력하기
*/
public class TestFor9 {
     public static void main(String[] args) {
           
           for(int i=0;i<4; i++) {
                for (int j=i+1; j<5; j++) {
                     System.out.print(i + " " + j + " ");
                }
                System.out.println();
           }
     }
}
```

![08](/md/legacy-assets/java/06/08.webp)

---

### 무한 LOOP

* 종료되지 않는 프로그램을 작성 시 사용
* **무한LOOP 아랫줄의 코드는 실행될 수 없기 때문에 코드를 작성하면 에러발생**
* break가 존재하면 반복문을 빠져나가는 조건이 있기 때문에 무한 loop가 아님
     * **break는 가장 인근에 존재하는 반복문을 빠져나감**


```java
// 무한LOOP
for(;;) { 
    반복수행문장;
}
```

```java
// 증가하는 수를 세는 무한 LOOP
for(초기값;;증감소식) {

}
```

```java
// 하나의 for문에서 index를 여러개 사용가능
// 초기값을 여러개 설정가능
for(초기값, 초기값, .. ; 조건식 ; 증감식,.. ) {

}
```

```java
public class TestFor10 {
     
     public static void main(String[] args) {
           
           // 무한루프
           for(;;) {
                System.out.println("무한루프");
           }
           
           // System.out.println("무한루프 다음코드");
           // Unreachable code error발생
     }
}
```

![09](/md/legacy-assets/java/06/09.webp)

```java
// 증가하는 수를 세는 무한 LOOP
for (int i=0;;i++) {
     System.out.println("무한루프" + i);
}
```

```java
for (int i=0;;i++) {
     System.out.println("무한루프" + i);
     
     // 다중 for의 경우 break는 가장 가까이 있는 for만 빠져나감
     if (i==50)
           break;
}
```

```java
// 여러개의 초기값을 사용하는 for
for(int i=0, j=10, k=30; i<10; i++, j++, k--) {
     System.out.println(i+" "+j+" "+k);
}
```

```java
// 조건식을 잘못 설정하면 무한루프
for(int i=0; i < 10; i--) {
     System.out.println("무한루프 " + i);
}
```

```java
// for문 뒤에 ;가 있는 경우 한번 실행됨
// for문 수행 후 sysout 한번 수행
int i = 0;
for(i=0; i< 10; i++); {
     System.out.println("반복문"+i);
}
```

---

### 향상된 for

* **jdk 1.5**에서 추가된 문법
* 이전 for는 인덱스를 얻기 위해 사용
* **향상된 for는 인덱스를 사용할 수 없음**
     * **Array, Collection(List, Set)의 모든 방(요소)의 값을 출력하기 위해 제공되는 for**
* 많은 양의 데이터를 출력할 때 기존 for보다 느리다.

```java
for (데이터형 변수명 : 배열명|Collection명) {
    // 변수에는 배열 또는 Collection의 요소 값이 저장됨
}
```

```java
public class EnhancedFor01 {
     public static void main(String[] args) {
           
           int[] arr = {10, 20, 300, 15};
           
           System.out.println("기존 for");
           // 기존 for의 i는 요소의 인덱스
           for(int i=0; i<arr.length;i++) {
                System.out.println(arr[i]);
           }
           
           System.out.println("향상된 for");
           
           // 향상된 for에선 i가 요소의 값을 갖게 됨
           for(int i:arr) {
                System.out.println(i);
           }
     }
}
```

![10](/md/legacy-assets/java/06/10.webp)

```java
import java.util.ArrayList;
import java.util.List;
public class EnhancedFor3 {
     
     public static void main(String[] args) {
           
           // Collection
           List<Integer> list = new ArrayList<>();
           
           list.add(10);
           list.add(20);
           list.add(110);
           list.add(1);
           
           System.out.println("---------List 이전  for----------");
           for(int i=0; i<list.size();i++) {
                System.out.println(list.get(i));
           }
           
           System.out.println("---------List 개선된  for----------");
           for(int i : list) {
                System.out.println(i);
           }
     }
}
```

![11](/md/legacy-assets/java/06/11.webp)


---

### jdk 컴파일 버전 변경

* 프로젝트 선택 - Properties(Alt+Enter) - Java Compiler  - 기존 1.8 check 풀면 다른 컴파일러 버전 선택가능
     * 향상된 for문은 1.5부터 사용가능
     * 이전 버전 컴파일러 선택 시 사용불가능해지는 기능들이 있음

![12](/md/legacy-assets/java/06/12.webp)

![13](/md/legacy-assets/java/06/13.webp)

---

### continue


* **반복문의 실행을 건너 뛸 때 사용**
     * 조건문으로 묶어서 사용
     * 반복수행 코드 위에 정의한다.

```java
for (int i=0; i<10; i++) {
    // if 없이 사용하면 에러발생
    continue;
    System.out.println("안녕"); // Unreachable code error!
}
```

![14](/md/legacy-assets/java/06/14.webp)

```java
public class TestContinue {
     public static void main(String[] args) {
           
           // 0~100까지 홀수만 출력
           for(int i=0; i<100; i++) {
                
                if (i%2 == 0) {
                     continue;
                }
                System.out.println("i = " + i);
           }
     }
}
```

---

[숙제풀이1](https://github.com/younggeun0/SSangYoung/blob/master/dev/workspace/javase_prj/src/date181120/HW1.java)
[숙제풀이1 flowchart](/md/legacy-assets/java/06/15.webp)

[숙제풀이2](https://github.com/younggeun0/SSangYoung/blob/master/dev/workspace/javase_prj/src/date181120/HW2.java)