방송대 Java프로그래밍 11강: 컬렉션 선택 기준과 Set·List·Queue·Map

같은 여러 값을 저장하더라도 중복을 막을지, 입력 순서를 유지할지, 먼저 들어온 값을 먼저 꺼낼지, 이름으로 값을 찾을지에 따라 자료구조가 달라진다. 이 글은 요구사항을 Set·List·Queue·Map의 규칙으로 바꾸고, HashSet·ArrayList·LinkedList·HashMap의 실행 결과까지 추적하는 선택 기준을 만든다.

자료의 모양보다 먼저 관리 규칙을 묻는다

수강 신청 코드, 발표 순서, 대기표, 이름별 점수는 모두 여러 원소를 다루지만 같은 컬렉션으로 처리하기에는 규칙이 다르다. 컬렉션(collection)은 여러 원소를 하나의 그룹으로 묶어 관리하는 자료구조이며, JCF(Java Collections Framework)는 컬렉션을 표현하고 다루는 인터페이스와 클래스의 집합이다.

직접 구성한 네 상황을 요구사항으로 번역하면 선택의 출발점이 보인다.

상황	가장 중요한 규칙	우선 검토할 인터페이스	이유
한 번만 등록할 쿠폰 코드	중복 불허, 순서 불필요	`Set`	같은 원소를 다시 넣지 않는 규칙이 핵심
발표자의 등장 순서	순서 유지, 중복 가능	`List`	위치와 입력 순서로 원소를 다룸
접수 순서대로 처리할 대기표	먼저 입력된 원소를 먼저 제거	`Queue`	FIFO 삽입·삭제 규칙이 핵심
학번으로 학생 정보를 조회	고유한 키와 값의 대응	`Map`	위치 대신 키로 연결된 값을 찾음

판단 핵심: 원소의 자료형이 문자열이라는 사실만으로 컬렉션을 고를 수 없다. 중복, 순서, 제거 정책, 검색 기준을 먼저 결정해야 한다.

JCF의 계층은 공통 기능과 고유 규칙을 나눈다

Set, List, Queue는 Collection 계열에서 원소 추가·삭제·탐색 같은 공통 기능을 공유한다. Collection은 다시 원소를 차례로 방문할 수 있는 Iterable과 연결된다. 반면 Map은 하나의 원소가 키와 값의 쌍이므로 Collection과 별도의 계층을 이룬다.

Set: 원소 순서의 의미가 없고 중복을 허용하지 않는다. 정렬 규칙이 필요하면 SortedSet 계열을 생각한다.
List: 입력된 순서를 유지하고 중복을 허용하며 인덱스로 특정 위치를 참조한다.
Queue: 원소를 넣고 꺼내는 정책을 표현하며 기본적인 대기열은 FIFO로 처리한다. 양 끝을 다루는 확장 규칙에는 Deque가 있다.
Map: 키와 값의 쌍을 저장한다. 키는 중복되지 않고 한 키에는 하나의 값이 대응한다.

구현·확장 관점	Set 계열	List·Queue 계열	Map 계열
해시테이블	`HashSet`	-	`HashMap`
크기 조절 배열	-	`ArrayList`, `Vector`, `Stack`	-
연결 리스트	-	`LinkedList`	-
해시와 연결	`LinkedHashSet`	-	`LinkedHashMap`
정렬 규약	`SortedSet`	-	`SortedMap`
트리 구현	`TreeSet`	-	`TreeMap`

인터페이스는 “어떤 규칙으로 다룰 것인가”를 표현하고, 구현 클래스는 “그 규칙을 어떤 구조로 실현할 것인가”를 결정한다. 예를 들어 HashSet은 Set을, ArrayList와 LinkedList는 List를, HashMap은 Map을 구현한다. LinkedList는 Queue로도 사용할 수 있다.

구조를 잘못 읽는 경우: Map을 Collection의 한 종류라고 외우면 add()와 put()을 혼동한다. 원소 하나를 넣는 Collection 계열과 키-값 매핑을 넣는 Map 계열은 출발 규약부터 다르다.

