여러 데이터를 똑똑하게 담는 법

컬렉션(Collection)은 "여러 개의 데이터를 담고 편하게 다루기 위한 표준 자료구조 묶음"이에요. 자바는 이런 자료구조들을 미리 잘 만들어서 컬렉션 프레임워크(Collection Framework)라는 이름으로 제공해요. 우리는 그걸 가져다 쓰기만 하면 됩니다.

왜 필요할까요? 이전에 배운 배열을 떠올려 봐요. 배열은 강력하지만 결정적인 한계가 있었어요.

컬렉션은 성격에 따라 크게 세 종류로 나뉘어요. 이 셋만 알면 90%는 커버돼요.

List(리스트)는 데이터를 넣은 순서대로 저장하고, 같은 값이 여러 번 들어가는 것(중복)도 허용해요. 각 자리에는 인덱스(번호)가 0번부터 붙어서, 번호로 콕 집어 꺼낼 수 있어요. 대표 구현체가 바로 ArrayList예요.

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

public class ListExample {
    public static void main(String[] args) {
        // 문자열을 담는 List 생성 (제네릭은 곧 배웁니다)
        List<String> fruits = new ArrayList<>();

        // add : 뒤에 추가 (넣은 순서 유지)
        fruits.add("사과");
        fruits.add("바나나");
        fruits.add("사과");   // 중복 허용! 같은 값이 또 들어감

        // size : 개수 세기
        System.out.println("개수: " + fruits.size());   // 3

        // get(index) : 번호로 꺼내기 (0번부터)
        System.out.println("첫 번째: " + fruits.get(0)); // 사과
        System.out.println("두 번째: " + fruits.get(1)); // 바나나

        // remove(index) : 번호로 삭제
        fruits.remove(1);   // 바나나 삭제
        System.out.println("삭제 후 개수: " + fruits.size()); // 2
    }
}

Set(셋, 집합)은 같은 값을 두 번 담을 수 없어요. 이미 있는 값을 또 넣으려 하면 조용히 무시돼요. 그리고 순서를 보장하지 않아요 — 넣은 순서대로 나온다는 보장이 없죠. 대표 구현체는 HashSet이에요.

import java.util.HashSet;
import java.util.Set;

public class SetExample {
    public static void main(String[] args) {
        Set<String> names = new HashSet<>();

        names.add("철수");
        names.add("영희");
        names.add("철수");   // 중복! → 무시됨
        names.add("철수");   // 또 중복 → 무시됨

        // 철수를 3번 넣었지만 실제로는 1개만 저장됨
        System.out.println("총 인원: " + names.size()); // 2

        // 이미 있는 값인지 확인
        System.out.println(names.contains("영희")); // true
        System.out.println(names.contains("민수")); // false
    }
}

Map(맵)은 키(key)와 값(value)을 한 쌍으로 저장해요. 국어사전이 "단어 → 뜻"으로 되어 있듯, Map은 키로 값을 빠르게 찾아요. 여기서 키는 중복될 수 없어요(같은 키에 다시 넣으면 값이 덮어써져요). 대표 구현체는 HashMap이에요.

import java.util.HashMap;
import java.util.Map;

public class MapExample {
    public static void main(String[] args) {
        // 키:String(이름), 값:Integer(점수)
        Map<String, Integer> scores = new HashMap<>();

        // put(키, 값) : 저장
        scores.put("철수", 90);
        scores.put("영희", 85);
        scores.put("철수", 100);  // 같은 키! → 90이 100으로 덮어써짐

        // get(키) : 키로 값 꺼내기
        System.out.println("철수 점수: " + scores.get("철수")); // 100
        System.out.println("영희 점수: " + scores.get("영희")); // 85

        // containsKey(키) : 그 키가 있는지 확인
        System.out.println(scores.containsKey("영희")); // true
        System.out.println(scores.containsKey("민수")); // false

        // 키가 없으면 get은 null을 돌려줘요
        System.out.println(scores.get("민수")); // null
    }
}

지금까지 List<String>, Map<String, Integer> 처럼 꺾쇠 < > 안에 타입을 적었죠? 이게 바로 제네릭(Generics)이에요. "이 컬렉션에는 이런 타입만 담겠다"고 미리 선언하는 거예요.

// 제네릭 선언 : 이 리스트에는 String만 담는다!
List<String> list = new ArrayList<>();

list.add("hello");
// list.add(123);  // ❌ 컴파일 에러! String이 아니라서 아예 못 넣음

String s = list.get(0);  // 꺼낼 때 캐스팅 필요 없음! 자동으로 String

제네릭의 진짜 가치는 제네릭이 없을 때와 비교하면 확 와닿아요. 옛날 방식(제네릭 없이)에서는 아무 타입이나 담을 수 있어서 위험했어요.

// 🚫 제네릭이 없다면 (옛날 방식)
List list = new ArrayList();   // 타입 지정 안 함
list.add("hello");
list.add(123);        // 문자열도, 숫자도 다 들어감 (섞임!)

// 꺼낼 때 Object로 나와서 직접 캐스팅해야 함
String s = (String) list.get(0);  // 캐스팅 필요
String x = (String) list.get(1);  // 💥 실행 중 에러! 123은 String이 아님

한 가지 규칙이 있어요. 컬렉션은 기본형(int, double, boolean 등)을 직접 담을 수 없어요. 오직 객체(참조형)만 담을 수 있죠. 그래서 기본형에는 각각 짝이 되는 래퍼 클래스(Wrapper Class)가 있어요.

그래서 정수를 담을 때는 List<int>가 아니라 List<Integer>라고 써야 해요. 그런데 신기하게도, 여기에 그냥 int 값을 넣어도 잘 들어가요! 자바가 자동으로 변환해 주기 때문이에요.

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

public class BoxingExample {
    public static void main(String[] args) {
        List<Integer> nums = new ArrayList<>();

        // 오토박싱: int(5) → Integer 로 자동 포장되어 저장됨
        nums.add(5);
        nums.add(10);
        nums.add(3);

        // 언박싱: Integer → int 로 자동 풀려서 계산됨
        int first = nums.get(0);        // Integer → int
        int sum = nums.get(0) + nums.get(1); // 15

        System.out.println("첫 값: " + first); // 5
        System.out.println("합계: " + sum);    // 15
    }
}