배열로 회원 목록 관리하기

회원 네 명을 담을 배열을 만들어 두었는데 아직 두 명만 가입했다고 해 봅시다. 배열에는 칸이 네 개 있지만 회원은 두 명뿐입니다. 그렇다고 나머지 두 칸이 비어 있는 것도 아닙니다. 배열을 만들 때 자바가 채워 넣은 기본값 null과 0이 들어 있습니다. 그래서 배열을 회원 저장소로 쓰려면 '칸이 몇 개인가'와 '회원이 몇 명 들어 있는가'를 따로 관리해야 합니다.

이 글에서는 배열과 인덱스에서 만든 병렬 배열과 회원 수 변수 size로 회원을 추가하고, 저장된 회원의 나이로 합계·평균·최솟값·최댓값을 구합니다. 마지막에는 이 기능들을 명령어로 실행하는 작은 프로그램으로 묶습니다.

배열 길이만큼 반복하면 생기는 일

먼저 자주 하는 실수부터 보겠습니다. 아래 프로그램은 용량 4인 배열 두 개에 회원 두 명을 넣은 뒤, 배열 길이 age.length만큼 반복하며 회원을 출력하고 나이 평균을 계산합니다.

public final class LengthInsteadOfSize {
    public static void main(String[] args) {
        String[] emails = new String[4];
        int[] age = new int[4];
        int size = 0;

        emails[size] = "[email protected]";
        age[size] = 40;
        size++;

        emails[size] = "[email protected]";
        age[size] = 50;
        size++;

        int total = 0;
        for (int index = 0; index < age.length; index++) {
            total += age[index];
            System.out.println(emails[index] + "=" + age[index]);
        }
        System.out.println("average=" + total / age.length);
    }
}

[email protected]=40
[email protected]=50
null=0
null=0
average=22

예외 없이 끝났지만 결과는 틀렸습니다. 세 번째와 네 번째 줄의 null=0은 존재하지 않는 회원입니다. new String[4]와 new int[4]로 배열을 만들면 모든 칸이 기본값으로 채워지는데, String 배열은 null, int 배열은 0이 기본값입니다. 반복이 age.length, 즉 4까지 돌았으므로 아직 아무도 쓰지 않은 두 칸까지 출력된 것입니다.

평균도 틀렸습니다. 실제 회원 두 명의 평균은 (40 + 50) / 2 = 45인데, 이 프로그램은 합계 90을 용량 4로 나눴습니다. 게다가 total과 age.length가 둘 다 int라서 정수 나눗셈이 일어나고, 22.5에서 소수 부분까지 버려져 22가 출력되었습니다.

그림처럼 배열의 칸은 두 영역으로 나뉩니다. length는 배열에 담을 수 있는 칸의 수, 즉 용량(capacity)이며 배열을 만들 때 정해진 뒤로 바뀌지 않습니다. 반면 size는 지금 실제로 저장된 회원 수이고, 회원이 추가될 때마다 1씩 늘어납니다. 회원을 인덱스 0부터 빈틈없이 채우면 0부터 size - 1까지가 실제 회원이고, size부터 length - 1까지는 아직 쓰지 않은 칸입니다.

따라서 회원을 출력하거나 나이를 더하는 반복은 size까지만 돌고, 평균의 분모도 size를 씁니다. length는 새 회원을 넣을 자리가 남았는지 판단할 때 씁니다. 위 프로그램의 반복 조건을 index < size로, 평균 계산을 (double) total / size로 바꾸면 두 회원과 average=45.0이 출력됩니다. (double)을 붙이는 이유는 뒤에서 평균을 계산할 때 설명합니다.

회원 추가하기: 자리 확인, 기록, 개수 증가

size에는 쓸모가 하나 더 있습니다. 회원을 0번 칸부터 빈틈없이 채우므로, 현재 회원 수 size가 곧 다음 회원이 들어갈 빈칸의 인덱스입니다. 회원이 두 명이면 0번과 1번 칸이 차 있고 다음 자리는 2번입니다. 그래서 회원 추가는 'size번 칸에 쓰고 size를 1 늘린다'로 정리됩니다.