제네릭과 인터페이스형 변수는 저장 규칙을 코드에 드러낸다

JCF의 인터페이스와 클래스는 java.util 패키지에 포함되며 제네릭 타입으로 다루는 원소의 유형을 지정한다. 변수는 가능한 한 필요한 규칙을 나타내는 인터페이스형으로 선언하고, 오른쪽에서 구현 객체를 선택하면 코드의 의도가 선명해진다.

Set<Integer> uniqueNumbers = new HashSet<>();
List<Integer> orderedNumbers = new ArrayList<>();
List<Integer> linkedNumbers = new LinkedList<>();
Queue<Integer> waitingNumbers = new LinkedList<>();
Map<String, Integer> scores = new HashMap<>();

Set<Integer>는 정수 원소의 중복을 허용하지 않는다는 규칙을, Map<String, Integer>는 문자열 키가 정수 값과 대응한다는 규칙을 표현한다. 구현을 바꾸더라도 변수에 약속된 인터페이스 기능을 중심으로 코드를 작성할 수 있다.

선언 순서: 먼저 필요한 인터페이스를 정하고, 그다음 구현 클래스를 고르며, 마지막으로 제네릭 인수에 원소 또는 키·값의 자료형을 적는다.

Collection 메서드는 결과의 뜻까지 읽어야 한다

Collection<E>는 Set·List·Queue가 공통으로 지원해야 하는 삽입, 삭제, 탐색 기능을 정의한다. 같은 메서드라도 컬렉션 규칙에 따라 결과가 달라질 수 있으므로 반환형을 함께 읽어야 한다.

질문	대표 메서드	결과 해석
원소를 추가·합치고 싶은가?	`add(E)`, `addAll(Collection)`	성공적인 변화 여부를 불리언으로 확인
일부·전체를 제거할 것인가?	`remove(Object)`, `removeAll(Collection)`, `clear()`	대상 제거 또는 전체 비우기를 수행
공통 원소만 남길 것인가?	`retainAll(Collection)`	현재 컬렉션과 주어진 컬렉션의 공통 부분만 유지
포함 여부를 확인할 것인가?	`contains(Object)`, `containsAll(Collection)`	한 원소 또는 모든 원소의 포함 여부 반환
크기·비어 있음이 필요한가?	`size()`, `isEmpty()`	원소 수 또는 빈 상태를 반환
순회·배열 변환이 필요한가?	`iterator()`, `toArray()`	반복자 또는 객체 배열을 얻음

예를 들어 이미 들어 있는 값을 HashSet에 다시 add()하면 컬렉션은 변하지 않고 false가 반환된다. 반면 같은 값을 허용하는 ArrayList에서는 새 원소가 뒤에 추가된다. “add는 항상 true”가 아니라 그 컬렉션의 규칙에 따라 실제 변화가 있었는가를 본다.

HashSet은 중복 삽입을 상태 변화 없이 거부한다

다음은 강의 예제를 학습용 값으로 바꾼 실험이다. 저장 순서가 아니라 중복 여부와 메서드 반환값에 초점을 둔다.

Set<String> codes = new HashSet<>();

System.out.println(codes.add("A17"));
System.out.println(codes.add("B04"));
System.out.println(codes.add(new String("A17")));
System.out.println(codes.size());
System.out.println(codes.contains(new String("B04")));
codes.remove("A17");
System.out.println(codes.size());

첫 "A17"은 새 원소이므로 추가되고 true가 나온다.
"B04"도 새 원소이므로 추가되어 크기는 2가 된다.
새 String 객체로 만든 "A17"은 내용상 같은 원소로 판정되어 추가되지 않고 false가 나온다.
contains()도 같은 기준으로 "B04"를 찾아 true를 반환한다.
"A17"을 제거한 뒤 크기는 1이 된다.

오개념 교정: HashSet은 “같은 참조만 중복”으로 보는 저장소가 아니다. 강의의 문자열 예처럼 내용이 같은 새 문자열도 같은 원소로 판정될 수 있다. 따라서 중복 판단과 변수의 참조 동일성을 같은 문제로 보지 않는다.

