220826 D+4 박싱, 언박싱(Boxing, Unboxing), 조건문, 반복문(break & continue문), 사용자 입력, 배열 탐색

1. 래퍼 클래스(Wrapper Class)

: 기본 자료 타입(primitive type)을 객체(포장 / wrapper 객체)로 다루기 위해서 사용하는 클래스들

→ 프로그래밍을 하다 보면 기본 타입의 데이터를 객체로 표현해야 하는 경우가 종종 있다.

대표적으로 이후 배우게 되는 컬렉션에서 사용하는 데이터 타입은 모두 객체로 포장된 타입을 사용한다.

→ 기본 타입의 값을 내부에 두고 포장하기 때문이다.

래퍼 클래스로 감싸고 있는 기본 타입 값은 외부에서 변경할 수 없으며,

만약 값을 변경하고 싶다면 새로운 포장 객체를 만들어야 한다.

 

→ 래퍼 클래스는 java.lang 패키지에 포함되어 있는데, 다음과 같이 기본 타입에 대응되는 클래스들이 있다.

→ char 타입과 int 타입이 각각 Character와 Integer로 변경되고,

기본 타입의 첫 문자를 대문자로 바꾼 이름을 가지고 있다.

기본 타입	래퍼 클래스
byte	Byte
char	Character
int	Integer
float	Float
double	Double
boolean	Boolean
long	Long
short	Short

2. 객체 자료형
‣ 자바는 객체지향 언어이므로 기본 자료형을 제외한 다른 타입, 자료형들도 전부 객체로 만들어 사용 가능하다.
‣ 포장 객체(Wrapper)도 기본 자료형을 포장해서 객체로 만들었기 때문에 포장 '객체'라는 이름으로 부르고 있다.
‣ 참조 자료형인 String, Enum, Interface, Class도 객체 자료형에 속한다고 볼 수 있고,
특정한 클래스를 자료형으로 쓸 수도 있다.

ex)

// #1
public class Subject {
  String subjectName;
  int score;
  int subjectId;
}

// #2
public class Student {
  String studentName;
  int studentId;
  
  Subject eng; // 상단에 작성한 Subject 클래스를 자료형으로 사용
  Subject math; 
}

// #3
public Student(int studentId, String studentName) {
  this.studentId = studentId;
  this.studentName = studentName;
  
  eng = new Subject(); // new 키워드로 인스턴스 생성 후 사용
  math = new Subject();
}
// Student의 인스턴스가 생길 때, 자동으로 eng, math 인스턴스도 생성됨
// 이후 해당 객체를 이용해 학생별 영어/수학 점수 데이터를 입력할 수 있음

Student kimcoding = new Student(1, "kimcoding"); 
// 김코딩 학생을 생성하면서, 타입형태로 클래스인 Student를 지정

→ 커스텀 클래스를 타입으로 선언하여 사용할 수 있고, 클래스도 객체 자료형에 속한다.
포장(Wrapper) 객체도 기본 자료형을 가지고 만든 클래스, 객체이기 때문에 이와 동일한 원리라고 생각한다.

3. 박싱 / 언박싱(Boxing / Unboxing)
‣ 박싱(boxing): 기본 타입의 값을 포장 객체로 만드는 과정.
‣ 언박싱(unboxing): 포장 객체에서 기본 타입의 값을 얻어내는 과정.

ex)

// 박싱, 언박싱의 과정이 왜 필요한지 동등비교의 예
// 래퍼 클래스는 아니지만 객체 클래스인 String 타입을 사용
import java.util.Scanner;
public class Main {
  static Scanner myInput = new Scanner(System.in);
  public static void main(String[] args) {
    String res = myInput.nextLine(); // input으로 "spring";
    
    // Input으로 들어온 값인 "spring"은 input과 동시에 새로운 String 타입의 객체로 생성됨
    // 1. 비교 연산자(==)을 통한 동등비교
    // 힙에 저장된 객체의 주소를 비교하기 때문에 false라는 값이 출력
    System.out.println(res == "spring"); // false
	
    // 2. equals()를 사용한 동등비교
    // 주소가 아니라 값을 비교하게 되기 때문에 true라는 값이 출력
    System.out.println(res.equals("spring")); // true
  }
}

 

