[아이티센 부트캠프] (배열)

이언덕·2026년 3월 20일
Javaarray배열자바

아이티센 부트캠프

목록 보기
7/115
post-thumbnail

[배열]

1. 배열이 왜 필요한가

개념

배열은 같은 자료형의 값을 여러 개 묶어서 다루는 구조다.

변수는 원래 값 하나만 저장한다.
그래서 점수 5개를 저장하려면 원래는 아래처럼 변수가 여러 개 필요하다.

int score1 = 100;
int score2 = 90;
int score3 = 80;
int score4 = 70;
int score5 = 60;

이렇게 하면 값이 조금만 많아져도 이름이 너무 많아지고, 출력이나 계산도 하나씩 직접 써야 해서 불편하다.


배열을 쓰면 같은 자료형의 값을 하나의 이름으로 묶어서 관리할 수 있다.

int[] score = {100, 90, 80, 70, 60};

이제는 score라는 이름 하나로 여러 값을 다룰 수 있다.
즉, 배열은 같은 타입의 데이터를 순서 있게 묶어서 관리하기 쉽게 만든 문법이라고 보면 된다.



핵심 특징

  • 배열에는 같은 자료형의 값만 넣을 수 있다.
  • 값이 여러 개일 때 다루기 편하다.
  • 각 값은 순서대로 저장된다.
  • 배열 안의 각각의 칸을 원소 또는 엘리먼트라고 한다.
  • 배열은 보통 for문과 함께 많이 사용한다.



헷갈리기 쉬운 부분

배열은 여러 값을 저장한다고 해서, 아무 타입이나 섞어 넣는 구조가 아니다.

예를 들어 int[] 배열에는 정수만 넣을 수 있다.

int[] nums = {10, 20, 30};   // 가능

반대로 이런 식은 안 된다.

int[] nums = {10, 3.14, 30}; // 에러

3.14는 실수이기 때문이다.



2. 배열 선언, 생성, 초기화

배열을 이해할 때 가장 먼저 정리해야 하는 부분이 선언, 생성, 초기화다.
이 세 개를 나눠서 보면 배열 문법이 훨씬 덜 헷갈린다.

개념

(1) 선언

배열 선언은 배열을 다룰 변수를 준비하는 것이다.

int[] score;
int score[];

둘 다 같은 뜻이다.
다만 보통은 int[] score처럼 쓰는 쪽이 int 배열이라는 뜻이 더 잘 보여서 많이 쓴다.



(2) 생성

배열 생성은 new를 사용해서 실제로 배열을 만드는 것이다.

score = new int[5];

이 코드는 길이가 5인 int 배열을 생성하고, score (배열변수)가 그 배열을 가리키게 한다.
즉, 정수 5개를 넣을 수 있는 칸 5개를 만든다고 이해하면 된다.

배열이 생성되면 요소에 자동적으로 기본값으로 초기화된다.
(아래 사진에서는 int의 기본값인 0으로 각 요소에 초기화된 것을 볼 수 있다.)





(3) 초기화

초기화는 배열 안에 값을 넣는 것이다.

score[0] = 10;
score[1] = 20;
score[2] = 30;

즉, 순서대로 보면

  • 선언: 배열 변수 준비
  • 생성: 실제 배열 만들기
  • 초기화: 배열 칸에 값 넣기

이 흐름이다.


배열은 이 세 단계를 꼭 따로만 써야 하는 것은 아니다.
한 줄에 합쳐서도 쓸 수 있다.

int[] nums1 = new int[10];            // 선언 + 생성
int[] nums2 = new int[] {10, 20, 30}; // 선언 + 생성 + 초기화
int[] nums3 = {1, 2, 3, 4, 5};        // 선언과 동시에 초기화하는 축약형

여기서 nums3는 값을 직접 적었기 때문에, 값의 개수에 맞춰 배열의 길이도 자동으로 정해진다.
즉, {1, 2, 3, 4, 5}처럼 값 5개를 적었으므로 길이가 5인 배열이 만들어진다.

즉, 배열은

  • 먼저 선언하고 나중에 생성할 수도 있고
  • 선언하면서 바로 생성할 수도 있고
  • 선언하면서 값까지 바로 넣을 수도 있다

