컬렉션 프레임워크 — List, Set, Map 제대로 쓰기

// 배열: 크기를 미리 정해야 한다
String[] names = new String[3];
names[0] = "Alice";
names[1] = "Bob";
names[2] = "Charlie";
// names[3] = "Dave"; // ArrayIndexOutOfBoundsException!

Iterable
  └── Collection
        ├── List   — 순서 있음, 중복 허용
        ├── Set    — 순서 없음, 중복 불허
        └── Queue  — FIFO 구조

Map (별도 계층) — 키-값 쌍, 키 중복 불허

// 인터페이스 타입으로 선언 → 구현체를 바꿔도 나머지 코드는 안 바뀐다
List<String> names = new ArrayList<>();
// 나중에 LinkedList로 바꿔야 한다면?
// List<String> names = new LinkedList<>();

List<String> fruits = new ArrayList<>();

fruits.add("사과");
fruits.add("바나나");
fruits.add("체리");

fruits.get(0);             // "사과" — 인덱스로 접근
fruits.size();             // 3
fruits.set(1, "블루베리");   // 수정
fruits.remove(2);          // 인덱스로 삭제
fruits.remove("사과");      // 값으로 삭제
fruits.contains("블루베리"); // true

초기 상태 (기본 용량 10):
[사과][바나나][체리][ ][ ][ ][ ][ ][ ][ ]
                     ↑ 여유 공간

꽉 찼을 때 → 새 배열(기존의 1.5배) 생성 후 복사:
[사과][바나나][체리][딸기][...][포도][ ][ ][ ][ ][ ]
                                     ↑ 새 여유 공간

[null|사과|→] ←→ [←|바나나|→] ←→ [←|체리|null]
 prev  data next

LinkedList<String> names = new LinkedList<>();
names.add("Alice");
names.add("Bob");
names.add("Charlie");

// 맨 앞에 추가 — ArrayList보다 빠르다
names.addFirst("Zara");
System.out.println(names); // [Zara, Alice, Bob, Charlie]

Set<String> languages = new HashSet<>();
languages.add("Java");
languages.add("Python");
languages.add("Java");   // 중복 → 무시됨

languages.size();             // 2
languages.contains("Java");   // true — O(1)

1단계: hashCode()로 버킷(저장 위치) 결정
   ↓
2단계: 같은 버킷에 이미 요소가 있으면 equals()로 비교
   ↓
  같으면 → 중복이므로 추가 안 함
  다르면 → 같은 버킷에 추가 (해시 충돌)

class Student {
    String name;
    int id;

    // equals()와 hashCode()를 둘 다 오버라이드해야 한다
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Student s)) return false;
        return id == s.id && Objects.equals(name, s.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, id);
    }
}

Set<Student> students = new HashSet<>();
students.add(new Student("Alice", 1));
students.add(new Student("Alice", 1)); // 중복으로 판단됨
students.size(); // 1

Set<Integer> numbers = new TreeSet<>();
numbers.add(30); numbers.add(10); numbers.add(20);
System.out.println(numbers); // [10, 20, 30] — 자동 정렬!

Set<String> colors = new LinkedHashSet<>();
colors.add("빨강"); colors.add("파랑"); colors.add("초록");
System.out.println(colors); // [빨강, 파랑, 초록] — 넣은 순서 그대로

Map<String, Integer> scores = new HashMap<>();

scores.put("Alice", 95);
scores.put("Bob", 87);
scores.put("Charlie", 92);

scores.get("Alice");                  // 95
scores.get("Dave");                   // null — 없는 키
scores.getOrDefault("Dave", 0);       // 0 — 기본값 지정
scores.containsKey("Bob");            // true
scores.remove("Charlie");             // 삭제

// 전체 순회
for (Map.Entry<String, Integer> entry : scores.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}

put("Alice", 95) 호출 시:

1. "Alice".hashCode() → 해시값 계산
2. 해시값으로 버킷 인덱스 결정 (해시값 % 배열 크기)
3. 해당 버킷이 비어있으면 → 바로 저장
4. 이미 차있으면 → equals()로 키 비교
   - 같은 키 → 값 덮어쓰기
   - 다른 키 → 체이닝(연결 리스트 or 트리)

Map<String, Integer> map = new HashMap<>();

// key에 null 가능 (하나만)
map.put(null, 100);
System.out.println(map.get(null)); // 100

// value에 null 가능 (여러 개)
map.put("A", null);
map.put("B", null);

System.out.println(map); // {null=100, A=null, B=null}

Map<String, Integer> treeMap = new TreeMap<>();
treeMap.put("Charlie", 92); treeMap.put("Alice", 95); treeMap.put("Bob", 87);
System.out.println(treeMap); // {Alice=95, Bob=87, Charlie=92}

Map<String, Integer> linkedMap = new LinkedHashMap<>();
linkedMap.put("세 번째", 3); linkedMap.put("첫 번째", 1); linkedMap.put("두 번째", 2);
System.out.println(linkedMap); // {세 번째=3, 첫 번째=1, 두 번째=2}

List<String> names = List.of("Alice", "Bob", "Charlie");

for (String name : names) {
    System.out.println(name);
}

List<String> names = new ArrayList<>(List.of("Alice", "Bob", "Charlie"));

Iterator<String> it = names.iterator();
while (it.hasNext()) {
    String name = it.next();
    if (name.equals("Bob")) {
        it.remove(); // Iterator의 remove()는 안전
    }
}
System.out.println(names); // [Alice, Charlie]

List<String> names = new ArrayList<>(List.of("Alice", "Bob", "Charlie"));

// 이렇게 하면 안 된다!
for (String name : names) {
    if (name.equals("Bob")) {
        names.remove(name); // ConcurrentModificationException 발생!
    }
}

// removeIf() — 가장 간결하다
names.removeIf(name -> name.equals("Bob"));

List<Integer> numbers = new ArrayList<>(List.of(30, 10, 20, 50, 40));

Collections.sort(numbers);                          // [10, 20, 30, 40, 50]
Collections.sort(numbers, Collections.reverseOrder()); // [50, 40, 30, 20, 10]

List<String> original = new ArrayList<>(List.of("A", "B", "C"));

// 수정 불가 래퍼로 감싸기
List<String> readOnly = Collections.unmodifiableList(original);

// readOnly.add("D"); // UnsupportedOperationException!

// 주의: original을 수정하면 readOnly에도 반영된다
original.add("D");
System.out.println(readOnly); // [A, B, C, D] — 진짜 불변이 아니다!

// List.of — 수정 불가
List<String> fruits = List.of("사과", "바나나", "체리");
// fruits.add("딸기"); // UnsupportedOperationException!

// Set.of — 중복 넣으면 예외
Set<String> colors = Set.of("빨강", "파랑", "초록");
// Set.of("빨강", "빨강"); // IllegalArgumentException!

// Map.of — 10개 이하의 키-값 쌍
Map<String, Integer> scores = Map.of(
    "Alice", 95,
    "Bob", 87,
    "Charlie", 92
);

// Map.ofEntries — 10개 초과 시
Map<String, Integer> moreScores = Map.ofEntries(
    Map.entry("Alice", 95),
    Map.entry("Bob", 87)
);

순서가 필요하다 → 인덱스 접근 多 → ArrayList ✅ / 앞뒤 삽입삭제 多 → LinkedList
중복 제거가 필요하다 → 순서 무관 → HashSet ✅ / 삽입 순서 → LinkedHashSet / 정렬 → TreeSet
키-값 쌍이 필요하다 → 순서 무관 → HashMap ✅ / 삽입 순서 → LinkedHashMap / 키 정렬 → TreeMap