다만 쓰기 전에 자리가 남았는지 먼저 확인해야 합니다. size가 용량과 같아지면 배열이 가득 찬 것이고, 그때의 size번 칸은 배열에 존재하지 않습니다.

if (size >= emails.length) {
    System.out.println("저장 공간이 가득 찼습니다.");
} else {
    emails[size] = "[email protected]";
    age[size] = 35;
    size++;
}

두 배열에 값을 모두 쓴 다음 맨 마지막에 size를 늘리는 순서에도 이유가 있습니다. size는 '여기까지는 회원이 확실히 들어 있다'는 표시이므로 두 칸을 모두 채운 뒤에 늘려야 합니다. size부터 늘려 놓고 이메일 검사에서 거절하면, 아무것도 쓰지 않은 칸이 회원 수에 포함되어 목록에 null=0이 나타납니다. 이 실수는 3장의 마지막 글에서 직접 재현해 봅니다.

자리 확인을 빼면 생기는 일

용량 검사를 빼고 용량 2인 배열에 세 번째 회원을 넣으면 어떻게 되는지 보겠습니다. 다음 코드는 앞의 if (size >= emails.length) 검사 없이 대입만 세 번 연달아 실행합니다. 문법에는 문제가 없어 컴파일은 되므로, 문제는 실행 중에 드러납니다.

public final class CapacityOverflow {
    public static void main(String[] args) {
        String[] emails = new String[2];
        int size = 0;

        emails[size++] = "[email protected]";
        emails[size++] = "[email protected]";
        emails[size++] = "[email protected]";
    }
}

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 2 out of bounds for length 2
	at CapacityOverflow.main(CapacityOverflow.java:8)

emails[size++] = ...는 지금의 size 값을 인덱스로 써서 그 칸에 대입하고, size는 1 늘리는 짧은 표현입니다. 세 번째 대입에서 size는 2인데, 길이 2인 배열의 인덱스는 0과 1뿐이므로 ArrayIndexOutOfBoundsException이 발생합니다. 메시지는 접근하려던 인덱스 2와 배열 길이 2를 함께 알려 주고, 다음 줄의 CapacityOverflow.java:8은 예외가 난 소스 코드의 줄 번호입니다.

예외 메시지가 원인을 정확히 알려 주기는 하지만, 사용자가 회원을 한 명 더 입력했다는 이유로 프로그램 전체가 멈추는 것은 바람직하지 않습니다. 배열이 가득 차는 것은 충분히 예상할 수 있는 상황입니다. 그러니 쓰기 전에 공간을 확인하고, 예외 대신 '저장 공간이 가득 찼습니다' 같은 안내로 바꿔 주는 편이 낫습니다. 앞의 if (size >= emails.length)가 바로 그 일을 합니다.

더 깊이: emails[size++]는 실패해도 size를 늘린다

emails[size++] = value는 짧아서 자주 쓰이지만, 대입이 실패했을 때 size가 어떻게 되는지는 겉으로 드러나지 않습니다. Java 언어 명세(JLS §15.26.1)에 따르면 배열 원소에 대입할 때는 배열 식, 인덱스 식, 오른쪽 값을 차례로 계산한 다음에 인덱스가 범위 안인지 검사합니다. 그래서 인덱스 식의 size++는 예외가 나기 전에 이미 실행됩니다.

public final class IncrementBeforeStore {
    public static void main(String[] args) {
        String[] emails = new String[2];
        int size = 2;

        try {
            emails[size++] = "[email protected]";
        } catch (ArrayIndexOutOfBoundsException error) {
            System.out.println("error: " + error.getMessage());
        }
        System.out.println("size=" + size);
    }
}

error: Index 2 out of bounds for length 2
size=3