이렇게 이해하면 된다.



코드 예제

예제: ArrayTest1

int[] nums1 = new int[10];
int[] nums2 = new int[] {10, 20, 30};
int[] nums3 = {1, 2, 3, 4, 5};

System.out.println(nums1.length);
System.out.println(nums2.length);
System.out.println(nums3.length);

// 출력결과
// 10
// 3
// 5

이 코드는 배열을 만드는 대표적인 세 가지 형태를 한 번에 보여준다.

  • new int[10]은 길이를 먼저 정해서 만드는 방식이다.
  • new int[] {10, 20, 30}은 값을 적으면서 만드는 방식이다.
  • {1, 2, 3, 4, 5}는 선언과 동시에 쓸 수 있는 축약형이다.

또 값을 몇 개 적었는지에 따라 배열의 길이도 달라진다는 점을 함께 확인할 수 있다.



헷갈리기 쉬운 부분

값을 적으면서 배열을 만드는 문법은 두 가지처럼 보이지만, 실제로는 풀어서 쓴 형태와 줄여 쓴 형태의 차이라고 보면 된다.

int[] nums2 = new int[] {10, 20, 30};
int[] nums3 = {1, 2, 3, 4, 5};

이 둘은 모두 값을 넣으면서 배열을 만드는 코드다.
다만 차이는 문법에 있다.

  • new int[] { ... } 는 풀어서 쓴 형태
  • { ... } 는 줄여서 쓴 축약형

여기서 중요한 점은 { ... }만 쓰는 축약형은 배열을 선언하는 순간에만 사용할 수 있다는 것이다.


그래서 아래 코드는 가능하다.

int[] score = {100, 200, 300}; // 가능

하지만 이미 선언이 끝난 뒤에는 축약형만 따로 쓸 수 없다.

int[] score;
score = {100, 200, 300}; // 에러

이 경우에는 반드시 new int[]를 함께 써야 한다.

int[] score;
score = new int[] {100, 200, 300}; // 가능

즉, 이렇게 기억하면 된다.

  • 선언과 동시에 초기화 → {...} 가능
  • 나중에 다시 대입 → new int[]{...} 필요

한 줄로 정리하면, 처음 만들 때는 {...}를 줄여 쓸 수 있고, 다시 넣을 때는 new int[]{...}를 써야 한다는 뜻이다.



3. 배열의 생성

개념

배열을 생성한다는 것은 단순히 칸만 만드는 것이 아니다.
배열을 생성하면 실제로 값을 저장할 공간이 만들어지고, 그 배열을 배열 변수가 가리키게 된다.

int[] score = new int[5];

or

int[] score;
score = new int[5];

이 코드는 모두 길이가 5인 int 배열을 생성하는 뜻이다.
즉, 정수 5개를 저장할 수 있는 배열이 만들어지고, 배열 변수 score가 그 배열을 가리키게 된다.

배열은 생성되는 순간 길이가 함께 정해진다.
그리고 한 번 정해진 길이는 그 배열 안에서는 바뀌지 않는다.

또 배열을 생성만 해도 각 칸에는 자료형에 맞는 기본값이 자동으로 들어간다.
예를 들어 int[] 배열은 생성 직후 각 칸이 모두 0으로 채워진 상태가 된다.




즉, 배열을 생성할 때 같이 봐야 하는 것은 아래 네 가지다.

  • 실제 배열이 만들어진다.
  • 배열의 길이가 정해진다.
  • 각 칸은 기본값으로 자동 초기화된다.
  • 배열 변수는 그 배열을 가리키게 된다.



핵심 특징

배열의 길이는 length로 확인할 수 있다.

int[] score = new int[5];

System.out.println(score.length);  // 5

여기서 score.length는 배열 안에 들어 있는 원소 개수, 즉 배열의 크기를 뜻한다.




또 int[] 배열은 생성만 해도 기본값 0이 들어간다.

int[] score = new int[5];

System.out.println(score[0]);
System.out.println(score[1]);
System.out.println(score[2]);
// 출력결과
// 0
// 0
// 0