ArrayList는 위치 변화까지 추적해야 결과를 예측할 수 있다

ArrayList는 크기를 조절할 수 있는 배열로 List를 구현한다. 중복 원소를 허용하고 입력 순서를 유지하며, 인덱스로 특정 원소를 읽거나 삽입·교체·삭제할 수 있다. 중간 위치에서 원소가 바뀌면 뒤 원소의 인덱스도 달라지므로 상태표가 유용하다.

List<String> list = new ArrayList<>();
list.add("red");
list.add("blue");
list.add("green");
list.add(1, "red");
String old = list.set(2, "black");
String removed = list.remove(3);

실행 직후	리스트 상태	반환값·변화
세 번의 `add(E)`	[red, blue, green]	뒤에 차례로 추가
`add(1, "red")`	[red, red, blue, green]	기존 인덱스 1 이후 원소가 뒤로 이동
`set(2, "black")`	[red, red, black, green]	교체된 기존 값 `"blue"` 반환
`remove(3)`	[red, red, black]	삭제된 값 `"green"` 반환

indexOf("red")는 첫 위치 0을, lastIndexOf("red")는 마지막 위치 1을 반환한다. get(2)는 현재 인덱스 2의 "black"을 읽는다. subList(from, to)는 시작 인덱스는 포함하고 끝 인덱스 전까지의 구간을 다루는 메서드다.

추적 핵심: add(index, value)는 삽입, set(index, value)는 교체다. 삽입은 크기와 뒤 인덱스를 바꾸지만 교체는 크기를 유지한다.

같은 List도 탐색 목적에 따라 순회 표현이 달라진다

ArrayList의 원소를 차례로 다루는 방법에는 인덱스 반복, 향상된 for문, Iterator, forEach()가 있다. 모두 순회할 수 있지만 필요한 정보와 표현 방식이 다르다.

방법	중심 질문	적합한 경우
인덱스 for문	현재 위치가 필요한가?	`get(i)`와 위치를 함께 사용할 때
향상된 for문	원소만 차례로 읽으면 되는가?	간결하게 모든 원소를 방문할 때
`Iterator`	컬렉션 종류와 무관한 반복 규약이 필요한가?	`hasNext()`로 확인하고 `next()`로 이동할 때
`forEach()`	각 원소에 같은 동작을 전달할 것인가?	`Consumer`나 람다식으로 처리 동작을 표현할 때

Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    String color = iterator.next();
    System.out.println(color);
}

list.forEach(color -> System.out.println(color));

Iterator는 hasNext(), next(), remove()를 제공한다. 기본 순서는 “다음 원소가 있는지 묻기 → 다음 원소를 받기 → 처리하기”다. next()만 반복하거나, 한 번 받은 원소를 처리하지 않고 다시 next()를 호출하면 의도한 원소를 건너뛸 수 있다. Iterator는 HashSet, ArrayList, LinkedList 등에서 iterator()로 얻을 수 있다.

LinkedList는 같은 객체를 List·스택·Queue 규칙으로 볼 수 있다

LinkedList는 연결 리스트로 List를 구현하므로 ArrayList 예제의 인터페이스 중심 코드는 구현 객체만 바꾸어 사용할 수 있다. 동시에 앞쪽 삽입·삭제를 이용한 push()·pop()과 Queue의 offer()·poll()·peek()도 제공한다.

Queue<String> tickets = new LinkedList<>();
tickets.offer("Q31");
tickets.offer("Q32");
tickets.offer("Q33");

System.out.println(tickets.poll());
System.out.println(tickets.peek());
System.out.println(tickets.poll());
System.out.println(tickets.poll());
System.out.println(tickets.poll());

상태는 [Q31, Q32, Q33]에서 시작한다. 첫 poll()은 앞의 Q31을 제거하고 반환한다. 이어지는 peek()는 Q32를 읽지만 제거하지 않는다. 다음 두 poll()이 Q32와 Q33을 차례로 제거하고, 빈 큐에서 마지막 poll()은 null을 반환한다.