박싱은 객체 안에 값을 넣는 것, 언박싱은 객체 밖으로 값을 꺼내는 것.
⇒ 이미 객체로 포장된 값을 비교하기 위해 꼭 필요한 과정이라는 것을 알 수 있다.

✷ 기본 타입의 값을 박싱 하는 방법

기본 타입의 값을 줄 경우	문자열을 줄 경우
Byte obj = new Byte(10);	Byte obj = new Byte("10");
Character obj = new Charactor('A');	없음
Short obj = new Short(100);	Short obj = new Short("100");
Integer obj = new Integer(1000);	Integer obj = new Integer("1000");
Long obj = new Long(100000);	Long obj = new Long("100000");
Float obj = new Float(2.3F);	Float obj = new Float("2.3F");
Double obj = new Double(3.4);	Double obj = new Double("3.4");
Boolean obj = new Boolean(true);	Boolean obj = new Boolean("true");

위의 방법과 같이 new 키워드와 생성자를 사용하여 박싱을 할 수 있다.
그러나 생성자를 이용하지 않아도 각 포장 클래스마다 가지고 있는 정적 valueOf() 메서드를 사용할 수도 있다.
이 방법으로는 전달 인자가 문자열인 경우에도 Integer 포장 객체로 박싱 하여 사용할 수 있다.

Integer obj1  = Integer.valueOf(1000);
Integer obj2  = Integer.valueOf("1000");

String type = obj2.getClass().getName(); 
System.out.println(type); // java.lang.Integer

반면에, 언박싱(박싱 된 포장 객체에서 다시 기본 타입의 값을 얻어내기 위함) 하기 위해서는
각 포장 클래스마다 가지고 있는 메서드인 "기본 타입명 + Value()"를 호출하면 된다.

기본 타입	How to do
byte	num = obj.byteValue();
char	ch = obj.charValue();
short	num = obj.shortValue();
int	num = obj.intValue();
long	num = obj.longValue();
float	num = obj.floatValue();
double	num = obj.doubleValue();
boolean	bool = obj.booleanValue();

4. 자동 박싱과 언박싱
‣ 자동 박싱: 클래스 타입에 기본 값이 대입될 경우 발생함.

Integer obj = 122; // 자동 박싱

int 타입의 값을 Integer 클래스 변수에 대입하면 자동 박싱이 일어나서 Integer 객체가 생성된다.

‣ 자동 언박싱: 기본 타입에 포장 객체가 대입될 경우에 발생함.

Integer obj = new Integer(200);
int value = obj; // 자동 언박싱
int value2 = obj + 100; // 자동 언박싱

Integer 객체를 int 타입 변수에 대입하거나, Integer 객체와 int 타입 값을 연산하면
Integer 객체로부터 int 타입의 값이 자동 언박싱 되어 연산된다.

‣ 컬렉션 객체에 int 값을 저장하면 자동 박싱이 일어나 Integer 객체가 저장된다.

List<Integer> list = new ArrayList<Integer>();
list.add(200); // 자동 박싱

(자동 박싱과 언박싱은 자바 5부터 추가된 기능이기 때문에, 자바 4 이전 버전에서는 직접 박싱과 언박싱을 해주어야 한다.)

5. 문자열을 기본 타입 값으로 변환

‣ 포장(Wrapper) 클래스의 주요 용도는 기본 타입의 값을 박싱 해서 포장 객체로 만드는 것이지만,
문자열을 기본 타입 값으로 변환할 때에도 많이 사용된다.
‣ 대부분의 포장 클래스에는 "parse + 기본 타입" 형태로 작성되어 있는 정적 메서드가 있다.
이 메서드는 문자열을 매개 값으로 받아 기본 타입 값으로 변환한다.

기본 타입	How to do
byte	num = Byte.parseByte("10");
short	num = Short.parseShort("100");
int	num = Integer.parseInt("1000");
long	num = Long.parseLong("10000");
float	num = Float.parseFloat("2.34F");
double	num = Double.parseDouble("3.45");
boolean	bool = Boolean.parseBoolean("true");
boolean	bool = obj.booleanValue();

6. 래퍼 클래스(Wrapper class) 내부 값 비교
‣ 포장 객체는 내부의 값을 비교하기 위해 == 와 != 연산자를 사용할 수 없다.
이 연산자는 내부의 값을 비교하는 것이 아니라 포장 객체의 주소를 비교하기 때문입니다.

