[Java] 제어문 - if, switch/case, while - do while, for, for each

if문

if(조건문){
    조건문이 참일 경우 실행되는 블록
}

조건문: t/f 결과가 나오는 조건문이 와야함

 

연산자

• x && y :(and) x와 y 모두 참이어야 참이다
• x || y : (or) x와 y 둘 중 적어도 하나가 참이면 참이다
• !x : (not) x가 거짓이면 참이다

예제 : "돈이 3000원 이상 있거나 카드가 있다면 택시를 타고 그렇지 않으면 걸어가라"

int money = 2000;
boolean hasCard = true;

if (money>=3000 || hasCard) {
    System.out.println("택시 타기");
} else {
    System.out.println("걸어가라");
}

/* money는 3000보다 작지만, hascard가 true
따라서 money >= 3000 || hascard 조건문 참 -> 택시 타기 출력*/

 

메서드

• contains : List 자료형에서 해당 아이템이 있는지 조사하는 메서드

예제: "만약 주머니에 돈이 있으면 택시를 타고, 없으면 걸어가라“

ArrayList<String> pocket = new ArrayList<String>();
pocket.add("paper");
pocket.add("handphone");
pocket.add("money");

if (pocket.contains("money")) {
    System.out.println("택시를 타고 가라");
}else {
    System.out.println("걸어가라");
}

/* pocket 리스트에 안에 'money' 포함
따라서 pocket.contains("money")가 참 -> "택시를 타고 가라"가 출력 */

 

if-else / else if (다중 조건 판단)

• else if -> 이전 조건문이 거짓일 때 수행됨

예제: "지갑에 돈이 있으면 택시를 타고, 지갑엔 돈이 없지만 카드가 있으면 택시를 타고, 돈도 없고 카드도 없으면 걸어가라“

boolean hasCard = true;
ArrayList<String> pocket = new ArrayList<String>();
pocket.add("paper");
pocket.add("handphone");

if (pocket.contains("money")) { // 거짓
    System.out.println("택시를 타고 가라");
}else if(hasCard) { //이전 조건문이 거짓이므로 수행 -> hasCard=true이므로
    System.out.println("택시를 타고 가라"); // 출력
}else {         
    System.out.println("걸어가라");
}

if 로만 쓰면 다중 조건이 아니라, 앞 조건이 만족하더라도 모든 if문을 검사해야 함.

if- else if 둘 다 참일 경우에는 맨 위에만 하고 넘어가는데

if- if로 쓸 때 둘 다 참인 경우에는 다 실행 

 

• 삼항연산자: 항이 3개인 연산자
• 기본 구조: 조건식 ? 반환값1 : 반환값2
• 조건식이 참일 경우 반환값 1이 사용, 거짓일 경우 반환값 2가 사용됨.

int a=10;

int value = (a>5) ? 20 : 30;

System.out.println(value); //a>5가 참이므로 20이 출력

 

• if문장에 중괄호{} 블록이 없을 경우에는 if 조건문 바로 아래 한 줄만 조건에 만족할 때 실행됨
• 그 다음 문장은 if문이랑 관계 없음, indentation 주의

int a = 10;

if(a>5)
    System.out.println("a는 10보다 크다.")
    System.out.println("hello") // "hello" 는 무조건 출력됨

---

switch/case 문

• switch 블록 안에는 여러 개의 case 올 수 O, 하나의 default 올 수 O
• break문 생략 가능 -> break 없으면 조건에 맞는 부분부터 차례대로 case 문장이 다 실행됨
• switch 조건문에 들어갈 수 있는 입력 변수의 타입은 byte, short, char, int만 가능

int num = 1;
switch(num){
    case 1:
        System.out.println("1입니다.");
        break;
    case 2:
        System.out.println("2입니다.");
        break;
    case 3:
        System.out.println("3입니다.");
        break;
    default:
        System.out.println("1,2,3이 아닙니다.");
}

// 만약 break 가 없었다면 -> 1입니다, 2입니다, 3입니다 모두 출력됨

* enum 과 결합해서 많이 사용함

 

switch 관련 새 문법

• JDK 7 이상에서는 switch에서 String타입 사용 가능
• JDK 14, JDK 17에서 switch관련 새 문법 추가됨

 

• JDK 14 -> 화살표 case 라벨, 다중 case 라벨, switch 연산식, yield 예약어 등의 기능이 추가

public class SwitchTest {
 
