컬렉션은 안에서 뭘 하고, 제네릭과 모던 문법은 왜 그렇게 생겼을까?

HashMap은 내부에 버킷 배열(Node[] table)을 두고, 키의 hashCode()를 한 번 더 섞어(스프레드) 버킷 인덱스를 정해요. 같은 버킷에 여러 키가 몰리면(충돌) 그 버킷은 링크드 리스트로 이어집니다.

List<Integer> list = new ArrayList<>(List.of(1, 2, 3, 4));
for (Integer x : list) {
    if (x % 2 == 0) list.remove(x); // ❌ ConcurrentModificationException
}
list.removeIf(x -> x % 2 == 0);     // ✅ 안전한 조건 삭제

자바 제네릭은 컴파일 시점에만 타입을 검사하고, 컴파일 후엔 타입 정보를 지워요 — 이게 타입 소거(type erasure)예요. List<String>과 List<Integer>는 런타임엔 둘 다 그냥 List입니다(하위 호환을 위한 설계).

// src에서 꺼내(생산) dest에 넣는다(소비)
static <T> void copy(List<? super T> dest, List<? extends T> src) {
    for (int i = 0; i < src.size(); i++)
        dest.set(i, src.get(i));
}
List<Number> dst = new ArrayList<>(List.of(0, 0, 0));
List<Integer> s  = List.of(1, 2, 3);
copy(dst, s); // Integer(src) → Number(dest) : PECS 성립

스트림은 중간 연산(filter·map…)과 최종 연산(collect·forEach…)으로 나뉘어요. 핵심은 지연 평가(lazy) — 중간 연산은 정의만 쌓아두고, 최종 연산이 호출될 때 비로소 원소가 흐르며 한 번에 처리됩니다.

Stream<String> s = Stream.of("a", "b", "c")
    .filter(x -> { System.out.println("filter " + x); return true; });
// 여기까지 아무것도 출력 안 됨 (지연)
long n = s.count(); // 최종 연산 → 이제서야 filter 실행

var words = List.of("apple", "ant", "bee", "bear");
Map<Character, Long> countByInitial = words.stream()
    .collect(Collectors.groupingBy(w -> w.charAt(0), Collectors.counting()));
// {a=2, b=2}

// record: 한 줄로 불변 데이터 + equals/hashCode/toString 자동
record Point(int x, int y) {}

// sealed: 허용된 하위 타입만
sealed interface Shape permits Circle, Rect {}
record Circle(double r) implements Shape {}
record Rect(double w, double h) implements Shape {}

// switch 패턴 매칭 + record 디컨스트럭션 (Java 21)
static double area(Shape s) {
    return switch (s) {
        case Circle c -> Math.PI * c.r() * c.r();
        case Rect(double w, double h) -> w * h; // 구조 분해
    }; // sealed라 default 없이도 망라 성립
}