Integer obj1 = 300;
Integer obj2 = 300;

Integer obj3 = new Integer(300);
Integer obj4 = new Integer(300);

Integer obj5 = Integer.valueOf(300);
Integer obj6 = Integer.valueOf(300);

System.out.println(obj1 == obj2); // false
System.out.println(obj1 == obj3); // false
System.out.println(obj1 == obj5); // false

System.out.println(obj3 == obj4); // false
System.out.println(obj5 == obj6); // false

→ 모든 Integer 객체가 300이라는 동일한 값을 가지고 있지만, == 연산의 결과는 false가 나온다.
이때, 내부의 값만 비교하려면 언박싱한 값을 얻어 비교해야 한다.
그렇기 때문에 포장 객체에 정확히 어떤 값이 저장될지 모르는 상황이라면 == 와 != 연산자는 사용하지 않는 편이 좋다.
직접 내부의 값을 언박싱해서 비교하거나, equals() 메서드로 내부 값을 비교하는 것이 좋다.

Integer obj1 = 300;
Integer obj2 = 300;

Integer obj3 = new Integer(300);
Integer obj4 = new Integer(300);

Integer obj5 = Integer.valueOf(300);
Integer obj6 = Integer.valueOf(300);

System.out.println(obj1.equals(obj2)); // true
System.out.println(obj1.equals(obj3)); // true
System.out.println(obj1.equals(obj5)); // true

System.out.println(obj3.equals(obj4)); // true
System.out.println(obj5.equals(obj6)); // true

→ Integer 객체 안의 내부 값을 equals() 메서드를 사용해서 비교해본 결과는 true이다.
⇒ 포장 객체의 비교 연산은 기본 타입의 연산과는 조금 다르다.

7. 제어문
: 자바 프로그램을 실행할 때 main() 메서드의 시작 중괄호부터 끝 중괄호까지
위에서부터 아래로 실행하는 흐름을 개발자가 원하는 방향으로 바꿀 수 있도록 해주는 것.

① 조건문
: 제어문 블록을 빠져나와 정상 흐름으로 다시 돌아가는 경우.
조건식의 결과에 따라 블록 실행 여부가 결정됨.
‣ if문
→ 조건식에 true or false 값을 산출할 수 있는 연산식, boolean 변수가 올 수 있다.

if(조건식) {
  실행문;
  실행문;
}

if(조건식) {
  실행문
}

중괄호{} 블록은 여러 개의 실행문을 하나로 묶기 위해 작성되는 것이며,
만약 true인 조건식에 실행문이 하나라면 생략 가능하나 생략하지 않고 작성하는 것을 추천한다.

‣ if - else문

// condition is true
int number = 1;

// if문의 조건식이 true이므로 code1 블록이 실행된다
if(number > 0) {
  // code1
} else {
  // code2
}
// code after if ... else

// condition is false
int number = 1;

// if문의 조건식이 false이므로 code2 블록이 실행된다
if(number > 0) {
  // code1
} else {
  // code2
}
// code after if ... else

if - else문을 여러번 사용하거나 if문 블록 내부에 또다른 if문을 중첩해서 사용할 수 있음

‣ Switch문
: 변수가 어떤 값을 갖느냐에 따라 실행문이 선택된다.
ex)

package com.company;

import java.util.Scanner;

public class Main {
  static Scanner myInput = new Scanner(System.in);
  public static void main(String[] args) {
    String dice = myInput.nextLine(); //주사위 번호 입력
      switch(dice) { 
        case 1:
          System.out.println("1번");
          break; // 다음 case를 실행하지 않고, switch문 탈출! 
        case 2:
          System.out.println("2번");
          break;
        case 3:
          System.out.println("3번");
          break;
        case 4:
          System.out.println("4번");
          return "4번이 나왔습니다."
        case 5:
          System.out.println("5번");
          break;
		case 6:
          System.out.println("5번");
          break;
        default: // switch문의 괄호 안 값과 같은 값이 없으면, 여기서 실행문 실행
          System.out.println("없는 숫자! " + dice);
          break;
        }
    }
}

num의 값과 case의 번호가 같으면 해당 case안의 실행문을 실행하고 
실행이 완료되면 break를 통해서 해당 블록을 탈출

switch문은 괄호 안의 값과 동일한 값을 갖는 case로 가서 실행문을 실행한다.