    public static void main(String[] args) {
        switch1(Day.FRIDAY);                                // 6
        enhancedSwitch1(Day.FRIDAY);                        // 6
 
        System.out.println(switch2(Day.SATURDAY));          // 8
        System.out.println(enhancedSwitch2(Day.SATURDAY));  // 8
 
        System.out.println(enhancedSwitch3(Day.SUNDAY));    // Six 6
        System.out.println(enhancedSwitch4(Day.SUNDAY));    // Six 6
 
        switchError("ERROR");                            // -1
    }
    
/////////////////////////////////////////
 
    static void switch1(Day day) { //day의 길이를 출력하는 기존 switch문 예제 
        switch (day) {
            case MONDAY:
            case FRIDAY:
            case SUNDAY:
                System.out.println(6);
                break;
            case TUESDAY:
                System.out.println(7);
                break;
            case THURSDAY:
            case SATURDAY:
                System.out.println(8);
                break;
            case WEDNESDAY:
                System.out.println(9);
                break;
        }
    }
    
 
    static void enhancedSwitch1(Day day) { //다중 case 라벨(,)사용, 화살표 case 라벨(,)사용
        switch (day) {
            case MONDAY, FRIDAY, SUNDAY -> System.out.println(6);
            case TUESDAY                -> System.out.println(7);
            case THURSDAY, SATURDAY     -> System.out.println(8);
            case WEDNESDAY              -> System.out.println(9);
        }
    }
/* 화살표 case 라벨(->)을 사용할 때 실행문이 여러 개(즉, 2줄 이상)일 때는 중괄호로 묶어줘야 한다.
한마디로 화살표 case 라벨(->)을 사용할 때는 if 문이나 for 문처럼 실행문이 1줄일 때만 중괄호를 생략할 수 있다.*/
 
///////////////////////////////////////// 
 
    static int switch2(Day day) { //numLetters 변수에 day의 길이를 저장하는 기존 switch 문 예제
        int numLetters;
        switch (day) {
            case MONDAY:
            case FRIDAY:
            case SUNDAY:
                numLetters = 6;
                break;
            case TUESDAY:
                numLetters = 7;
                break;
            case THURSDAY:
            case SATURDAY:
                numLetters = 8;
                break;
            case WEDNESDAY:
                numLetters = 9;
                break;
            default:
                numLetters = -1;
        }
        return numLetters;
    }
  
 
    static int enhancedSwitch2(Day day) {
        // 변수를 선언하지 않고 바로 return하는 것도 가능
        return switch (day) {
            case MONDAY, FRIDAY, SUNDAY -> 6;
            case TUESDAY                -> 7;
            case THURSDAY, SATURDAY     -> 8;
            case WEDNESDAY              -> 9;
        };
 
//        int numLetters = switch (day) {
//            case MONDAY, FRIDAY, SUNDAY -> 6;
//            case TUESDAY                -> 7;
//            case THURSDAY, SATURDAY     -> 8;
//            case WEDNESDAY              -> 9;
//        };
//        return numLetters;
    }
 
    // return type이 Object인 경우 다양한 type 사용 가능, 화살표 뒤 값이 void type이면 에러발생
//    static Object enhancedSwitch2(Day day) {
//        return switch (day) {
//            case MONDAY, FRIDAY, SUNDAY -> 6;
//            case TUESDAY                -> "Seven";
//            case THURSDAY, SATURDAY     -> 8;
//            case WEDNESDAY              -> 9;
//        };
//    }

/////////////////////////////////////////
 
    static int enhancedSwitch3(Day day) { //길이를 return하기 전에 특정 메시지를 출력하고 싶을 때
        return switch (day) {
            case MONDAY, FRIDAY, SUNDAY -> {
                System.out.print("Six ");
                yield 6;  //중괄호 안에서만 yield 예약를 사용할 수 있음
            }
            case TUESDAY -> 7; // ->yield 7; 이면 에러
            case THURSDAY, SATURDAY -> 8;
            case WEDNESDAY -> 9;
        };
    }
 
    static int enhancedSwitch4(Day day) {
        return switch (day) {
            case MONDAY, FRIDAY, SUNDAY:
                System.out.print("Six ");
                yield 6; //case 라벨(:) 에서도 사용 가능
            case TUESDAY:
                yield 7;
            case THURSDAY, SATURDAY:
                yield 8;
            case WEDNESDAY:
                yield 9;
        };
    }
    
/////////////////////////////////////////
 
