[Java] 짝수는 싫어요 (ArrayList / 제네릭 / 배열변환)

Problem 💻

https://school.programmers.co.kr/learn/courses/30/lessons/120813

정수 n이 매개변수로 주어질 때, n 이하의 홀수가 오름차순으로 담긴 배열을 return하도록 solution 함수를 완성해주세요.

Approach 1 ❌ - 나의 초기 접근법.

 n이하의 정수들을 홀수로만 골라내기 위해서

for문으로 n이하의 정수를 하나씩 끄집어내면서,

if문의 조건으로 n%2 == 1만 새로 생성한 배열에 answer이라는 배열에 넣는다.

이 과정은 for문 안에서 이루어진다.

for문 전에 int[] answer = new int[n/2];로 홀수를 담을 배열을 생성해준다.

---

Approach 2 ⭕ - 나의 접근법에 대한 교정.

1. 홀수 추출 :

    n 이하의 정수 중 홀수만 선택.

2. 배열 크기 계산 :

     n이 짝수인지 홀수인지에 따라 홀수의 개수를 결정하여 배열 크기를 미리 설정한다.

      (나의 초기 접근법에서는 무조건 n/2개가 배열의 크기라고 정했다. n이 홀수인지 짝수인지에 따라 배열의 크기가 달라진다.)

3. 배열의 홀수 저장 :

     for문을 사용해 홀수만 배열에 저장.

 

---

Solution 💡

<주요 자바 문법>

1. for 반복문 : 특정 범위의 값을 순차적으로 순회

for (int i = 1; i <= n; i++) {
   //실행문
}

2. 조건문 if : 특정 조건을 충족하는 경우에만 실행.

if (조건) {
    // 실행문
}

3. 리스트와 배열 변환 : 리스트는 동적 크기를 가지며 배열로 변환이 가능.

List<Integer> list = new ArrayList<>();
int[] array = new int[list.size()];
for (int i = 0; i <list.size(); i++) {
     array[i] = list.get(i);
}

---

< 정답 코드 >

import java.util.ArrayList;
import java.util.List;

public class Solution {
   public static int[] solution(int n) {
       // Step 1 : 리스트를 활용해 홀수를 저장 (배열 크기 계산 불필요)
       List<Integer> oddNumbers = new ArrayList<>();
       
       // Step 2 : 1부터 n까지 순회하며 홀수인지 확인
       for (int i =1; i <= n; i++) {
           if (i % 2 == 1) { //홀수 조건
               oddNumbers.add(i)
           }
       }
       // Step 3 : 리스트를 배열로 변환
       int[] answer = new int[oddNumbers.size()];
       for (int i = 0; i < oddNumbers.size(); i++) {
           answer[i] = oddNumbers.get(i);
       }
       
       return answer;
   }
   
   // 테스트 메인 메서드
   public static void main(String[] args) {
       int n = 10;
       int [] result = solution(n);
       
       //결과 출력
       for (int num : result) {
           System.out.print(num + " ");
       }
   
   }


}

<코드 설명>

1. List 사용 이유 :

    - 배열 크기를 사전에 결정하지 않고 동적으로 추가 가능.

    - 초기 배열 크기를 계산하지 않아도 됨.

 

2. 홀수 조건 :