만약 괄호 안의 값과 동일한 값을 갖는 case가 없으면 default로 가서 실행문을 실행한다(default는 생략 가능).

 

// switch문에는 int 뿐만 아니라, char 타입 변수도 사용가능하고, 
// 자바 7부터는 String 타입의 변수도 올 수 있다.

// 직급별 월급 출력하기
package com.company;

public class Main {
  static Scanner userInput = new Scanner(System.in);

  public static void main(String[] args) {
    String yourPosition = userInput.nextLine(); // 입력받기

    switch(yourPosition) {
      case "Senior" :
        System.out.println("700만원");
        break;

      case "Junior" :
      case "Manager" : // 실행문이 같으면 이렇게 작성 가능
        System.out.println("500만원");
        break;
          default: 
            System.out.println("300만원");
            break;
    }
  }
}


// 자바 14에서 표준화된 enhanced switch문(향상된 switch문)의 예시
// 직급별 월급 출력하기
package com.company;

public class Main {
  static Scanner userInput = new Scanner(System.in);

  public static void main(String[] args) {
    String[] positionList = {"Manager", "Senior", "Junior"};
    String yourPosition = userInput.nextLine(); // 입력받기

    switch (yourPosition) {
      case "Senior" -> System.out.println("700만원");
      case "Junior", "Manager" -> System.out.println("500만원");
    }
  }
}

✷ 기존의 switch문에서 변경된 점

‣ 여러 조건에 따라 콤마 , 로 구분하여 한 번에 처리할 수 있게 되었다.

: 대신에 -> 를 사용하고, break문이 생략되었다.

-> 를 사용했다면 실행문이 2개 이상이거나, 반환값이 존재할 경우 중괄호 블록({ })을 사용해야 한다.

( :을 사용하면, 실행문이 여러 개라 할지라도 중괄호 블록({ })을 사용하지 않아도 된다. )

② 반복문
: 제어문이 실행된 후 다시 제어문 처음으로 돌아가 반복하는 경우.
✷ for문은 반복 횟수를 알고 있을 때, while문은 조건에 따라 반복할 때 주로 사용한다.

‣ for문
: 주어진 횟수만큼 실행문을 반복 실행할 때 적합한 반복 제어문.

// for문의 기본 형식
for((1)초기화식; (2)조건식; (3)증감식){
  실행문;
  실행문;
}

// 1부터 100까지 더하는 반복제어문의 예시
public class Main {
  public static void main(String[] args) {
    int sum = 0;
    for(int i = 0; i <= 100; i++) {
      sum = sum + i;
    }
  }
}

✷ for문이 처음 실행될 때

① 초기화식이 제일 먼저 실행

② 조건식을 평가하여 true면 실행문을 실행시킨다.
③ 블록 내부의 실행문들이 모두 실행되면 증감식을 실행시키고 다시 조건식을 평가하게 된다.
(false인 경우 for문 블록을 실행하지 않고 끝나게 된다.)
⇒ 조건식을 충족하는 동안 초기화식부터 시작하여 증감식의 규칙을 따라 실행한다.
조건이 충족하지 않으면 실행문을 실행하지 않고 끝나게 된다.
⇒ 초기화식이 필요 없을 경우에는 초기화식을 생략할 수 있고, 초기화식이나 증감식도 둘 이상이 될 수 있다.

// 초기화식, 증감식이 둘 이상이 되는 기본 형태의 예시
for(int i = 0, j = 100; i <= 50 && j >= 50; i++, j--){
  실행문;
  실행문;
}

// 루프 카운트 변수를 선언할 때 부동소수점(floating point)타입을 사용하지 않아야 한다
// 예시
public class Main {
  public static void main(String[] args) {
    for(float x = 0.1f; x <= 1.0f; x += 0.1f){
      System.out.println(x);
    }
  }
}

/*
0.1
0.2
0.3
0.4
0.5
0.6
0.70000005
0.8000001
0.9000001
*/

이론적으로는 3번 라인의 for문이 10번 반복되어야 하지만
0, 1은 float타입으로 정확하게 표현할 수 없다.
따라서 x에 더해지는 값이 약간 크기 때문에 for문은 9번만 실행된다.