값을 따로 넣지 않았는데도 0이 나오는 이유는, 배열이 생성될 때 각 칸이 기본값으로 자동 초기화되기 때문이다.

자료형에 따라 기본값은 다르다.

  • int[] → 0
  • boolean[] → false
  • double[] → 0.0
  • 참조형 배열 → null



코드 예제

예제: ArrayTest3

boolean a1[] = new boolean[10];
int a2[] = new int[5];
long a3[] = new long[20];
double a4[] = new double[3];

System.out.println(a2.length);

a2 = new int[100];
System.out.println(a2.length);

// 출력결과
// 5
// 100

이 코드는 배열을 생성하면 길이가 정해진다는 점과, length로 그 크기를 확인할 수 있다는 점을 보여준다.

또 a2 = new int[100];을 보면, 기존 배열의 길이를 바꾼 것이 아니라 길이 100인 새 배열을 다시 만든 뒤 a2가 그 배열을 가리키게 된다는 점도 함께 볼 수 있다.



3 - 1 배열 선언 생성과정

1. int 타입 score 배열변수 선언





2. 연산자 new로 메모리 빈 공간에 5개 int 타입 생성





3. 배열생성 되면 자동적으로 각 요소에 기본값 초기화





4. 배열변수 score에 배열 주소 저장



4. 배열 원소 다루기: 인덱스와 값 저장하기

개념

배열의 각 칸에는 순서 번호가 붙어 있다.
이 번호를 인덱스라고 한다.

배열의 인덱스는 1부터가 아니라 0부터 시작한다.

예를 들어 길이가 5인 배열이라면 인덱스는 이렇게 된다.

  • 첫 번째 칸 → 0
  • 두 번째 칸 → 1
  • 세 번째 칸 → 2
  • 네 번째 칸 → 3
  • 다섯 번째 칸 → 4




배열의 한 칸에 접근할 때는 배열이름[인덱스] 형태를 사용한다.

score[0]
score[3]
score[score.length - 1]

값을 넣을 때도 같은 형태를 사용한다.

score[3] = 100;

값을 꺼낼 때도 같다.

int value = score[3];

즉, score[3]은 배열 전체가 아니라 배열 안의 한 칸을 뜻한다.



코드 예제

예제: ArrayTest5

int nums[] = { 10, 5, 7, 6, 21, 3, 22, 18, 9, 2, 25, 14 };

System.out.println(nums.length);
System.out.println(nums[0]);
System.out.println(nums[nums.length - 1]);

// 출력결과
// 12
// 10
// 14

이 코드는 배열의 길이, 첫 번째 값, 마지막 값을 꺼내는 기본 형태를 보여준다.




예제: 배열 한 칸에 값 저장하기

int[] score = new int[5];
score[3] = 100;

int value = score[3];
System.out.println(value);

// 출력결과
// 100

이 코드는 배열의 특정 위치에 값을 넣고, 다시 그 값을 꺼내는 예제다.



5. 배열 출력하기

개념

배열을 출력할 때는 배열 변수 자체를 출력하는 것과 배열 안의 값을 출력하는 것을 구분해야 한다.

배열 변수는 실제 값을 직접 들고 있는 것이 아니라, 배열을 가리키는 변수다.
그래서 배열 변수를 그대로 출력하면 배열 안의 값들이 출력되는 것이 아니라, 배열을 참조하고 있다는 정보처럼 보이는 값이 출력된다.

예를 들어 아래처럼 나온다.