대입은 실패했는데 size는 3이 되었습니다. 이 예외를 잡고 프로그램을 계속 진행하면 회원은 두 명인데 size는 3인 상태가 남습니다. 쓰기와 개수 증가를 별도의 문장으로 나누고 size++를 마지막에 두면, 쓰기에서 예외가 날 때 size++까지 가지 않으므로 이런 일이 생기지 않습니다.

저장된 회원만 합산하고 평균 내기

합계와 평균은 반복 범위를 size로 바꾸기만 하면 됩니다. 아래 프로그램은 용량 5인 배열에 회원 네 명의 나이를 넣고 합계와 평균을 구합니다. 비교를 위해 정수 나눗셈 결과도 함께 출력합니다.

public final class SummaryWithSize {
    public static void main(String[] args) {
        int[] age = new int[5];
        int size = 4;
        age[0] = 40;
        age[1] = 50;
        age[2] = 30;
        age[3] = 25;

        int total = 0;
        for (int index = 0; index < size; index++) {
            total += age[index];
        }

        double average = size == 0 ? 0.0 : (double) total / size;
        System.out.println("total=" + total);
        System.out.println("int division=" + total / size);
        System.out.println("average=" + average);
    }
}

total=145
int division=36
average=36.25

다섯 번째 칸(인덱스 4)은 반복에 들어가지 않으므로 합계는 40 + 50 + 30 + 25 = 145입니다. 두 번째 줄은 int끼리 나눈 결과입니다. 정수 나눗셈은 몫만 남기고 소수 부분을 버리므로 36.25가 아니라 36이 됩니다. 결과를 double 변수에 담는다고 해결되지도 않습니다. double average = total / size;라고 쓰면 오른쪽의 정수 나눗셈이 먼저 끝나 36이 되고, 그 36이 36.0으로 바뀔 뿐입니다.

실수 나눗셈을 하려면 나누기 전에 피연산자 하나를 double로 바꿔야 합니다. (double) total / size에서 캐스트 (double)은 나눗셈보다 먼저 적용되어 total을 145.0으로 바꾸고, 그러면 size도 자동으로 double로 넓혀져 세 번째 줄의 36.25가 나옵니다. 반대로 (double) (total / size)처럼 괄호로 나눗셈을 먼저 묶으면 이미 정수 나눗셈이 끝난 36을 바꾸므로 36.0이 됩니다.

size == 0 ? 0.0 : ... 부분은 회원이 한 명도 없을 때를 위한 것입니다. 회원이 없는데 그대로 나누면 어떻게 될까요? int끼리 0으로 나누면 ArithmeticException: / by zero 예외가 발생합니다. 한쪽을 double로 바꾼 나눗셈에서는 예외 대신 0.0 / 0.0이 계산되어, '숫자가 아님'을 뜻하는 특별한 값 NaN(Not a Number)이 나옵니다. 어느 쪽도 사용자에게 보여 줄 결과가 아니므로 나누기 전에 size를 확인합니다.

여기서는 삼항 연산자로 회원이 없을 때 0.0을 쓰기로 했습니다. 하지만 평균 0.0은 '나이가 0세인 회원들'처럼 오해될 수도 있습니다. 화면에 회원 없음을 출력하는 편이 더 정확할 때도 많으므로, 회원이 없을 때 무엇을 보여 줄지는 프로그램의 요구사항에 맞춰 정합니다.

합계를 담는 변수의 타입도 한 번 따져 볼 만합니다. int가 담을 수 있는 가장 큰 값은 2,147,483,647(약 21억)입니다. 회원 나이 몇 개를 더할 때는 충분하지만, 하루를 밀리초로 나타낸 86,400,000을 25번만 더해도 이 범위를 넘습니다. 범위를 넘은 int 계산은 예외 없이 음수 같은 엉뚱한 값으로 바뀌므로(이를 오버플로라고 합니다), 합계가 커질 수 있으면 long total을 씁니다.