‣ enhanced(향상된) for문
반복 실행을 하기 위해 카운터 변수와 증감식을 사용하지 않는다.
배열 및 컬렉션 항목의 개수만큼 반복하고 자동적으로 for문을 빠져나간다.

public class EnhancedForLoop {
  public static void main(String[] args) throws Exception {
    String[] names = {"Maru", "Leah", "Harvey", "Sebastian"};
    for(String name : names) {
      System.out.println(name + "님은 공부 중입니다.");
    }
  }
 }
 
/*
Maru님은 공부 중입니다.
Leah님은 공부 중입니다.
Harvey님은 공부 중입니다.
Sebastian님은 공부 중입니다.
*/

① for문의 괄호( ) 안에는 배열에서 꺼낸 항목을 저장할 변수 선언, 콜론( : ), 사용할 배열이 작성된다.
② 향상된 for문을 처음 실행할 때, names 배열에서 가져올 첫 번째 값이 존재하는지 확인하고,
값이 존재하면 해당 값을 변수인 name에 저장한다. 그리고 그 안의 실행문을 실행한다.
③ 블록 내부의 실행문이 모두 실행되면 다시 names 배열에서 가져올 값이 있는지 확인하고
만약 가져올 다음 항목이 없다면 자동적으로 for문이 종료된다.

‣ while문

: 조건식이 false인 경우 반복 행위를 멈추고 while문을 종료하고,

true인 경우 계속해서 반복한다(but this is infinite loops).

// while문의 기본 형식
while((1)조건식) {
  (2)실행문;
}

public class Main {
  public static void main(String[] args) {
    boolean run = true;
    int num = 1;
  
    while(run) { // while(true) 조건문
      num++; // 실행문
      System.out.println(num); // 실행문
      
      if(num == 22) { // 조건문, num이 22가 되면 탈출
        run = false;
      }
    }
  }
}

‣ do - while문

참고링크

while문은 시작할 때부터 조건식을 검사하여 블록 내부를 실행할지 결정하지만,
경우에 따라 블록 내부의 실행문을 우선 실행시키고 실행 결과에 따라 반복 실행을 계속할지 결정하는 경우가 있다.

// do - while문 기본 형식
do {
  (1)실행문
} while((2)조건문);

① 실행문을 먼저 실행한다.

② 실행문이 모두 실행되면 조건식을 평가한다.

③ 그 결과가 true면 실행문 → 조건식으로 반복 실행, false면 do - while문을 종료한다.

// int타입을 요소로 가지는 arr 배열을 인덱스가 4 이상일 경우에만 순회하여 콘솔에 출력하는 코드 예제
// 먼저 최초 실행을 한 후 인덱스를 비교하여 while문의 조건이 true 일 경우만 do 안의 실행문을 실행
public class Main {
  public static void main(String args[]){
    int arr[] = {2, 11, 45, 3, 9, 66};
    int i = 0;
    do {
      System.out.println(arr[i]);
      i++;
    } while(i < 4);
  }
}

// 2, 11, 45, 3

9. break & continue문

① break문

: 반복문을 실행 중지할 때 사용된다.

for(...) {
  break;
}

while(...) {
  break;
}

대개 if문과 같이 사용되며, if문의 조건식에 따라 for / while문을 종료할 때 사용한다.

→ 만약 반복문이 중첩되어 있을 경우 break문은  가장 가까운 반복문만 종료, 바깥쪽 반복문에 영향을 끼치지 않음.

// 바깥 for문은 3부터 9까지 반복하고, 중첩된 for문은 5부터 1까지 반복하는 예제
public class Main {
  public static void main(String[] args) {
    Outter : for(int ele = 3; ele < 10; ele++) {
      for(int el = 5; el > 0; el--) {
        System.out.println("ele " + ele + " el "+ el);
        if(ele == 5){
          break Outter;
        }
      }
    }	
  }
}

/*
ele 3 el 5
ele 3 el 4
ele 3 el 3
ele 3 el 2
ele 3 el 1
ele 4 el 5
ele 4 el 4
ele 4 el 3
ele 4 el 2
ele 4 el 1
ele 5 el 5
*/

바깥 for문에서 ele 변수의 값이 5가 되면 바깥 for문까지 빠져나올 수 있도록

해당 for문에 Outter라는 라벨을 붙이고, 이를 break 문에 사용하였다.