offer()와 add()는 뒤에 원소를 추가하며, poll()과 remove()는 앞의 원소를 삭제하고 반환한다. peek()와 element()는 앞의 원소를 읽는다. 이름이 비슷해도 읽기만 하는가, 제거까지 하는가를 구분해야 한다.

Map은 위치 대신 고유한 키로 값을 찾는다

Map<K, V>는 키와 값으로 이루어진 매핑을 관리하며 원소의 순서는 중요하지 않다. 하나의 키에는 하나의 값이 대응하므로 같은 키로 put()하면 새 항목이 하나 더 생기는 것이 아니라 기존 값이 바뀐다. 강의 범위의 HashMap은 해싱을 이용해 Map을 구현하며, List와는 탐색 기준이 다르다.

Map<String, Integer> stock = new HashMap<>();
stock.put("pen", 12);
stock.put("notebook", 7);
stock.put("pen", 15);

System.out.println(stock.size());
System.out.println(stock.get("pen"));
System.out.println(stock.containsKey("eraser"));

첫 두 put() 뒤에는 키가 두 개다. 세 번째 put("pen", 15)는 "pen" 키의 값을 12에서 15로 교체하므로 크기는 여전히 2다. get("pen")은 15, 존재하지 않는 "eraser"에 대한 containsKey()는 false를 반환한다.

get(key)는 키에 대응하는 값을, 없으면 null을 반환한다.
remove(key)는 매핑을 제거하고 기존 값을, 없으면 null을 반환한다.
keySet()은 키들로 구성된 Set을, values()는 값들로 구성된 Collection을 반환한다.

오개념 교정: Map의 키는 중복되지 않지만 값까지 고유해야 하는 것은 아니다. 서로 다른 상품 키가 같은 재고 수량을 가질 수 있다.

중첩 Map은 큰 키에서 작은 키로 두 번 조회한다

강의의 성적부 구조는 Map의 값으로 또 다른 Map을 저장해 복합 자료를 표현한다. 바깥 Map은 이름을 개별 성적표에 연결하고, 안쪽 Map은 과목명을 점수에 연결한다. 자료형을 구체적으로 적으면 두 단계의 키와 값 관계가 코드에 그대로 드러난다.

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

Map<String, Integer> mina = new HashMap<>();
mina.put("국어", 88);
mina.put("영어", 92);
scores.put("민아", mina);

int english = scores.get("민아").get("영어");
System.out.println(english);

scores.get("민아")는 이름 키로 안쪽 성적 Map을 얻는다.
그 결과에 get("영어")를 호출해 과목 키에 대응하는 정수 92를 얻는다.
따라서 출력값은 92다. 한 번에 값을 찾는 것처럼 보여도 실제 판단은 바깥 키와 안쪽 키의 두 단계다.

여러 학생을 입력 순서대로 출력해야 한다면 이름 목록을 ArrayList에 두고 Iterator로 순회하면서 각 이름을 바깥 Map의 키로 사용할 수 있다. 이렇게 List의 순서 관리와 Map의 키 검색을 역할별로 결합한다.

컬렉션 선택은 네 질문과 두 확인으로 끝낸다

새로운 자료 관리 문제에서는 다음 판정 순서를 사용한다.

중복을 허용하는가? 허용하지 않으면 Set을 먼저 검토한다.
위치와 입력 순서가 중요한가? 중요하고 중복도 가능하면 List가 맞다.
삽입·삭제 정책이 핵심인가? 먼저 들어온 원소를 먼저 처리하면 Queue를 검토한다.
고유한 이름으로 값을 찾아야 하는가? 키-값 대응이면 Map을 고른다.
어떤 구현이 필요한가? 강의 범위에서는 HashSet, ArrayList, LinkedList, HashMap 중 인터페이스 규칙을 구현하는 클래스를 선택한다.
메서드가 상태와 무엇을 반환하는가? 중복 add의 false, set의 기존 값, poll의 제거된 값, put의 키 교체처럼 상태와 반환값을 함께 추적한다.