가장 어린 회원과 가장 나이 많은 회원 찾기

최솟값을 구할 때 int min = 0;으로 시작하는 실수가 흔합니다. 회원 나이는 모두 양수이므로 어떤 나이도 0보다 작지 않고, min은 끝까지 0으로 남습니다. 0은 저장된 회원의 나이가 아니라 개발자가 임의로 넣은 값이기 때문입니다.

올바른 출발점은 실제 회원 가운데 하나입니다. 첫 회원(인덱스 0)을 일단 최솟값이자 최댓값으로 정하고, 나머지 회원과 하나씩 비교하면서 더 작거나 더 큰 값을 만나면 바꿉니다. 이렇게 하면 결과는 언제나 실제로 저장된 회원 중 하나가 됩니다. 또 하나의 요령은 나이 값 대신 인덱스를 기억하는 것입니다. 병렬 배열에서는 같은 인덱스의 이메일과 나이가 한 회원이므로, 인덱스만 알면 그 회원의 이메일도 함께 찾을 수 있습니다.

public final class MemberExtremes {
    public static void main(String[] args) {
        String[] emails = {"[email protected]", "[email protected]", "[email protected]", null};
        int[] age = {40, 55, 25, 0};
        int size = 3;

        if (size == 0) {
            System.out.println("회원 없음");
            return;
        }

        int minIndex = 0;
        int maxIndex = 0;
        for (int index = 1; index < size; index++) {
            if (age[index] < age[minIndex]) {
                minIndex = index;
            }
            if (age[index] > age[maxIndex]) {
                maxIndex = index;
            }
        }

        System.out.println("min=" + emails[minIndex] + ":" + age[minIndex]);
        System.out.println("max=" + emails[maxIndex] + ":" + age[maxIndex]);
    }
}

[email protected]:25
[email protected]:55

반복이 진행되는 동안 두 인덱스가 어떻게 바뀌는지 따라가 보겠습니다. 처음에는 둘 다 0, 즉 [email protected]의 나이 40을 가리킵니다. 반복은 인덱스 0이 이미 출발점으로 쓰였으므로 1부터 시작합니다.

인덱스 1의 55는 지금까지의 최댓값 40보다 크므로 maxIndex가 1로 바뀌고, 인덱스 2의 25는 최솟값 40보다 작으므로 minIndex가 2로 바뀝니다. 인덱스 3은 size가 3이라 비교하지 않습니다. 그 칸의 null과 0은 회원이 아니기 때문입니다. 마지막에 두 인덱스로 이메일과 나이를 함께 꺼내 출력합니다.

같은 최댓값이 둘 이상이면 비교 연산자에 따라 결과가 달라집니다. 나이가 {40, 55, 25, 55}라면 >로 비교할 때는 먼저 나온 인덱스 1이 남고, >=로 비교할 때는 같은 값을 만날 때마다 바꾸므로 나중에 나온 인덱스 3이 남습니다. 어느 쪽이 맞는지는 문법이 아니라 '동점이면 먼저 가입한 회원을 보여 준다' 같은 요구사항이 정합니다.

마지막으로 size == 0 검사를 맨 앞에 둔 이유를 보겠습니다. return;은 main을 그 자리에서 끝내는 문장으로, 회원이 없으면 회원 없음만 출력하고 나머지 계산은 건너뜁니다(return은 return과 호출 스택에서 자세히 다룹니다). 이 검사를 빼면 반복이 한 번도 돌지 않아 출발점인 인덱스 0이 그대로 결과가 됩니다. 용량 4인 빈 배열이라면 min=null:0처럼 존재하지 않는 회원이 출력되고, 길이가 0인 배열이라면 인덱스 0에 접근하는 순간 ArrayIndexOutOfBoundsException이 발생합니다.

칸이 다섯 개인 new int[5]도 size가 0이면 회원은 한 명도 없습니다. 배열에 칸이 있는 것과 회원이 있는 것은 다른 이야기이고, 최솟값과 최댓값은 회원이 한 명 이상일 때만 정의됩니다.

