Java - 중첩 for문,while문

public class Ex {
 
    public static void main(String[] args) {
        /*
         * for문을 사용하여 특정 단의 구구단 출력
         * 
         *  < 2단 >
         * 2 * 1 = 2
         * 2 * 2 = 4
         * 2 * 3 = 6
         * 2 * 4 = 8
         * 2 * 5 = 10
         * 2 * 6 = 12
         * 2 * 7 = 14
         * 2 * 8 = 16
         * 2 * 9 = 18
         */
        
        System.out.println(" < 2단 >");
        System.out.println("2 * 1 = 2");
        System.out.println("2 * 2 = 4");
        System.out.println("2 * 3 = 6");
        System.out.println("2 * 4 = 8");
        System.out.println("2 * 5 = 10");
        System.out.println("2 * 6 = 12");
        System.out.println("2 * 7 = 14");
        System.out.println("2 * 8 = 16");
        System.out.println("2 * 9 = 18");
        
        System.out.println("----------------------");
        
        int dan = 4;
        int i = 1;
//        
//        System.out.println(" < " + dan + "단 >");
//        System.out.println(dan + " * " + i + " = " + (dan * i));
//        i++;
//        System.out.println(dan + " * " + i + " = " + (dan * i));
//        i++;
//        System.out.println(dan + " * " + i + " = " + (dan * i));
//        i++;
//        System.out.println(dan + " * " + i + " = " + (dan * i));
//        i++;
//        System.out.println(dan + " * " + i + " = " + (dan * i));
//        i++;
//        System.out.println(dan + " * " + i + " = " + (dan * i));
//        i++;
//        System.out.println(dan + " * " + i + " = " + (dan * i));
//        i++;
//        System.out.println(dan + " * " + i + " = " + (dan * i));
//        i++;
//        System.out.println(dan + " * " + i + " = " + (dan * i));
//        i++;
        
        // ----------------------------------------------
        // for문을 사용하여 구구단 출력
        dan = 9;
        System.out.println(" < " + dan + "단 >");
        
        for(i = 1; i <= 9; i++) {
            System.out.println(dan + " * " + i + " = " + (dan * i));
            
        }
        
/*
         * 반복문을 사용한 합계 계산(= 연산의 누적)
         * 1. 연산을 누적할 누적 변수 선언 및 초기화
         * 2. 반복문을 사용하여 특정 범위 반복
         * 3. 반복문 내에서 특정 데이터를 누적 변수에 누적
         * 4. 반복문 종료 후 누적 변수 값 출력
         */
        
        // 1 ~ 10 까지의 합(total)을 계산하여 출력
        int total = 0; // 누적 변수 선언 및 초기화(합계 계산을 위해 0 으로 초기화)
        
//        for(int i = 1; i <= 10; i++) {
//            // 누적변수 total 에 i 값을 누적
//            total += i; // total = total + i;
//        }
        
        
        int num = 1;
        
        for(int i = 0; i < 10; i++) {
            // 누적변수 total 에 num 값을 누적 후 num 값 1 증가시킴
            total += num;
            num++;
        }
        
        System.out.println("1 ~ 10 까지의 합 : " + total);
        
 
/*
         * 중첩 for문
         * - for문 안에 또 다른 for문을 기술하는 것
         * - 바깥쪽 for문과 안쪽 for문으로 구분됨
         *   => 바깥쪽 for문이 1바퀴 돌 때, 안쪽 for문은 여러바퀴를 돈다.
         *      (= 즉, 안쪽 for문 반복 횟수가 바깥쪽 for문 반복횟수보다 많다)
         *   
         * < 기본 문법 >
         * for(초기식1; 조건식1; 증감식1) { // 바깥쪽 for문
         *
         *        문장1; // 조건식1 이 true 일 때 실행되는 문장
         *
         *        // 조건식1 이 true 일 때 실행되는 문장(안쪽 for문을 지정된 횟수만큼 반복 실행)
         *         for(초기식2; 조건식2; 증감식2) { // 안쪽 for문
         * 
         *             문장2; // 전체 반복 횟수 = 안쪽 for문 반복횟수 * 바깥쪽 for문 반복횟수
         * 
         *         }
         * 
         *         문장3; // 안쪽 for문 반복이 종료된 후 실행되는 문장
         * 
         * }
         * 
         */
        
        // 바깥쪽 for문 : i값이 1 ~ 3 까지 1씩 증가하면서 반복
        for(int i = 1; i <= 3; i++) {
            System.out.println("i = " + i);
            
            // 안쪽 for문 : j값이 1 ~ 2 까지 1씩 증가하면서 반복
            for(int j = 1; j <= 2; j++) {
                System.out.println("-------------> j = " + j);
            }
            
            System.out.println("------- 안쪽 for문 반복 종료");
            
        }
        
        System.out.println("바깥쪽 for문 반복 종료");
        
for(int line = 1; line <= 5; line++) { // 전체 라인 수
            
            for(int i = 1; i <= 5; i++) { // 한 라인에서 출력할 * 갯수
                System.out.print("*");
            }
            
            System.out.println(); // 줄바꿈
            
        }
        
        /*
         *  *       =>  1번 라인 : 1개
         *  **      =>  2번 라인 : 2개
         *  ***     =>  3번 라인 : 3개
         *  ****    =>  4번 라인 : 4개
         *  *****   =>  5번 라인 : 5개
         */
        
        for(int line = 1; line <= 10; line++) { // 전체 라인 수
            
            for(int i = 1; i <= line; i++) { // 한 라인에서 출력할 * 갯수
                System.out.print("*");
            }
            
            System.out.println(); // 줄바꿈
            
        }
        
        System.out.println("-----------------");
        
        /*
         *  *****   =>  1번 라인 : 5개(5 4 3 2 1)  (1 2 3 4 5)
         *  ****    =>  2번 라인 : 4개(5 4 3 2)    (1 2 3 4)
         *  ***     =>  3번 라인 : 3개(5 4 3)      (1 2 3)
         *  **      =>  4번 라인 : 2개(5 4)        (1 2)
         *  *       =>  5번 라인 : 1개(5)          (1)
         */
        
        for(int line = 5; line >= 1; line--) { // 전체 라인 수
            
            for(int i = 1; i <= line; i++) { // 한 라인에서 출력할 * 갯수
                System.out.print("*");
            }
            
            System.out.println(); // 줄바꿈
            
        }
        
        System.out.println("-----------------");
        
        for(int line = 1; line <= 5; line++) { // 전체 라인 수
            
            for(int i = 5; i >= line; i--) { // 한 라인에서 출력할 * 갯수
                System.out.print("*");
            }
            
            System.out.println(); // 줄바꿈
            
        }
        
        System.out.println("-----------------");
        // 소수 계산
        for(int i = 1; i <= 100000; i++) { // 정수 1 ~ 100 까지 반복
            int count = 0;
 
            for(int j = 1; j <= i; j++) { // 정수를 1 부터 자기자신까지 반복
                if(i % j == 0) { // 정수i 가 1부터 자기자신까지 차례대로 나누어 떨어질 때
                    count++; // 카운트 증가
                }
            }
            
            if(count <= 2) { // 나누어 떨어지는 숫자가 2개 이하일 때
                System.out.println(i + " ");
            }
 
        }
 
/*
         * while 문
         * - for문과 마찬가지로 특정 조건식 결과가 true 일 동안 반복 수행하는 반복문
         * - for문과 달리 조건식 위치만 정해져있고, 초기식과 증감식 위치는 유동적
         * - for문은 주로 반복 횟수가 정해져 있는 경우 사용하며,
         *   while문은 주로 반복 횟수가 정해져 있지 않은 경우 사용
         * - for문과 while문은 100% 상호변환이 가능하다!
         * 
         * < 기본 문법 >
         * 초기식;
         * 
         * while(조건식) {
         *         // 조건식 결과가 true 일 때 반복할 문장
         *         // 증감식(반복할 문장보다 위에 위치할 수도 있다!)
         * }
         */
        
        for(int i = 1; i <= 10; i++) {
            System.out.println(i + " : Hello, World!");
        }
        
        System.out.println("----------------------");
        
        // 위의 for문을 while문으로 변환
        int i = 1; // 초기식
        
        while(i <= 10) { // 조건식
            // 조건식 결과가 true 일 때 실행할 문장
            System.out.println(i + " : Hello, World!"); 
            i++; // 증감식
        }
        
        System.out.println("----------------------");
        
        // 1 ~ 10 까지 1씩 증가하면서 반복   =>  1 2 3 4 5 6 7 8 9 10
        i = 1;
        
        while(i <= 10) {
            System.out.print(i + " ");
            i++;
        }
        
        System.out.println();
        System.out.println("----------------------");
        
        // 1 ~ 10 까지 2씩 증가하면서 홀수 출력 => 1 3 5 7 9
        i = 1;
        
        while(i <= 10) {
            System.out.print(i + " ");
            i += 2;
        }
        
        System.out.println();
        System.out.println("----------------------");
        
        // 2 ~ 10 까지 2씩 증가하면서 짝수 출력 => 2 4 6 8 10
        i = 2;
        
        while(i <= 10) {
            System.out.print(i + " ");
            i += 2;
        }
        
        System.out.println();
        System.out.println("----------------------");
        
        // 10 ~ 1 까지 1씩 감소하면서 i 출력 => 10 9 8 7 6 5 4 3 2 1
        i = 10;
        
        while(i >= 1) {
            System.out.print(i + " ");
            i--;
        }
 
 
// for문과 if문을 조합하여
        // 1 ~ 10 까지의 정수 중에서 짝수만 누적 후 출력
        // 2 + 4 + 6 + 8 + 10 = 30 출력
//        int total = 0;
//        
//        for(int i = 1; i <= 10; i++) {
//            // i값이 짝수일 때만 total 에 누적
//            if(i % 2 == 0) {
//                total += i;
//            }
//        }
//        
//        System.out.println("1 ~ 10 까지 짝수의 합 : " + total);
        
        // --------------------------------------
        // 1 ~ 10 까지의 정수 중에서 짝수는 evenTotal, 홀수는 oddTotal 에 누적 후 출력
        int oddTotal = 0, evenTotal = 0;
        
        for(int i = 1; i <= 10; i++) {
            if(i % 2 == 0) { // 짝수일 때
                evenTotal += i;
            } else { // 홀수일 때
                oddTotal += i;
            }
        }
        
        System.out.println("1 ~ 10 까지 홀수 합 : " + oddTotal); // 25
        System.out.println("1 ~ 10 까지 짝수 합 : " + evenTotal); // 30
        
// 바깥쪽 for문 i값이 1 ~ 10까지 반복할 동안,
        // 안쪽 for문 j값이 1 ~ 5까지 반복
        for(int i = 1; i <= 10; i++) {
//            System.out.println("i = " + i);
            
            for(int j = 1; j <= 5; j++) {
                System.out.println("i = " + i + ", j = " + j);
            }
            
        }
        
        /*
         * 타이머(XX분 XX초)
         * => 분(min : 0 ~ 59분), 초(sec : 0 ~ 59초)
         * 
         * < 출력 예시 >
         * 0분 0초
         * 0분 1초
         * 0분 2초
         * ... 생략 ...
         * 0분 59초
         * 1분 0초
         * 1분 1초
         * ... 생략 ...
         * 59분 58초
         * 59분 59초
         */
        
        for(int min = 0; min <= 59; min++) {
//            System.out.println(min + "분");
            
            for(int sec = 0; sec <= 59; sec++) {
                System.out.println(min + "분 " + sec + "초");
            }
            
        }
        
        System.out.println("-------------------------------");
        
        /*
         * 중첩 for문을 사용하여 2단 ~ 9단까지의 구구단 출력
         * 
         *  < 2단 >
         * 2 * 1 = 2
         * 2 * 2 = 4
         * 2 * 3 = 6
         * 2 * 4 = 8
         * ...생략...
         * 
         *  < 3단 >
         * 3 * 1 = 3
         * ...생략...
         * 
         *  < 9단 >
         * ...생략...
         * 9 * 9 = 81
         * 
         * => 단(dan) 이 2 ~ 9 까지 1씩 증가
         * => 이 때, 각 단에서 i값이 1 ~ 9 까지 1씩 증가
         * 
         */
 
        for(int dan = 2; dan <= 9; dan++) {
        
            System.out.println(" < " + dan + "단 >");
            
            for(int i = 1; i <= 9; i++) {
                
                System.out.println(dan + " * " + i + " = " + (dan * i));
                
            }
            
            System.out.println(); // 줄바꿈
            
        }
 
    }
 
}

중첩 for 문을 활용하여 계산된 값들을 누적시켜 보았고 *(아스테리스크)를 출력시켜보는 문장을 연습해 보았다. 간단한 문장들로 이런 결과물들을 볼 수 있다는 게 너무 신기했고, 갈수록 재미있어지는 것 같다. 구구단 같은 경우에도 머리를 써서 만들어 간다는 과정이 너무 좋았다. for문에 비하면 while문은 좀 간단하게 느껴져서 어렵게 느껴지진 않았다. 하지만 복습은 철저히 해야 하겠다. 마무리로 배웠던 문장들로 시계와 구구단도 순서대로 만들어 보았는데 어렵지는 않았고 재미있었다. 디지털시계가 저런 식을 활용해서 만들어지는 게 신기했고 얼른 많이 배우고 제대로 배워나가야겠다.