마지막 점검으로 “이 코드는 원소 위치로 찾는가, 키로 찾는가?”와 “읽기만 하는가, 제거까지 하는가?”를 묻는다. 이 두 질문은 List와 Map, peek()와 poll()처럼 시험에서 자주 섞이는 동작을 분리해 준다.

핵심 개념 정리

Set은 중복 불허, List는 순서·중복·인덱스, Queue는 처리 순서, Map은 고유 키와 값의 대응을 중심 규칙으로 삼는다.
Set·List·Queue는 Collection의 공통 메서드를 공유하지만 Map은 키-값 구조의 별도 계층이다.
인터페이스형 변수는 필요한 규칙을, HashSet·ArrayList·LinkedList·HashMap 같은 구현 클래스는 실제 저장 방식을 나타낸다.
HashSet의 중복 add, ArrayList의 삽입·교체, Queue의 조회·제거, Map의 같은 키 put은 반환값과 상태 변화를 함께 읽는다.
Iterator는 hasNext()로 확인한 뒤 next()로 원소를 받는 공통 순회 규약이다.
중첩 Map은 바깥 키로 내부 Map을 얻고 다시 안쪽 키로 값을 찾는다.

컬렉션 문제의 풀이 순서는 중복 → 순서·위치 → 삽입·삭제 정책 → 키 검색 → 구현 클래스 → 메서드의 상태 변화와 반환값이다. 클래스 이름을 먼저 외우지 말고 자료 관리 규칙을 인터페이스로 번역하면, 구현을 바꾸거나 여러 컬렉션을 결합하는 문제에서도 선택 근거를 설명할 수 있다.

예상문제 10선

1. 같은 쿠폰 코드를 한 번만 등록하고 입력 순서는 고려하지 않는 기능에 가장 알맞은 인터페이스는?

① List ② Set ③ Queue ④ Map

정답입니다.

오답입니다. 답안을 다시 선택해 보세요.

정답 및 해설 보기

정답: ②

① 오답: List는 순서와 위치를 유지하지만 같은 코드를 중복 저장할 수 있어 핵심 규칙과 다르다.
② 정답: Set은 원소 중복을 허용하지 않으므로 한 번만 등록한다는 조건을 직접 표현한다.
③ 오답: Queue는 삽입과 삭제의 처리 순서가 중심이며 중복 방지가 주된 규칙은 아니다.
④ 오답: Map은 별도의 값과 연결할 고유 키가 필요할 때 적합하지만 현재 조건은 코드 원소 자체의 중복 제거다.

2. JCF 계층에 관한 설명으로 옳은 것은?

① Map은 List의 하위 인터페이스다 ② Queue는 Map의 키 집합을 뜻한다 ③ Collection은 Map의 하위 인터페이스다 ④ Set·List·Queue는 Collection 계열이고 Map은 별도 계열이다

정답입니다.

오답입니다. 답안을 다시 선택해 보세요.

정답 및 해설 보기

정답: ④

① 오답: Map은 키-값 매핑을 다루는 별도 계층이며 순서 있는 List의 하위가 아니다.
② 오답: Queue는 FIFO 같은 처리 순서를 표현하고 Map의 키 집합은 keySet()으로 얻는다.
③ 오답: Collection과 Map의 상하 관계를 거꾸로 연결한 설명이다.
④ 정답: 세 인터페이스는 공통 Collection 규약을 공유하고 Map은 키-값 구조 때문에 분리된다.

3. Map<String, Integer> 선언이 표현하는 것으로 가장 정확한 것은?

① 문자열 키와 정수 값의 대응 ② 정수 인덱스와 문자열 원소의 순서 ③ 문자열이 중복되지 않는 Set ④ 정수가 먼저 제거되는 Queue

정답입니다.

오답입니다. 답안을 다시 선택해 보세요.

정답 및 해설 보기

정답: ①