명령을 읽어 회원 추가·목록·요약 실행하기

이제 지금까지의 조각을 한 프로그램으로 묶어 보겠습니다. 이 프로그램은 한 줄에 명령 하나를 읽습니다. add를 읽으면 다음 두 줄을 이메일과 나이로 읽어 회원을 추가하고, list는 목록을, summary는 합계와 평균을 출력하며, quit을 읽으면 끝납니다. 실행할 때마다 같은 결과를 볼 수 있도록 Scanner로 키보드 입력 받기에서처럼 입력을 문자열로 고정했습니다.

import java.util.Scanner;

public final class ArrayMemberRegistry {
    public static void main(String[] args) {
        Scanner scanner = new Scanner("add\n[email protected]\n40\nadd\n[email protected]\n50\nlist\nsummary\nquit\n");
        String[] emails = new String[3];
        int[] age = new int[3];
        int size = 0;
        boolean running = true;

        while (running && scanner.hasNextLine()) {
            String command = scanner.nextLine().trim();

            switch (command) {
                case "add" -> {
                    if (size >= emails.length) {
                        System.out.println("full");
                        break;
                    }

                    String email = scanner.nextLine().trim();
                    int value = Integer.parseInt(scanner.nextLine().trim());
                    if (email.isEmpty() || value < 14 || value > 120) {
                        System.out.println("invalid");
                        break;
                    }

                    emails[size] = email;
                    age[size] = value;
                    size++;
                    System.out.println("added");
                }
                case "list" -> {
                    for (int index = 0; index < size; index++) {
                        System.out.println((index + 1) + ". " + emails[index] + "=" + age[index]);
                    }
                }
                case "summary" -> {
                    int total = 0;
                    for (int index = 0; index < size; index++) {
                        total += age[index];
                    }
                    double average = size == 0 ? 0.0 : (double) total / size;
                    System.out.println("total=" + total + ", average=" + average);
                }
                case "quit" -> running = false;
                default -> System.out.println("unknown");
            }
        }
    }
}

added
added
1. [email protected]=40
2. [email protected]=50
total=90, average=45.0

while은 running이 참이고 읽을 줄이 남아 있는 동안 명령을 하나씩 읽습니다. 화살표(->)를 쓴 switch는 일치한 case의 블록만 실행하고 다음 case로 넘어가지 않습니다. add 블록 안의 break는 switch를 즉시 끝낼 뿐 바깥의 while까지 끝내지는 않으므로, 실행은 다음 명령을 읽는 반복 조건으로 돌아갑니다.

add 블록은 앞에서 정한 순서를 그대로 따릅니다. 먼저 자리가 남았는지 확인하고, 그다음 이메일과 나이를 읽어 검사합니다. trim()은 앞뒤 공백을 지우고, Integer.parseInt는 "40" 같은 문자열을 정수 40으로 바꿉니다. 이메일이 비어 있거나 나이가 14 이상 120 이하가 아니면 invalid를 출력하고 switch를 끝내며, 모든 검사를 통과해야 두 배열의 size번 칸에 쓰고 마지막에 size를 늘립니다.

출력의 처음 두 줄은 두 번의 add가 성공한 결과입니다. list는 인덱스 0과 1의 회원을 출력하는데, 사람에게 보여 주는 번호는 1부터 시작하도록 index + 1을 붙였습니다. summary는 두 회원의 합계 90과 평균 45.0을 출력하고, quit은 running을 거짓으로 바꿔 반복을 끝냅니다. 아래 단계별 그림은 add 블록이 공간 검사, 값 검사, 기록과 size 증가를 어떤 순서로 실행하는지 보여 줍니다.

가득 찼을 때 남는 입력 줄

용량이 가득 찼을 때의 동작을 보려면 두 배열의 길이를 함께 3에서 1로 바꾸고 같은 입력으로 실행해 보세요. 출력은 다음과 같습니다.