if (i % 2 == 1) {

     - i % 2가 1인 경우 i는 홀수.

 

3. 리스트 -> 배열 변환

int[] answer = new int[oddNumbers.size()];
for (int i = 0; i < oddNumbers.size(); i++) {
    answer[i] = oddNumbers.get(i);
}

       - 리스트에 저장된 값들을 배열에 복사. 

 

4. 테스트 출력:

      - 배열을 반복문으로 출력해 결과를 확인.

---

<  ArrayList 랑 ArrayList의 주요 메서드를 알아볼까?  >

1. ArrayList란

ArrayList는 자바에서 제공하는 가변크기 배열을 구현한 클래스이다.

즉, 요소가 들어갈 크기를 미리 정하지 않아도 되는 배열의 형태이다.

 

java.util.ArrayList 패키지에 포함되어 있으며,

다음과 같은 특징을 가진다 :

- 배열처럼 요소를 저장하지만, 크기를 동적으로 조장할 수 있음.

- 데이터가 추가되거나 삭제될 때 크기가 자동으로 증가 또는 감소.

- 인덱스(0부터 시작)를 사용해 요소에 접근하거나 변경 가능.

 

2. 주요 메서드 

- add(E e) : 리스트에 요소를 추가.

- get(int index) : 특정 인덱스에 있는 요소를 반환.

- size() : 리스트의 현재 크기(요소 개수)를 반환.

 

3. 이 코드에 사용된 get(int index)메서드

 역할: 

- 리스트의 특정 인덱스 위치에 저장된 값을 반환한다. 

- 반환 타입은 리스트가 저장하는 요소의 데이터 타입과 동일하다.

문법 :

E get(int index)

- E : ArrayList에 저장된 요소의 데이터 타입(제네릭 타입)

 

 

---

< 제네릭 타입에 대해 알아볼까? >

제네릭 타입은 어떤 데이터 타입을 사용할지 미리 정하지 않고, 사용하는 시점에 타입을 정하는 것이다.자바에서 제네릭 타입은 주로 <>기호를 사용해 표시한다. 

ArrayList<Integer> numbers = new ArrayList<>();

 

제네릭(Generic) 타입과  데이터 타입(Data Type)은 뭐지?

 

1. 데이터 타입(Data Type)이란?

 데이터 타입은 컴퓨터에서 다루는 "데이터 종류" 뜻한다. 

 

 

예를 들어:

• 숫자: 정수(int), 소수(double) 같은 숫자를 저장하는 타입.

• 예: 1, 42, 3.14

• 글자: 문자(char), 문자열(String) 같은 글자를 저장하는 타입.

• 예: 'A', "Hello"

• 참/거짓: 논리형(boolean).

• 예: true, false

 

데이터 타입의 예시

int number = 10; // 정수 타입

double pi = 3.14; // 소수 타입

String greeting = "Hello"; // 문자열 타입

boolean isEven = true; // 참/거짓 타입

 

 

2. 제네릭(Generic) 타입이란?

제네릭 타입은 어떤 데이터 타입을 사용할지 미리 정하지않고, 사용하는 시점에 타입을 정하는 것이다. 

 

비유로 설명:

• “일반 상자(Box)“를 생각해보세요. 상자는 안에 어떤 물건이 들어갈지 미리 정하지 않는다.

• 사과를 담을 수도 있고, 책을 담을 수도 있다.

• 제네릭 타입은 이런  “모든 물건을 담을 수 있는 상자”와 같아요.

• 나중에 이 상자를 사용할 때 사과를 넣겠다! 또는 책을 넣겠다! 라고 정하는 것이다.

 

제네릭 타입의 예

자바에서 제네릭 타입은 주로 <> 기호를 사용해 표시해요. 예를 들어:

 

ArrayList<Integer> numbers = new ArrayList<>();

 

• 여기서 ArrayList<Integer>는 정수(Integer)를 저장하는 리스트를 만든다는 뜻이다.

• 제네릭 타입  <Integer>를 통해 리스트에 어떤 데이터 타입을 저장할지 명확히 알려준다.

 

제네릭이 없는 경우와 비교:

제네릭을 사용하지 않으면, 리스트 안에 여러 타입(숫자, 문자열 등)을 섞어서 저장할 수 있어요. 하지만 그 경우, 어떤 타입인지 헷갈릴 수 있고 문제가 생길 가능성이 높아요.

 

제네릭 없이 사용:

ArrayList list = new ArrayList(); // 타입 명시 X

list.add(1);         // 정수

list.add("Hello");   // 문자열

 

제네릭 사용:

ArrayList<String> list = new ArrayList<>();

list.add("Hello");  // 문자열만 저장 가능

 

• 제네릭 타입을 지정하면 저장할 수 있는 데이터 타입이 제한되므로, 더 안전하고 오류를 줄일 수 있다.

 

3. 제네릭 타입의 장점

1. 타입 안정성(Type Safety):

• 제네릭은 어떤 타입이 저장되는지 명확히 알 수 있어 실수를 방지한다.

• 예: ArrayList<Integer>는 정수만 저장할 수 있다.

2. 코드 재사용성:

• 제네릭을 사용하면, 데이터 타입에 상관없이 재사용 가능한 코드를 만들 수 있어요.

• 예: 같은 ArrayList 클래스가 숫자, 문자열 등 다양한 타입을 처리할 수 있어요.

3. 형변환(Casting)이 불필요:

• 제네릭을 사용하면 데이터를 꺼낼 때 타입을 따로 변환하지 않아도 돼요.

 

4. 제네릭 타입의 문법

제네릭 타입을 사용할 때는 <> 기호 안에 사용할 데이터 타입을 적어준다. 대표적인 예는 ArrayList 클래스입니다.

 

기본 문법:

 

ArrayList<T> list = new ArrayList<>();

 

• 여기서  T는 타입을 의미하며, 원하는 데이터 타입으로 변경 가능.

 

< 데이터 타입 예시: >

 

1. 정수(Integer) 리스트:

 

ArrayList<Integer> intList = new ArrayList<>();

intList.add(1); // 정수만 저장 가능

 

 

2. 문자열(String) 리스트:

 

ArrayList<String> strList = new ArrayList<>();

strList.add("Hello"); // 문자열만 저장 가능

 

 

3. 참/거짓(Boolean) 리스트:

 

ArrayList<Boolean> boolList = new ArrayList<>();

boolList.add(true); // 참/거짓 값만 저장 가능

 

5. 제네릭 타입의 실제 사용

 

앞에서 본 코드에서도 제네릭 타입을 사용했다.

 

List<Integer> oddNumbers = new ArrayList<>();

 

• <Integer>: 정수만 저장할 수 있는 리스트를 만듦.

• oddNumbers.get(i):

• 정수를 저장했으므로, 꺼낼 때도 정수(Integer)로 반환.

 

6. 요약

 

• 데이터 타입은 정수, 문자열, 참/거짓처럼 데이터의 종류를 말한다.

• 제네릭 타입은 코드를 더 안전하고 유연하게 만들어주는 도구로, 저장할 데이터 타입을 나중에 정할 수 있다.

• 제네릭을 사용하면, 타입 안정성과 코드 재사용성이 높아지고 형변환이 필요 없어서 더 간편하다.

---

 

예외 처리:

만약 index가 리스트의 범위를 벗어나면 IndexOutOfBoundsException이 발생한다.

Exception in thread "main" java.lang.IndexOutOfBoundsException: Index 5 out of bounds for length 3

 

사용 예시

import java.util.ArrayList;

public class Main {
   public static void main(String[] args) {
       // ArrayList 생성
       ArrayList<Integer> oddNumbers = new ArrayList<>();
       
       // 리스트에 홀수 추가
       oddNumbers.add(1);
       oddNumbers.add(3);
       oddNumbers.add(5);
       
       //get()메서드로 요소 가져오기
       System.out.println("첫 번째 요소" + oddNumbers.get(0)); //출력: 1
       System.out.println("두 번째 요소" + oddNumbers.get(1)); //출력: 3
   }

}

 

<결과>

첫 번째 요소: 1
두 번째 요소: 3
세 번째 요소: 5

 

< oddNumbers.get(i)와 반복문 >

oddNumbers.get(i)는 반복문과 함께 자주 사용된다. 이를 통해 리스트의 모든 요소를 하나씩 접근할 수 있다.

import java.util.ArrayList;

public class Main {
   public static void main(String[] args) {
       // ArrayList 생성 및 값 추가
       ArrayList<Integer> oddNumbers = new ArrayList<>();
       oddNumbers.add(1);
       oddNumbers.add(3);
       oddNumbers.add(5);
       
       //반복문으로 리스트의 모든 요소 출력
       for (int i = 0; i < oddNumbers.size(); i++) {
           System.out.println("인덱스 " + i + "의 값" + oddNumbers.get(i))
       }
   
   }

}

인덱스 0의 값: 1
인덱스 1의 값: 3
인덱스 2의 값: 5

 

< 주의사항 >

1. 인덱스는 0부터 시작:

• oddNumbers.get(0)은 리스트의 첫 번째 요소를 반환.

• oddNumbers.get(oddNumbers.size() - 1)은 마지막 요소를 반환.

 

2. 범위 초과 예외:

• 유효한 인덱스 범위: 0 <= index < oddNumbers.size().

• 범위를 벗어나면 IndexOutOfBoundsException이 발생.

 

 

<실제 코드에서의 역할>

oddNumbers.get(i)는 리스트에서 i번째 홀수를 가져오는 역할을 한다.

예를 들어:

int[] answer = new int[oddNumbers.size()];
for (int i = 0; i < oddNumbers.size(); i++) {
    answer[i] = oddNumbers.get(i);
}

이 코드의 동작:

• oddNumbers.get(i)는 리스트에서 i번째 요소를 가져옴.

• answer[i]에 해당 값을 저장.

 

<효율성을 높이는 대안>

for-each 문법을 사용하면 get()을 직접 호출하지 않고도 리스트의 요소를 반복할 수 있다:

for (int num : oddNumbers) {
    System.out.println(num);
}

 

oddNumbers.get(i)는 ArrayList의 특정 인덱스 위치에 있는 값을 가져오는 메서드이다.
이는 리스트의 요소를 읽거나 활용할 때 필수적인 메서드로, 
for 반복문이나 for-each와 함께 사용해 리스트를 쉽게 다룰 수 있다.

---

---

<개선된 접근법> - 미리 배열 크기 계산

(어떤 숫자 n이 주어지면, 그 숫자보다 작거나 같은 홀수들을 모아서 배열에 담기)

만약에 배열 크기를 미리 계산하여 더 효율적으로 작성하려면 다음과 같은 방법을 사용할 수 있다.

public static int[] solution(int n) {
    // 홀수 개수 계산
    int size = (n + 1) / 2;
    
    // 배열 생성
    int[] answer = new int[size];
    
    // 홀수 저장
    int index = 0;
    for (int i = 1; i <= n; i += 2) {
        answer[index++] = i;
    }

    return answer;
}

이 방법의 장점 :

 - 배열 크기를 미리 계산해 메모리를 더 효율적으로 사용.

 - 반복문이 n 대신 n /. 2번만. 실행

 

개선된 코드에 대한 설명.

1. 함수 이름과 목표

public static int[] solution(int n)

 - 이 코드는 solution이라는 이름의 함수이다.

 -  숫자 n이 주어지면, n이하의 모든 홀수를 담은 배열을 만들어서 반환한다.

 -  예를 들어, n = 7이면, [1, 3, 5, 7]이라는 배열을 만들어서 돌려준다.

 

2. 홀수의 개수 계산

int size = (n + 1) / 2;

 

- 여기서 size는 배열의 크기(홀수의 개수)를 계산한다.

- 예를 들어:

    -  n = 7 이면, size = (7+1) /2 =4 (1,3,5,7 총 4개의 홀수)

    -  n = 8 이면, size = (8+1) /2= 4 (1,3,5,7 총 4개의 홀수)

 배열의 크기가
홀수라면 +1하여 /2하면 홀수의 갯수가 나오고
짝수라면 +1 하여 /2하면 정수형으로 출력이 되므로 소수점 버리고 홀수의 갯수가 나온다.

3. 빈 배열 만들기

int[] answer = new int[size];

 

 

4. 홀수를 배열에 저장하기

int index = 0;
for (int i =1; i <= n; i+=2) {
    answer[index++] = i;
}

 이 부분은 배열에 홀수를 하나씩 담는 역할을 한다. 

 

    4-1) for 반복문 :

- for (int i = 1; i <= n; i += 2) :

    i는 1부터 시작하여, 2씩 증가한다(즉, 홀수만 가리킨다)

    반복문은 i가 n보다 작거나 같을 때까지만 실행된다. 

 

   4-2) answer[index++] = i :

- answer 배열에 i 값을 넣는다.

- index++는 값을 넣은 뒤, 다음 빈칸을 가리키게 만들어준다.

- 예를 들어, n = 7일 때의 과정을 보자. 

    • 처음: i = 1, answer[0] = 1 → 배열은 [1, , , ].

    • 두 번째: i = 3, answer[1] = 3 → 배열은 [1, 3, , ].

    • 세 번째: i = 5, answer[2] = 5 → 배열은 [1, 3, 5, ].

    • 네 번째: i = 7, answer[3] = 7 → 배열은 [1, 3, 5, 7].