① 정답: 첫 제네릭 인수는 키, 둘째 인수는 값의 자료형이므로 문자열을 정수에 연결한다.
② 오답: 인덱스 기반 순서는 List의 규칙이며 Map의 첫 자료형은 인덱스가 아니라 키다.
③ 오답: 키의 중복 불허 특성만 떼어 Set으로 바꾸면 정수 값과의 대응이 사라진다.
④ 오답: Queue의 제거 순서는 제네릭 인수 두 개로 키와 값을 나타내는 Map 선언과 관계없다.

4. 빈 HashSet에 "one", "two", 새 문자열 객체 "one"을 차례로 add한 뒤 크기는?

① 0 ② 1 ③ 2 ④ 3

정답입니다.

오답입니다. 답안을 다시 선택해 보세요.

정답 및 해설 보기

정답: ③

① 오답: 첫 두 add는 서로 다른 원소를 정상적으로 추가하므로 빈 상태가 아니다.
② 오답: "one"과 "two"는 다른 원소이므로 둘 다 저장된다.
③ 정답: 내용이 같은 두 번째 "one"은 중복으로 추가되지 않아 원소는 두 개다.
④ 오답: 새 객체라는 이유만으로 같은 내용의 문자열을 별도 원소로 세는 오류다.

5. 리스트 [A, B, C]에 add(1, "X")를 실행한 결과는?

① [X, A, B, C] ② [A, X, C] ③ [A, X, B, C] ④ [A, B, X, C]

정답입니다.

오답입니다. 답안을 다시 선택해 보세요.

정답 및 해설 보기

정답: ③

① 오답: 맨 앞은 인덱스 0이며 지정한 인덱스 1과 다르다.
② 오답: add(index, value)를 set()처럼 교체로 해석해 기존 B를 잃은 결과다.
③ 정답: 인덱스 1에 X를 삽입하고 기존 B와 C를 한 칸씩 뒤로 이동한다.
④ 오답: X를 인덱스 2에 넣은 상태이며 0부터 세는 위치를 한 칸 크게 계산했다.

6. ArrayList의 set(2, "new")를 “인덱스 2에 새 원소를 삽입한다”라고 설명한 오류를 바로잡은 것은?

① 기존 인덱스 2의 원소를 교체하고 그 기존 값을 반환한다 ② 맨 앞 원소를 제거하고 그 값을 반환한다 ③ 같은 값이 있으면 추가를 거부하고 false를 반환한다 ④ 키 2와 문자열 new를 Map에 저장한다

정답입니다.

오답입니다. 답안을 다시 선택해 보세요.

정답 및 해설 보기

정답: ①

① 정답: set()은 지정 위치의 원소를 바꾸며 리스트 크기는 유지된다.
② 오답: 앞 원소 제거는 Queue의 poll()이나 LinkedList의 관련 삭제 동작에 가깝다.
③ 오답: 이는 중복 원소를 받지 않는 Set의 add() 결과를 잘못 적용한 것이다.
④ 오답: List의 정수 인수는 키가 아니라 위치이며 set()은 Map의 put()이 아니다.

7. Iterator로 컬렉션을 안전하게 차례로 읽는 기본 순서는?

① next() 호출 → iterator() 생성 → hasNext() 확인 ② remove() 호출 → next() 호출 → size() 확인 ③ get(0) 호출 → hasNext() 확인 → next() 호출 ④ iterator() 생성 → hasNext() 확인 → next()로 원소 받기

정답입니다.

오답입니다. 답안을 다시 선택해 보세요.

정답 및 해설 보기

정답: ④

① 오답: 반복자를 만들기도 전에 next()를 호출할 수 없고 다음 원소 존재 여부 확인도 늦다.
② 오답: 읽기 순회에 제거를 먼저 실행할 이유가 없으며 다음 원소 확인 절차도 빠졌다.
③ 오답: get(0)은 List의 인덱스 접근으로 Iterator의 공통 순회 시작 단계가 아니다.
④ 정답: 컬렉션에서 반복자를 얻고 다음 원소 존재를 확인한 뒤 원소를 받는 순서다.