added
full
unknown
unknown
1. [email protected]=40
total=40, average=40.0

첫 회원은 저장되지만 두 번째 add에서는 자리가 없어 full을 출력하고 switch를 끝냅니다. 이때 이메일과 나이는 아직 읽기 전이므로 [email protected]과 50 두 줄이 입력에 그대로 남습니다. 그래서 다음 두 번의 반복이 이 줄들을 명령으로 읽고, 둘 다 아는 명령이 아니어서 unknown을 출력합니다. 그 뒤의 목록에는 첫 회원만 나오고 합계와 평균은 40과 40.0입니다.

이 동작이 맞는지는 프로그램을 어떻게 쓰느냐에 달려 있습니다. 사람이 키보드로 한 줄씩 입력하는 대화형 프로그램이라면, 자리가 없을 때 이메일과 나이를 묻지 않고 바로 full을 알리는 지금 순서가 맞습니다. 저장하지도 못할 정보를 입력하게 만들 필요가 없으니까요. 반대로 이 예제처럼 입력이 미리 묶여 있다면 거절한 명령의 나머지 줄을 건너뛰는 처리가 따로 필요합니다. 입력을 언제 읽을지와 실패한 뒤 남은 입력을 어떻게 처리할지는 함께 정해야 하는 문제입니다.

키보드로 직접 입력하기

키보드로 직접 입력하려면 Scanner를 만드는 줄만 Scanner scanner = new Scanner(System.in);으로 바꾸면 됩니다. 이 프로그램은 입력 안내 문구를 출력하지 않으므로, 실행하면 화면에 직접 친 줄과 프로그램의 출력이 번갈아 나타납니다. add, 이메일, 나이를 차례로 입력하고 list, quit을 입력하면 다음과 같습니다.

add
[email protected]
40
added
list
1. [email protected]=40
quit

다만 이 프로그램은 add 뒤에 이메일과 정수 나이 두 줄이 반드시 온다고 가정합니다. 나이에 forty를 입력하면 Integer.parseInt가 NumberFormatException을 던지며 프로그램이 멈추고, add만 보낸 채 입력이 끝나 버리면 nextLine이 NoSuchElementException을 던집니다. 잘못된 입력 뒤에도 계속 동작하게 하려면 입력 검증과 재입력 반복에서 배운 hasNextLine 검사와 try/catch를 더해야 합니다.

이 프로그램이 지키는 네 가지 규칙

코드가 길어 보여도, 저장소가 올바르려면 몇 가지 조건만 늘 참이면 됩니다. 프로그램이 실행되는 동안 언제나 참이어야 하는 조건을 불변식(invariant)이라고 합니다. 이 프로그램의 불변식은 다음 네 가지입니다.

1. size는 0 이상이고 배열 길이 이하입니다.
2. 인덱스 0부터 size - 1까지는 두 배열 모두 같은 회원의 값이 들어 있습니다.
3. 인덱스 size부터 length - 1까지는 아직 쓰지 않은 칸이므로 회원으로 읽지 않습니다.
4. 인덱스 0부터 size - 1까지 저장된 회원은 모두 검사를 통과한 값입니다. 이메일은 비어 있지 않고 나이는 14 이상 120 이하입니다.

add의 검사 순서, list와 summary의 반복 범위, 두 배열에 다 쓴 뒤에야 size를 늘리는 size++의 위치는 모두 이 네 가지를 지키기 위한 것입니다. 검사 순서는 1번과 4번을, 반복 범위는 3번을, size++의 위치는 2번을 지킵니다. 새 기능을 추가할 때도 이 규칙이 깨지지 않는지부터 확인하면 됩니다. 예를 들어 회원 삭제 기능을 만든다면, 삭제한 뒤에도 2번 규칙대로 회원이 빈틈없이 앞에서부터 채워져 있어야 합니다(연습 문제 2).