[I@2b2fa4f7

이 값은 배열 원소 목록이 아니라, 배열 객체를 그대로 출력했을 때 보이는 참조 정보 형태의 문자열이다.

따라서 배열 안의 실제 값을 보려면 배열 변수 자체를 출력하는 것이 아니라,
nums[0], nums[1]처럼 원소를 하나씩 꺼내서 출력해야 한다.



배열 주소 정보 출력

예제: ArrayTest1

int[] nums1 = new int[10];
int[] nums2 = new int[] {10, 20, 30};
int[] nums3 = {1, 2, 3, 4, 5};

System.out.println(nums1);
System.out.println(nums2);
System.out.println(nums3);

// 출력결과 예시
// [I@2b2fa4f7
// [I@1dbd16a6
// [I@7ad041f3

이 코드는 배열 변수를 그대로 출력했을 때 배열 안의 값 목록이 아니라, 배열을 가리키는 정보처럼 보이는 값이 나온다는 점을 보여준다.



배열 값 뽑아내기

예제: ArrayTest1

int [] score = {100, 90, 80, 70, 60, 50};
System.out.println(score[0]);

// 출력결과
// 100


for (int i = 0; i < score.length; i++) {
    System.out.println(score[i]);
}

// 출력결과
// 100
// 90
// 80
// 70
// 60
// 50

이 코드는 배열 안의 값을 실제로 출력하려면 원소를 하나씩 꺼내야 한다는 점을 보여준다.



헷갈리기 쉬운 부분

배열 변수 주소값 VS 배열 값

아래 두 코드는 완전히 다르다.

System.out.println(score);    // 배열 변수 출력
System.out.println(score[0]); // 배열 한 칸 출력
  • score는 배열 전체를 가리키는 변수
  • score[0]는 배열 안의 첫 번째 값

그래서 배열 전체를 그대로 출력한다고 해서 값이 자동으로 전부 나오는 것은 아니다.



배열 출력 for문 공식

반복 조건에 6처럼 숫자를 직접 쓰는 것보다 score.length를 쓰는 게 좋다.

for (int i = 0; i < score.length; i++)

이렇게 써야 배열 크기가 바뀌어도 코드를 덜 고치게 된다.



6. 배열 복사

개념

배열은 한 번 만들면 길이를 바꿀 수 없다.
그래서 더 큰 배열이 필요할 때는 기존 배열 자체를 늘리는 것이 아니라, 새 배열을 만든 뒤 기존 값을 옮겨 담는 방식을 사용한다.
이 과정을 배열 복사라고 한다.


예를 들어 길이 5인 배열이 있는데 길이 10짜리 배열이 필요하다면 흐름은 다음과 같다.
1. 더 큰 새 배열을 만든다.
2. 기존 배열의 값을 새 배열로 복사한다.
3. 배열 변수가 새 배열을 가리키게 한다.

즉, 배열 복사는 단순히 크기를 바꾸는 작업이 아니라
기존 데이터는 유지하면서 더 큰 새 배열로 옮겨 가는 작업이라고 보면 된다.



핵심 특징

배열 복사의 핵심은 새 배열 생성 + 기존 값 복사다.
배열 길이는 바뀌지 않기 때문에, 결국 새로운 배열을 만들어야 한다.


이때 가장 중요한 점은 두 가지다.
첫째,

score = new int[10];

이 코드는 복사가 아니라 새 배열을 다시 만든 것이다.
즉, 참조 대상만 바뀌고 기존 값은 옮겨지지 않는다.



둘째,
배열 복사는 보통 다음 두 가지 방식으로 많이 한다.
1. for문으로 직접 하나씩 복사
2. System.arraycopy()로 한 번에 복사


처음 배울 때는 for문 방식이 가장 이해하기 쉽다.
배열의 각 칸을 하나씩 꺼내서 새 배열에 넣는 구조이기 때문이다.

System.arraycopy()는 자바가 제공하는 복사 기능이다.
직접 반복문을 쓰지 않아도 여러 값을 한 번에 옮길 수 있다.

코드 예제

예제: ArrayCopyTest1

public class ArrayCopyTest1 {
    public static void main(String[] args) {
        int[] oldArr = {10, 20, 30, 40, 50};
        int[] newArr = new int[10];

        for (int i = 0; i < oldArr.length; i++) {
            newArr[i] = oldArr[i];
        }

        for (int i = 0; i < newArr.length; i++) {
            System.out.print(newArr[i] + " ");
        }

        // 출력결과
        // 10 20 30 40 50 0 0 0 0 0
    }
}

이 코드는 배열 복사의 가장 기본 형태를 보여준다.
먼저 oldArr에 기존 값이 들어 있고, newArr는 더 큰 배열로 새로 만든다.

핵심은 이 부분이다.

for (int i = 0; i < oldArr.length; i++) {
    newArr[i] = oldArr[i];
}

이 반복문이 기존 배열의 값을 하나씩 꺼내서 새 배열에 넣는다.
그래서 앞의 5칸은 기존 값이 복사되고, 나머지 칸은 아직 값을 넣지 않았으므로 기본값 0이 들어 있다.



예제: ArrayCopyTest2

public class ArrayCopyTest2 {
    public static void main(String[] args) {
        int[] oldArr = {10, 20, 30, 40, 50};
        int[] newArr = new int[10];

        System.arraycopy(oldArr, 0, newArr, 0, oldArr.length);

        for (int i = 0; i < newArr.length; i++) {
            System.out.print(newArr[i] + " ");
        }

        // 출력결과
        // 10 20 30 40 50 0 0 0 0 0
    }
}

이 코드는 자바에서 제공하는 System.arraycopy()를 사용한 예제다.
반복문을 직접 쓰지 않고도 배열의 값을 복사할 수 있다.

System.arraycopy(oldArr, 0, newArr, 0, oldArr.length);

이 줄은 다음 뜻이다.

  • oldArr에서
  • 0번 인덱스부터
  • newArr의 0번 인덱스 위치에
  • oldArr.length개만큼 복사한다

즉, oldArr의 처음부터 끝까지를 newArr의 앞부분에 그대로 복사한 것이다.


처음에는 문장이 길어 보여도, 실제 의미는
“기존 배열 내용을 새 배열로 옮긴다”는 뜻이다.



헷갈리기 쉬운 부분

초보자가 가장 많이 헷갈리는 부분은
새 배열 생성과 배열 복사를 같은 것으로 보는 것이다.

int[] score = new int[5];
score[0] = 100;

score = new int[10];
System.out.println(score[0]);

// 출력결과
// 0

이 경우 100이 유지될 것 같지만 실제로는 0이 출력된다.
왜냐하면 길이 10인 완전히 새로운 배열을 만든 것이지, 기존 배열의 값을 복사한 것이 아니기 때문이다.


즉,

  • new int[10] → 새 배열만 만든 것
  • 배열 복사 → 새 배열을 만들고 기존 값까지 옮긴 것

이 둘은 분명히 다르다.


또 하나 주의할 점은 복사할 때 반복문의 조건을 잘못 쓰면 에러가 날 수 있다는 것이다.

예를 들어 새 배열의 길이를 기준으로 무조건 복사하려고 하면,
기존 배열보다 큰 범위를 읽게 되어 문제가 생길 수 있다.
그래서 보통은 기존 배열 길이만큼만 복사해야 안전하다.

참고

배열 복사는 나중에 Arrays.copyOf() 같은 방식으로도 할 수 있다.
하지만 지금 단계에서는 먼저

  • 새 배열을 만든다
  • 기존 값을 옮긴다
  • 배열 변수는 새 배열을 가리키게 된다

이 흐름을 정확히 이해하는 것이 더 중요하다.



8. 향상된 for문 (forEach)

개념

배열을 처음부터 끝까지 순서대로 읽을 때는 일반 for문을 쓸 수도 있고, 향상된 for문을 쓸 수도 있다.
향상된 for문은 보통 for-each문이라고도 부른다.

일반 for문은 인덱스를 직접 사용해서 배열의 값을 꺼낸다.

for (int i = 0; i < nums.length; i++) {
    System.out.print(nums[i] + " ");
}

반면 향상된 for문은 인덱스를 직접 쓰지 않고, 배열 안의 값을 앞에서부터 하나씩 바로 꺼내서 사용한다.

for (int d : nums) {
    System.out.print(d + " ");
}

즉,

  • 일반 for문 → 몇 번째 칸인지 직접 다룬다
  • 향상된 for문 → 값을 하나씩 바로 꺼내 쓴다

이렇게 이해하면 된다.



코드 예제

예제: ArrayTest6

int nums[] = { 10, 5, 7, 6, 21, 3, 22, 18, 9, 2, 25, 14 };

for(int i=0; i < nums.length; i++)
    System.out.print(nums[i]+" ");
System.out.println();

for(int d : nums)
    System.out.print(d+" ");

// 출력결과
// 10 5 7 6 21 3 22 18 9 2 25 14
// 10 5 7 6 21 3 22 18 9 2 25 14

이 코드는 일반 for문과 향상된 for문이 같은 배열을 같은 순서로 출력할 수 있다는 점을 보여준다.
차이는 출력 결과가 아니라, 배열을 다루는 방식에 있다.

일반 for문은 nums[i]처럼 인덱스를 이용해서 값을 꺼낸다.
반면 향상된 for문은 d에 배열의 값을 하나씩 넣어가며 사용한다.



헷갈리기 쉬운 부분

향상된 for문은 편하지만 인덱스를 직접 제어할 수는 없다.

그래서 아래 같은 경우에는 일반 for문이 더 적합하다.

  • 특정 위치의 값을 바꾸는 경우
  • i += 2처럼 건너뛰면서 출력하는 경우
  • 마지막 원소부터 역순으로 출력하는 경우

예를 들어 이런 코드는 일반 for문이 필요하다.

for(int i = nums.length - 1; i >= 0; i--)
    System.out.print(nums[i] + " ");

이처럼 위치를 직접 다뤄야 하는 작업은 향상된 for문으로 하기 어렵다.


즉,

  • 배열 전체를 앞에서부터 순서대로 읽기 → 향상된 for문
  • 인덱스를 이용해서 위치를 제어해야 하기 → 일반 for문

이렇게 구분해서 보면 된다.



9. 응용 예제 1 - 배열 원소를 여러 방식으로 출력하기

문제에서 무엇을 하려는지

이 예제는 배열 안의 값을 여러 방식으로 꺼내 보는 연습이다.
첫 번째 값, 마지막 값, 전체 원소, 한 칸씩 건너뛴 원소, 역순 원소를 출력하면서 인덱스를 어떻게 다루는지 복습하는 것이 핵심이다.



이 예제에서 사용된 개념

  • length
  • 인덱스
  • 일반 for문
  • i += 2
  • 역순 반복



코드 흐름

먼저 배열의 길이를 출력해서 전체 원소 개수를 확인한다.
그다음 nums[0]으로 첫 번째 값을 꺼내고, nums[nums.length - 1]로 마지막 값을 꺼낸다.

이후에는 반복문을 세 가지 방식으로 사용한다.

첫 번째 for문은 처음부터 끝까지 모든 원소를 순서대로 출력한다.
두 번째 for문은 i += 2를 사용해서 인덱스를 2씩 증가시키며 건너뛰어 출력한다.
세 번째 for문은 마지막 인덱스부터 시작해서 거꾸로 감소시키며 역순으로 출력한다.

코드 예제

예제: ArrayTest5

int nums[] = { 10, 5, 7, 6, 21, 3, 22, 18, 9, 2, 25, 14 };

System.out.println(nums.length);
System.out.println(nums[0]);
System.out.println(nums[nums.length - 1]);

for(int i = 0; i < nums.length; i++)
    System.out.print(nums[i] + " ");
System.out.println();

for(int i = 0; i < nums.length; i += 2)
    System.out.print(nums[i] + " ");
System.out.println();

for(int i = nums.length - 1; i >= 0; i--)
    System.out.print(nums[i] + " ");

// 출력결과
// 12
// 10
// 14
// 10 5 7 6 21 3 22 18 9 2 25 14
// 10 7 21 22 9 25
// 14 25 2 9 18 22 3 21 6 7 5 10

헷갈리기 쉬운 부분

i += 2는 값이 짝수인 원소를 찾는 코드가 아니다.
이 코드는 인덱스를 0, 2, 4, 6 ...처럼 2칸씩 움직이면서 출력하는 것이다.

즉, 여기서 출력되는 것은 짝수 값이 아니라 짝수 인덱스 위치의 원소다.

또 마지막 값을 꺼낼 때는 nums[nums.length]가 아니라 nums[nums.length - 1]를 써야 한다.
배열의 인덱스는 0부터 시작하므로, 마지막 인덱스는 항상 length - 1이기 때문이다.



10. 응용 예제 2 - 최대값과 최소값 찾기

문제에서 무엇을 하려는지

이 예제는 배열에 여러 값을 넣은 뒤, 그 안에서 가장 큰 값과 가장 작은 값을 찾는 연습이다.
배열은 값을 저장하는 데서 끝나는 것이 아니라, 이렇게 여러 값을 한 번에 비교할 때도 많이 사용된다.



이 예제에서 사용된 개념

  • 배열 생성
  • 인덱스로 값 저장
  • 반복문
  • 비교 연산
  • 최대값, 최소값 갱신



코드 흐름

먼저 길이 5인 배열을 만든다.
그다음 반복문으로 각 칸에 1~45 사이의 난수를 넣는다.

배열이 준비되면 첫 번째 값을 기준값으로 잡는다.
bigNum에는 현재까지의 최대값을 저장하고, minNum에는 현재까지의 최소값을 저장한다.

이후 두 번째 원소부터 끝까지 반복하면서 비교한다.

  • 현재 값이 bigNum보다 크면 최대값을 바꾼다.
  • 현재 값이 minNum보다 작으면 최소값을 바꾼다.

이 과정을 끝까지 반복하면 최종적으로 최대값과 최소값이 남게 된다.

코드 예제

예제: ArrayTest4

int[] nums = new int[5];

for(int i = 0; i < nums.length; i++)
    nums[i] = (int)(Math.random() * 45) + 1;

for(int i = 0; i < nums.length; i++)
    System.out.print(nums[i] + " ");
System.out.println();

for(int data : nums)
    System.out.print(data + " ");

int bigNum = nums[0];
int minNum = nums[0];

for(int i = 1; i < nums.length; i++) {
    if (bigNum < nums[i])
        bigNum = nums[i];
    if (minNum > nums[i])
        minNum = nums[i];
}

System.out.printf("\nnums라는 배열에서 제일 큰 값 : %d", bigNum);
System.out.printf("\nnums라는 배열에서 제일 작은 값 : %d", minNum);

// 출력결과 예시
// 12 33 7 41 25
// 12 33 7 41 25
// nums라는 배열에서 제일 큰 값 : 41
// nums라는 배열에서 제일 작은 값 : 7

헷갈리기 쉬운 부분

최대값과 최소값을 구할 때 0으로 시작하면 잘못될 수 있다.
예를 들어 배열 안의 값이 모두 음수라면, 최대값을 0으로 시작하는 방식은 틀린 결과를 만들 수 있다.

그래서 보통은 배열의 첫 번째 값을 기준값으로 잡고 시작한다.

또 비교 반복문을 i = 1부터 시작하는 이유는 첫 번째 값은 이미 기준값으로 사용했기 때문이다.
첫 번째 값부터 다시 비교하면 불필요한 비교를 한 번 더 하게 된다.



11. 응용 예제 3 - 배열 원소의 합과 짝수 원소의 합 구하기

문제에서 무엇을 하려는지

이 예제는 배열에 들어 있는 값들을 모두 더해서 총합을 구하고,
그중에서 짝수 값만 골라서 짝수 원소의 합을 구하는 연습이다.

즉, 배열에서 값을 하나씩 꺼내 누적하는 방법과, 조건에 맞는 값만 골라 계산하는 방법을 함께 복습하는 예제다.



이 예제에서 사용된 개념

  • 일반 for문
  • 향상된 for문
  • 누적합
  • 조건문
  • 나머지 연산



코드 흐름

먼저 일반 for문과 향상된 for문으로 같은 배열을 각각 출력한다.
이 부분은 두 반복문이 배열을 어떻게 순회하는지 비교해서 보는 데 의미가 있다.

그다음 sumV라는 누적 변수에 배열의 모든 원소를 더해서 총합을 구한다.
이 작업은 일반 for문으로도 할 수 있고, 향상된 for문으로도 할 수 있다.

이후 evenSumV를 사용해서 짝수 값만 따로 더한다.
이때는 각 원소를 보면서 2로 나누었을 때 나머지가 0인지 확인한 뒤, 짝수일 때만 누적한다.

코드 예제

예제: ArrayTest6

int nums[] = { 10, 5, 7, 6, 21, 3, 22, 18, 9, 2, 25, 14 };

for(int i = 0; i < nums.length; i++)
    System.out.print(nums[i] + " ");
System.out.println();

for(int d : nums)
    System.out.print(d + " ");
System.out.println();

int sumV = 0;
for(int i = 0; i < nums.length; i++)
    sumV += nums[i];
System.out.println("\n" + sumV);

sumV = 0;
for(int d : nums)
    sumV += d;
System.out.println(sumV);

int evenSumV = 0;
for(int i = 0; i < nums.length; i++)
    if (nums[i] % 2 == 0)
        evenSumV += nums[i];
System.out.println("\n" + evenSumV);

evenSumV = 0;
for(int d : nums)
    if (d % 2 == 0)
        evenSumV += d;
System.out.println(evenSumV);

// 출력결과
// 10 5 7 6 21 3 22 18 9 2 25 14
// 10 5 7 6 21 3 22 18 9 2 25 14
//
// 142
// 142
//
// 72
// 72

헷갈리기 쉬운 부분

짝수 원소의 합은 짝수 인덱스의 합이 아니다.
배열 안에 있는 값들 중에서 값 자체가 짝수인 원소들만 더하는 것이다.

예를 들어 인덱스가 1인 위치에 6이 들어 있으면, 인덱스는 홀수여도 값이 짝수이므로 합에 포함된다.

또 총합을 한 번 구한 뒤에 다시 합을 구할 때는 누적 변수를 0으로 다시 초기화해야 한다.
초기화하지 않으면 이전 계산 결과가 남아 있어서 값이 계속 누적된다.



12. 응용 예제 4 - 문자 배열 다루기

문제에서 무엇을 하려는지

이 예제는 문자 배열에 들어 있는 각 문자를 하나씩 꺼내서,
그 문자가 대문자인지 소문자인지 구분하는 연습이다.

즉, 숫자 배열만이 아니라 문자 배열도 같은 방식으로 반복문과 함께 다룰 수 있다는 점을 보여준다.



이 예제에서 사용된 개념

  • char[]
  • 향상된 for문
  • 문자 비교
  • 조건문



코드 흐름

먼저 문자들이 들어 있는 char 배열을 만든다.
그다음 향상된 for문으로 배열 안의 문자를 하나씩 꺼낸다.

각 문자를 꺼낼 때마다

  • 'A' 이상 'Z' 이하이면 대문자
  • 그 외에는 소문자

로 판단해서 출력한다.

즉, 배열에서 값을 하나씩 꺼내는 흐름은 숫자 배열과 같고,
차이는 그 값을 숫자가 아니라 문자로 비교한다는 점이다.



코드 예제

예제: ArrayTest7

char letters[] = {'A', 'B', 'z', 't', 'M', 'm'};

for (char ch : letters) {
    if (ch >= 'A' && ch <= 'Z')
        System.out.println(ch + "는 대문자입니다.");
    else
        System.out.println(ch + "는 소문자입니다.");
}

// 출력결과
// A는 대문자입니다.
// B는 대문자입니다.
// z는 소문자입니다.
// t는 소문자입니다.
// M는 대문자입니다.
// m는 소문자입니다.

헷갈리기 쉬운 부분

여기서는 문자열이 아니라 문자 하나를 다루고 있다.
그래서 "A"가 아니라 'A'처럼 작은따옴표를 사용한다.

  • 'A' → 문자 1개
  • "A" → 문자열

이 둘은 전혀 다른 자료형이다.

또 이 예제는 대문자 여부만 검사하고, 대문자가 아니면 모두 소문자로 처리하고 있다.
지금 예제에 들어 있는 값은 모두 영문자라서 문제가 없지만, 다른 문자가 들어오면 같은 방식으로 처리되지 않을 수도 있다는 점은 같이 알아두면 좋다.

profile
이언덕
이전 포스트

[아이티센 부트캠프] (반복문)

다음 포스트

[아이티센 부트캠프] (다차원 배열)

0개의 댓글