8. Queue [Q1, Q2, Q3]에 poll(), peek(), poll()을 차례로 실행할 때 반환값은?

① Q1, Q1, Q2 ② Q1, Q2, Q2 ③ Q3, Q2, Q1 ④ Q1, Q2, Q3

정답입니다.

오답입니다. 답안을 다시 선택해 보세요.

정답 및 해설 보기

정답: ②

① 오답: 첫 poll이 Q1을 제거하므로 이어지는 peek가 Q1을 다시 읽을 수 없다.
② 정답: 첫 poll은 Q1을 제거하고, peek는 Q2를 남긴 채 읽으며, 다음 poll이 같은 Q2를 제거한다.
③ 오답: 뒤에서부터 꺼내는 스택식 해석이며 FIFO Queue의 앞쪽 처리와 반대다.
④ 오답: peek가 Q2를 제거한다고 잘못 생각해 마지막 poll이 Q3으로 넘어간 결과다.

9. Map의 keySet()과 values()의 반환 결과를 바르게 연결한 것은?

① 둘 다 키-값 쌍 하나를 반환한다 ② keySet은 값의 List, values는 키의 Queue를 반환한다 ③ keySet은 값의 Set, values는 키의 Collection을 반환한다 ④ keySet은 키의 Set, values는 값의 Collection을 반환한다

정답입니다.

오답입니다. 답안을 다시 선택해 보세요.

정답 및 해설 보기

정답: ④

① 오답: 두 메서드는 단일 매핑이 아니라 각각 키 전체와 값 전체를 볼 수 있는 컬렉션 형태를 반환한다.
② 오답: 키와 값을 서로 뒤집었고 반환 인터페이스도 List·Queue로 잘못 지정했다.
③ 오답: 반환 인터페이스의 종류는 비슷하지만 키와 값의 역할을 서로 바꿨다.
④ 정답: 고유한 키들은 Set으로, 값들은 Collection으로 제공된다.

10. 학생별로 과목 점수를 저장하고 이름으로 특정 학생의 영어 점수를 찾는 구조로 가장 알맞은 것은?

① Set<Integer> 하나에 모든 점수만 저장한다 ② Map<String, Map<String, Integer>>로 이름과 과목 키를 두 단계 사용한다 ③ Queue<String>에 이름과 점수를 입력 순서대로 번갈아 넣는다 ④ List<Integer>에서 학생 이름을 인덱스로 사용한다

정답입니다.

오답입니다. 답안을 다시 선택해 보세요.

정답 및 해설 보기

정답: ②

① 오답: 점수만 저장하면 학생과 과목의 대응 관계가 사라지고 중복 점수도 보존되지 않는다.
② 정답: 바깥 문자열 키로 학생의 성적 Map을 찾고 안쪽 문자열 키로 과목의 정수 점수를 찾는다.
③ 오답: Queue는 처리 순서를 위한 구조여서 이름과 과목을 키로 직접 검색하기 어렵다.
④ 오답: List의 인덱스는 정수 위치이며 문자열 이름을 검색 키로 표현하지 못한다.

참고 자료와 작성 기준

이 글은 해당 차시 강의자료를 바탕으로 학습 목적에 맞게 재구성한 비공식 학습자료입니다. 컬렉션 선택 기준, 상태 추적 예제와 문제 해설은 학습자의 이해를 돕도록 구성하고 검토했습니다.

작성·편집: 올에이클래스 학습연구팀
주요 근거: 한국방송통신대학교 Java프로그래밍 11강 「컬렉션」 강의록 :codex-file-citation{path="K1. 컴퓨터과학과/1. 재검토필요/2-1 Java프로그래밍/1. 강의록/java프로그래밍 강의록 11강.pdf" purpose="source"}
편집 원칙: 올에이클래스 편집 정책
최종 내용 검토: 2026-09-02

방송대 Java프로그래밍 11강: 컬렉션 선택 기준과 Set·List·Queue·Map