⇒ 중첩된 for문 안에서도 바깥쪽 for문까지 완벽하게 빠져나올 수 있다.

 

✷ break문과 continue문의 차이점

→ 반복문의 종료 여부.

continue문은 반복문을 종료하지 않고 계속 반복을 수행한다.

if문의 조건을 만족하는 경우 continue문을 실행하여 그 이후의 코드를 실행하지 않고 다음 반복으로 넘어간다.

 

② continue문

: 반복문에서만 사용된다.

블록 내부에서 continue문이 실행되면 for문의 증감문 / while, do - while문의 조건식으로 이동하여 작동한다.

// 1-10까지의 수 중에서 홀수만 출력하는 코드
// if문을 사용하여 나머지가 0인 짝수인 경우 continue문을 실행하여 다시 for문의 증감문으로 이동하여 다음 반복 실행 
// 홀수만 출력
public class ContinueExample {
  public static void main(String[] args) throws Exception {
    for (int i = 0; i < 10; i++) {
      if (i % 2 == 0) { // 나머지가 0일 경우는
        continue; // 다음 반복으로 넘어간다. 
      }
      System.out.println(i); // 홀수만 출력
    }
  }
}

/*
1,3,5,7,9
*/

10. 사용자 입력

① 콘솔 입력

// 콘솔에서 사용자의 입력을 받는 방법에 대해
import java.util.*;

public class App{
  public static void main(String[] args){
    Scanner scanner = new Scanner(System.in);
    String inputText = scanner.nextLine();
    
    System.out.println("result : " + inputText);
	// 결과 : result : [입력 내용]
  }
}

‣ 자바에서는 입력을 하고자 할 때 통상적으로 Scanner를 사용한다.

Scanner는 패키지 안에 정의되어 있으므로 상단에 작성해야 사용할 수 있다.

Scanner를 정의한 후 new 키워드를 통해 인스턴스를 시킬 때

파라미터에 InputStream 내장 클래스의 객체인 System.in을 전달해야 한다.

String inputText = scanner.nextLine();

위 선언문에서 scanner.nextLine(); 만 작성하여도 사용자 입력을 받을 수 있다.

하지만 메서드의 리턴 값을 변수에 저장하지 않으면 재사용할 수가 없기 때문에 

String inputText 변수에 대입하여 값을 저장하는 것이 일반적인 사용방법이다.

 

11. 배열 탐색

// for문으로 배열을 순회하여 총합을 구하는 코드
int[] numbers = { 1, 9, 8, 2, 4 };
int sum = 0;

for (int i = 0; i < numbers.length; i++) {
  sum += numbers[i];
}
System.out.println(sum); // 24


// while문으로 배열을 순회하여 총합을 구하는 코드
int[] numbers = { 1, 9, 8, 2, 4 };
int sum = 0;
int i = 0;

while (i < numbers.length) {
	sum += numbers[i++];
}
System.out.println(sum); // 24


// 향상된 for문으로 배열의 각 요소에 접근하기
int[] scores = { 1, 9, 8, 2, 4 };
int sum = 0;

for (int number: numbers) {
  sum += numbers;
}
System.out.println(sum); // 24

✷ 향상된 for문을 사용할 때 주의해야 할 사항

향상된 for문을 통해 배열을 순회하는 것은 배열의 값을 읽어오는 것만 가능하다. 

⇒ 향상된 for문으로 배열을 순회하면서 배열의 값을 수정할 수는 없다.

int[] numbers = { 1, 9, 8, 2, 4 };

// 일반적인 for문 및 while문을 사용하면 배열 요소의 값을 바꿀 수 있다. 
for(int i = 0; i < numbers.length; i++) {
  scores[i] = 0;
}
System.out.println("for문 사용 : " + Arrays.toString(numbers));


int j = 0;
while(j < numbers.length) {
  numbers[j++] = 1;
}
System.out.println("while문 사용 : " + Arrays.toString(numbers)); 


// 향상된 for문을 사용하면 배열 요소의 값을 바꿀 수 없다. 
for (int number: numbers) {
  number = 2;
}
System.out.println("향상된 for문 사용 : " + Arrays.toString(numbers));

/*
실행 결과

for문 사용      : [0, 0, 0, 0, 0]
while문 사용    : [1, 1, 1, 1, 1]
향상된 for문 사용 : [1, 1, 1, 1, 1]
*/