이 구조는 회원 목록에만 쓰이는 것이 아닙니다. 상품 관리 예제도 흔히 상품명과 가격을 병렬 배열에 넣고 추가와 목록 출력을 반복하는데, 단어만 바꾸면 회원 목록과 똑같습니다.

다만 무엇을 받아들일지는 데이터마다 다릅니다. 무료 상품이 있다면 가격 0은 허용해야 하지만, 회원 나이 0은 거절해야 합니다. 저장하는 방법은 그대로 가져다 쓰고, 검증 규칙은 데이터에 맞게 정합니다.

정리

• 배열의 length는 담을 수 있는 칸의 수(용량)이고, size는 실제로 저장된 회원 수입니다. 회원을 읽고 합산하는 반복과 평균의 분모에는 size를 씁니다.
• 회원을 추가할 때는 자리 확인, 두 배열에 기록, size 증가의 순서를 지킵니다. 자리 확인을 빼면 ArrayIndexOutOfBoundsException으로 프로그램이 멈춥니다.
• 정수끼리 나누면 소수 부분이 버려지므로, 평균은 (double) total / size처럼 나누기 전에 한쪽을 double로 바꿉니다. 회원이 없을 때 보여 줄 결과는 나누기 전에 따로 정합니다.
• 최솟값과 최댓값은 실제 회원인 인덱스 0에서 출발합니다. 값 대신 인덱스를 기억하면 같은 회원의 이메일도 함께 찾을 수 있습니다.

연습 문제

1. 조건에 맞는 회원만 집계하기

나이 배열과 size가 주어졌을 때 30세 이상인 회원의 수, 나이 합계, 평균을 출력하세요. 조건을 만족하는 회원이 하나도 없으면 평균 대신 none을 출력합니다.

public final class QualifiedSummary {
    public static void main(String[] args) {
        int[] age = {20, 45, 30, 60, 0};
        int size = 4;
        int count = 0;
        int total = 0;

        for (int index = 0; index < size; index++) {
            if (age[index] >= 30) {
                count++;
                total += age[index];
            }
        }

        System.out.println("count=" + count);
        System.out.println("total=" + total);
        if (count == 0) {
            System.out.println("average=none");
        } else {
            System.out.println("average=" + (double) total / count);
        }
    }
}

count=3
total=135
average=45.0

2. 회원 삭제하기

회원 세 명이 저장된 상태에서 인덱스 0의 회원을 삭제하는 코드를 작성하세요. 삭제한 뒤에도 0부터 size - 1까지는 빈틈없이 회원이 있어야 하고, 두 배열의 같은 인덱스는 같은 회원이어야 합니다. 삭제할 인덱스에 회원이 없으면 안내 문구만 출력합니다.

public final class RemoveMember {
    public static void main(String[] args) {
        String[] emails = {"[email protected]", "[email protected]", "[email protected]", null};
        int[] age = {40, 50, 35, 0};
        int size = 3;
        int target = 0;

        if (target < 0 || target >= size) {
            System.out.println("no member at " + target);
            return;
        }
        for (int index = target; index < size - 1; index++) {
            emails[index] = emails[index + 1];
            age[index] = age[index + 1];
        }
        size--;
        emails[size] = null;
        age[size] = 0;

        for (int index = 0; index < size; index++) {
            System.out.println((index + 1) + ". " + emails[index] + "=" + age[index]);
        }
        System.out.println("size=" + size + ", emails[2]=" + emails[2] + ", age[2]=" + age[2]);
    }
}

1. [email protected]=50
2. [email protected]=35
size=2, emails[2]=null, age[2]=0

다음 글

지금은 모든 코드가 main 하나에 들어 있습니다. 나이를 합산하는 반복문은 summary에 있는데, 나중에 보고서 메뉴를 추가하면 같은 반복문을 또 쓰게 될 것입니다. 메서드와 매개변수에서는 이런 코드를 이름 붙은 메서드로 묶어 한곳에서 관리하는 방법을 배웁니다.