    static int switchError(String s) {
        return switch (s) {
            case "MONDAY", "FRIDAY", "SUNDAY"   -> 6;
            case "TUESDAY"                      -> 7;
            case "THURSDAY, SATURDAY"           -> 8;
            case "WEDNESDAY"                    -> 9;
            default                             -> -1;
        };
    }
 
    enum Day { MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY }
    
    /* if default값이 없으면 'switch' expression does not cover all possible input values 에러 발생.
    위 예제는 String type이므로 가능한 모든 값은 거의 무한대나 마찬가지.
    String대신 int type이고, default를 사용하지 않는다면 int 범위의 모든 값에 대하여 case를 사용해야 할 것.
	따라서 default를 사용하거나, 필요한 값들로 열거 타입(enum)을 만들어서 사용해야 함
}

• https://congcoding.tistory.com/73

[Java 14] 개선된 switch 문(Enhanced Switch Expressions)

 

 

• JDK 17 -> instanceof 사용을 문자열 포맷팅,출력서식 %로 변환 가능 , null 지원, &&연산자 지원

static String formatter(Object o) { // instanceof를 사용한 기존 switch 문
    String formatted = "unknown";
    if (o instanceof Integer i) {
        formatted = String.format("int %d", i);
    } else if (o instanceof Long l) {
        formatted = String.format("long %d", l);
    } else if (o instanceof Double d) {
        formatted = String.format("double %f", d);
    } else if (o instanceof String s) {
        formatted = String.format("String %s", s);
    }
    return formatted;
}

static String formatterPatternSwitch(Object o) { // 문자열 포맷팅 %로 변환 가능
    return switch (o) {
        case Integer i -> String.format("int %d", i);
        case Long l    -> String.format("long %d", l);
        case Double d  -> String.format("double %f", d);
        case String s  -> String.format("String %s", s);
        default        -> o.toString();
    };
}

//Switch Expression example
switch (o) {
	case Integer i -> String.format("int %d", i);
    case Long l    -> String.format("long %d", l);
}
//Switch Statement example
switch (o) {
  case Integer i: 
    String.format("int %d", i);
    break;
  case Long l:
    String.format("long %d", l); 
    break;
}

//////////////////////

switch (o) { // null 사용 지원
  case null     -> System.out.println("null!");
  case String s -> System.out.println("String");
  default       -> System.out.println("Something else");
}

//////////////////////

switch(value) { // &&연산자 지원
  case String s && (s.length > 3) -> System.out.println("A short string");
  case String s && (s.length > 10 -> System.out.println("A medium string");
  default -> System.out.println("A long string");
}

• https://blog.adamgamboa.dev/switch-expression-on-java-17/

Switch expression on Java 17

• https://openjdk.org/jeps/406

---

while문

/* 기본 구조 */
변수의 초기화
while(탈출 조건식){
    탈출 조건식이 참일 경우 실행되는 코드;
    변수의 증감식;
}

//예제
int treeHit = 0;
while (treeHit < 10) {
    treeHit++; // treeHit+=1;
    System.out.println("나무를  " + treeHit + "번 찍었습니다.");
    if (treeHit == 10) {
        System.out.println("나무 넘어갑니다.");
    }
}

 

무한 loop

• false는 빠져나감, 항상 true면 무한Loop

while (true) {
    System.out.println("Ctrl+C를 눌러야 while문을 빠져 나갈 수 있음.");
}

 

break/continue

int coffee = 10;
int money = 300;

while (money > 0) { // money = 300이므로 항상 참 
    System.out.println("돈을 받았으니 커피를 줍니다.");
    coffee--; // 커피 개수 한 개씩 줄어듦 
    System.out.println("남은 커피의 양은 " + coffee + "입니다.");
    if (coffee == 0) {
        System.out.println("커피가 다 떨어졌습니다. 판매를 중지합니다.");
        break; // while문 빠져나옴
    }
}

//////////////////////

int a = 0;
while (a < 10) {
    a++;
    if (a % 2 == 0) {
        continue;  // 짝수인 경우 조건문으로 돌아간다.
    }
    System.out.println(a);  // 홀수만 출력된다.
}

• intellij - break point와 step over 기능 있음

* 이클립스도 있음?

 

do/while문

• 무조건 한 번은 실행됨

public class t {
	public static void main(String[] args) {
		int num = 6;
		do {
			System.out.println(num); // 6 출력
			num++; // 값이 1 증가
		} while (num <= 5); // 6이므로 false -> while 반복문 종료
		System.out.println("program and.... "); // 출력
	}
}

---

for문

/* 기본 구조 */
for(변수 초기화; 조건문; 증감식){
    탈출 조건식이 참인 경우 실행되는 부분
}

// 예제 
String[] numbers = {"one", "two", "three"};
for(int i=0; i<numbers.length; i++) {
    System.out.println(numbers[i]);
}

• 문자열+정수/불린/실수 -> 문자열됨
• "one" + 1 = "one1" 

- 모든 연산자 operator는 피연산자끼리 type이 같아야되는데 여기서 가능한 이유는 1이라는 정수가 문자열로 자동적으로 한 번 변환이 됐기 때문에 가능함.

- 특히 대입 연산자도 왼쪽, 오른쪽 성질이 같아야 함. (자료형을 명시를 해야하는 언어들에서) 

 

이중 for문

// 구구단 출력 예제

for(int i=2; i<10; i++) {
    for(int j=1; j<10; j++) {
        System.out.print(i*j+" ");
    }
    System.out.println("");  // 줄을 바꾸어 출력하는 역할
}

//출력 결과
2 4 6 8 10 12 14 16 18 
3 6 9 12 15 18 21 24 27 
4 8 12 16 20 24 28 32 36 
5 10 15 20 25 30 35 40 45 
6 12 18 24 30 36 42 48 54 
7 14 21 28 35 42 49 56 63 
8 16 24 32 40 48 56 64 72 
9 18 27 36 45 54 63 72 81

 

continue

//  60점 이상인 사람에게만 축하 메시지를 보내는 예제

int[] marks = {90, 25, 67, 45, 80};
for(int i=0; i<marks.length; i++) {
    if (marks[i] < 60) {
        continue;  // 조건문으로 돌아간다.
    }
    System.out.println((i+1)+"번 학생 합격입니다.");
}

• for문 안에서 break 문장 만나면 for문 벗어남

 

for each문

// 기본 구조
for (type var: iterate) {
    body-of-loop
}

// 기존 for문
String[] numbers = {"one", "two", "three"};
for(int i=0; i<numbers.length; i++) {
    System.out.println(numbers[i]);
}

// for each 구조
String[] numbers = {"one", "two", "three"};
for(String number: numbers) {
    System.out.println(number);
}

 

• iterate는 루프를 돌릴 객체
• iterate 객체에서 한개씩 순차적으로 var에 대입되어 for문이 수행된다.
• iterate로 사용할 수 있는 자료형: 루프를 돌릴수 있는 자료형(배열 및 ArrayList 등)만 가능
• for each 문은 따로 반복 횟수를 명시적으로 주는 것이 불가능하고, 1스탭씩 순차적으로 반복할때만 사용가능하다는 제약

 

label

• break와 continue문의 한계 
  • break는 현재 반복문을 빠져나가는데 사용
  • continue는 continue문 아래 부분을 실행하지 않고 다시 반복
  • 중첩반복문을 한번에 빠져나가기/ continue이하를 실행하지 않고 한번에 중첩 반복 할 때 => label 사용

 

; break label 사용

public static void main(String[] args) {
        out: // label명 지정
        for (int i = 1; i <= 2; i++) {
            System.out.println("첫 번째 for문");
            for (int k = 1; k <= 10; k++) {
                if(k==3) break out; 
                System.out.println("두 번째 for문");
            }
        }
    }
    
/* 출력 내용
첫 번째 for문
두 번째 for문
두 번째 for문   */

원래 break문 근접한 하나의 반복문만 벗어남

but label 사용: 벗어나야 할 반복문 지정 -> 최상단 반복문 벗어남 -> 중첩반복문 한 번에 빠져나가게 됨

 

; continue label 사용

public static void main(String[] args) {
        out: // label명 지정
        for (int i = 0; i < 3; i++) {
            for (int k = 1; k < 4; k++) {
                if(k%2 ==0) {
                	continue out; 
            }
            System.out.print(k+" ");
        }
        System.out.println();
    }
}
//1 1 1 출력

1. k가 2가 되면 k%2 == 0 -> for문의 맨 처음으로 돌아감 (외부 for문 하단에 줄 바꿈을 하지 않고)
2. i = 1,2 모두 n은 1일 때 출력하고 2가 되면 다시 돌아감 
3. i는 3이 되고 3 < 3으로 조건식에 성립되지 않아 반복문을 종료

---

<참고>

• https://wikidocs.net/189
• https://www.inflearn.com/course/즐거운-자바/dashboard