List, Set, Map

여러 값을 다룰 때는 값 사이의 관계에 맞는 컬렉션을 고릅니다. 순서와 위치가 중요하면 List, 같은 값을 한 번만 보관하면 Set, 이름으로 값을 찾으면 Map을 사용합니다.

타입	값을 찾는 기준	이 장에서 다루는 동작
`List<T>`	0부터 시작하는 인덱스	추가·변경·삭제·순회·합계
`Set<T>`	값의 포함 여부	중복 제거·합집합·교집합·차집합
`Map<K, V>`	키	값 갱신·기본값 조회·빈도 집계·키와 값 조회

T, K, V에는 보관할 타입을 지정합니다. List<int>는 정수 목록, Map<string, int>는 문자열 키에 정수를 연결하는 맵입니다. 각 소스의 빌드·실행 버튼에서 현재 서버의 결과를 확인할 수 있습니다. API 선언과 현재 실행 지원은 구분하며, 소스 아래에 실제 검증 상태를 표시합니다.

List: 순서와 위치

대괄호 [...]로 목록을 초기화합니다. add()는 항목을 추가하고 get(index)는 그 위치의 값을 읽습니다. 인덱스는 0부터 시작합니다.

import unibase.collections.List;

class ListItems {
    static void main() {
        List<string> colors = ["red", "green"];
        colors.add("blue");
        colors.set(1, "yellow");
        colors.removeAt(2);
        print(colors.get(0));
        print(colors.get(1));
        print(colors.size());
    }
}

import java.util.*;

public class ListItems {
    public static void main(String[] args) throws Exception {
        List<String> colors = new ArrayList<>(List.of("red", "green"));
        colors.add("blue");
        colors.set(1, "yellow");
        colors.remove(2);
        System.out.println(colors.get(0));
        System.out.println(colors.get(1));
        System.out.println(colors.size());
    }
}

colors = ["red", "green"]
colors.append("blue")
colors[1] = "yellow"
colors.pop(2)
print(colors[0])
print(colors[1])
print(len(colors))

using System;
using System.Collections.Generic;

class ListItems {
    static void Main() {
        var colors = new List<string> { "red", "green" };
        colors.Add("blue");
        colors[1] = "yellow";
        colors.RemoveAt(2);
        Console.WriteLine(colors[0]);
        Console.WriteLine(colors[1]);
        Console.WriteLine(colors.Count);
    }
}

const colors = ["red", "green"];
colors.push("blue");
colors[1] = "yellow";
colors.splice(2, 1);
console.log(colors[0]);
console.log(colors[1]);
console.log(colors.length);

package main

import (
	"fmt"
)

func main() {
	colors := []string{"red", "green"}
	colors = append(colors, "blue")
	colors[1] = "yellow"
	colors = append(colors[:2], colors[3:]...)
	fmt.Println(colors[0])
	fmt.Println(colors[1])
	fmt.Println(len(colors))
}

다른 언어의 탭은 직접 작성한 대응 코드이며 컴파일러의 자동 생성 결과가 아닙니다. 언어마다 API와 실행 환경이 다릅니다. 이 페이지의 빌드·실행은 Unibase 탭에서 사용할 수 있습니다.

서버 실행을 준비 중입니다.

Unibase 실행 결과

빌드·실행 메시지

출력 비교 기준

red
yellow
2

Unibase 소스 내려받기

검증 상태: 문법 검사 통과 · 실행 출력 일치 (2026-10-06)

읽기 기준 결과와 실제 실행 출력 비교

코드를 읽어 정한 비교 기준입니다. 실행 성공 결과로 대신 표시하지 않습니다.

red
yellow
2

실제 네이티브 실행: 빌드 passed, 실행 passed, 종료 코드 0

red
yellow
2

현재 실행 확인 범위

소스를 순서대로 읽으면 목록은 [red, green] → [red, green, blue] → [red, yellow, blue] → [red, yellow]로 바뀝니다. set(1, ...)은 두 번째 항목을 바꾸고 removeAt(2)는 세 번째 항목을 제거합니다. 제거 뒤에는 크기와 인덱스 범위도 달라집니다. get() 전에 인덱스가 0 <= index < size() 범위인지 고려하세요.

List 순회와 합계

값을 하나씩 읽어 계산하려면 size()를 반복 조건으로, get(i)를 현재 값으로 사용합니다.

import unibase.collections.List;

class ListSum {
    static void main() {
        List<int> numbers = [2, 4, 6, 8];
        int total = 0;
        for (int i = 0; i < numbers.size(); i = i + 1) {
            total = total + numbers.get(i);
        }
        print(total);
    }
}

import java.util.List;

public class ListSum {
    public static void main(String[] args) throws Exception {
        List<Integer> numbers = List.of(2, 4, 6, 8);
        int total = 0;
        for (int i = 0; i < numbers.size(); i++) { total += numbers.get(i); }
        System.out.println(total);
    }
}

numbers = [2, 4, 6, 8]
total = 0
for i in range(len(numbers)):
    total += numbers[i]
print(total)

using System;
using System.Collections.Generic;

class ListSum {
    static void Main() {
        var numbers = new List<int> { 2, 4, 6, 8 };
        int total = 0;
        for (int i = 0; i < numbers.Count; i++) { total += numbers[i]; }
        Console.WriteLine(total);
    }
}

const numbers = [2, 4, 6, 8];
let total = 0;
for (let i = 0; i < numbers.length; i++) { total += numbers[i]; }
console.log(total);

package main

import (
	"fmt"
)

func main() {
	numbers := []int{2, 4, 6, 8}
	total := 0
	for i := 0; i < len(numbers); i++ {
		total += numbers[i]
	}
	fmt.Println(total)
}

서버 실행을 준비 중입니다.

Unibase 실행 결과

빌드·실행 메시지

출력 비교 기준

Unibase 소스 내려받기

검증 상태: 문법 검사 통과 · 실행 출력 일치 (2026-10-06)

읽기 기준 결과와 실제 실행 출력 비교

코드를 읽어 정한 비교 기준입니다. 실행 성공 결과로 대신 표시하지 않습니다.

실제 네이티브 실행: 빌드 passed, 실행 passed, 종료 코드 0

현재 실행 확인 범위

합계는 2 → 6 → 12 → 20으로 누적됩니다. List<int>에 다른 숫자를 넣어도 같은 반복문 구조를 사용할 수 있습니다. 반복 중 목록을 추가·삭제하는 경우 인덱스가 바뀌므로 이 코드에서는 크기를 변경하지 않습니다.

Set: 중복 없는 값

Set<string>()은 빈 집합을 생성하는 형태입니다. 같은 값을 여러 번 add()해도 별도의 새 항목으로 늘어나지 않는다는 것이 집합의 핵심입니다.

import unibase.collections.List;
import unibase.collections.Set;

class SetUnique {
    static void main() {
        List<string> values = ["red", "blue", "red"];
        Set<string> unique = Set<string>();
        for (int i = 0; i < values.size(); i = i + 1) {
            unique.add(values.get(i));
        }
        print(unique.size());
    }
}

import java.util.*;

public class SetUnique {
    public static void main(String[] args) throws Exception {
        List<String> values = List.of("red", "blue", "red");
        Set<String> unique = new HashSet<>();
        for (String value : values) { unique.add(value); }
        System.out.println(unique.size());
    }
}

values = ["red", "blue", "red"]
unique = set()
for value in values:
    unique.add(value)
print(len(unique))

using System;
using System.Collections.Generic;

class SetUnique {
    static void Main() {
        var values = new List<string> { "red", "blue", "red" };
        var unique = new HashSet<string>();
        foreach (string value in values) { unique.Add(value); }
        Console.WriteLine(unique.Count);
    }
}

const values = ["red", "blue", "red"];
const unique = new Set<string>();
for (const value of values) { unique.add(value); }
console.log(unique.size);

package main

import (
	"fmt"
)

func main() {
	values := []string{"red", "blue", "red"}
	unique := make(map[string]struct{})
	for _, value := range values {
		unique[value] = struct{}{}
	}
	fmt.Println(len(unique))
}

서버 실행을 준비 중입니다.

Unibase 실행 결과

빌드·실행 메시지

출력 비교 기준

Unibase 소스 내려받기

검증 상태: 문법 검사 통과 · 실행 출력 일치 (2026-10-06)

읽기 기준 결과와 실제 실행 출력 비교

코드를 읽어 정한 비교 기준입니다. 실행 성공 결과로 대신 표시하지 않습니다.

실제 네이티브 실행: 빌드 passed, 실행 passed, 종료 코드 0

현재 실행 확인 범위

세 입력 red, blue, red에서 서로 다른 값은 두 개입니다. contains(value)로 포함 여부를 조회할 수도 있습니다. 집합의 순회 순서는 이 문서에서 보장하지 않으므로 출력 순서에 의존하는 코드를 만들지 않습니다.

합집합, 교집합, 차집합

중괄호에 값을 적어 집합을 초기화합니다. 두 집합을 비교하는 API에는 union(), intersection(), difference()가 있습니다.

import unibase.collections.Set;

class SetOperations {
    static void main() {
        Set<int> left = {1, 2, 3};
        Set<int> right = {2, 3, 4};
        Set<int> both = left.union(right);
        Set<int> common = left.intersection(right);
        Set<int> onlyLeft = left.difference(right);
        print(both.size());
        print(common.size());
        print(onlyLeft.size());
    }
}

import java.util.*;

public class SetOperations {
    public static void main(String[] args) throws Exception {
        Set<Integer> left = new HashSet<>(Set.of(1, 2, 3));
        Set<Integer> right = new HashSet<>(Set.of(2, 3, 4));
        Set<Integer> union = new HashSet<>(left);
        union.addAll(right);
        Set<Integer> intersection = new HashSet<>(left);
        intersection.retainAll(right);
        Set<Integer> difference = new HashSet<>(left);
        difference.removeAll(right);
        System.out.println(union.size());
        System.out.println(intersection.size());
        System.out.println(difference.size());
    }
}

left = {1, 2, 3}
right = {2, 3, 4}
union = left | right
intersection = left & right
difference = left - right
print(len(union))
print(len(intersection))
print(len(difference))

using System;
using System.Collections.Generic;

class SetOperations {
    static void Main() {
        var left = new HashSet<int> { 1, 2, 3 };
        var right = new HashSet<int> { 2, 3, 4 };
        var union = new HashSet<int>(left);
        union.UnionWith(right);
        var intersection = new HashSet<int>(left);
        intersection.IntersectWith(right);
        var difference = new HashSet<int>(left);
        difference.ExceptWith(right);
        Console.WriteLine(union.Count);
        Console.WriteLine(intersection.Count);
        Console.WriteLine(difference.Count);
    }
}

const left = new Set([1, 2, 3]);
const right = new Set([2, 3, 4]);
const union = new Set([...left, ...right]);
const intersection = new Set([...left].filter(value => right.has(value)));
const difference = new Set([...left].filter(value => !right.has(value)));
console.log(union.size);
console.log(intersection.size);
console.log(difference.size);

package main

import (
	"fmt"
)

func main() {
	left := map[int]struct{}{1: {}, 2: {}, 3: {}}
	right := map[int]struct{}{2: {}, 3: {}, 4: {}}
	union := make(map[int]struct{})
	intersection := make(map[int]struct{})
	difference := make(map[int]struct{})
	for value := range left {
		union[value] = struct{}{}
		if _, exists := right[value]; exists {
			intersection[value] = struct{}{}
		} else {
			difference[value] = struct{}{}
		}
	}
	for value := range right {
		union[value] = struct{}{}
	}
	fmt.Println(len(union))
	fmt.Println(len(intersection))
	fmt.Println(len(difference))
}

서버 실행을 준비 중입니다.

Unibase 실행 결과

빌드·실행 메시지

출력 비교 기준

4
2
1

Unibase 소스 내려받기

검증 상태: 문법 검사 통과 · 실행 출력 일치 (2026-10-06)

읽기 기준 결과와 실제 실행 출력 비교

코드를 읽어 정한 비교 기준입니다. 실행 성공 결과로 대신 표시하지 않습니다.

4
2
1

실제 네이티브 실행: 빌드 passed, 실행 passed, 종료 코드 0

4
2
1

현재 실행 확인 범위

읽기 기준으로 합집합은 {1, 2, 3, 4}, 교집합은 {2, 3}, 왼쪽 기준 차집합은 {1}입니다. 각 결과의 크기 4·2·1을 비교하면 순회 순서에 의존하지 않고 세 연산을 구분할 수 있습니다.

Map: 키로 값 찾기

Map<string, int>는 문자열을 키로, 정수를 값으로 사용합니다. put(key, value)는 해당 키의 값을 저장하고 getOrDefault(key, fallback)는 키가 없을 때 사용할 기본값을 함께 지정합니다.

import unibase.collections.List;
import unibase.collections.Map;

class MapCounts {
    static void main() {
        List<string> words = ["red", "blue", "red"];
        Map<string, int> counts = Map<string, int>();
        for (int i = 0; i < words.size(); i = i + 1) {
            string word = words.get(i);
            int previous = counts.getOrDefault(word, 0);
            counts.put(word, previous + 1);
        }
        print(counts.getOrDefault("red", 0));
        print(counts.getOrDefault("blue", 0));
        print(counts.getOrDefault("green", 0));
    }
}

import java.util.*;

public class MapCounts {
    public static void main(String[] args) throws Exception {
        List<String> words = List.of("red", "blue", "red");
        Map<String, Integer> counts = new HashMap<>();
        for (String word : words) { counts.put(word, counts.getOrDefault(word, 0) + 1); }
        System.out.println(counts.getOrDefault("red", 0));
        System.out.println(counts.getOrDefault("blue", 0));
        System.out.println(counts.getOrDefault("green", 0));
    }
}

words = ["red", "blue", "red"]
counts: dict[str, int] = {}
for word in words:
    counts[word] = counts.get(word, 0) + 1
print(counts.get("red", 0))
print(counts.get("blue", 0))
print(counts.get("green", 0))

using System;
using System.Collections.Generic;

class MapCounts {
    static void Main() {
        var words = new List<string> { "red", "blue", "red" };
        var counts = new Dictionary<string, int>();
        foreach (string word in words) { counts[word] = counts.GetValueOrDefault(word, 0) + 1; }
        Console.WriteLine(counts.GetValueOrDefault("red", 0));
        Console.WriteLine(counts.GetValueOrDefault("blue", 0));
        Console.WriteLine(counts.GetValueOrDefault("green", 0));
    }
}

const words = ["red", "blue", "red"];
const counts = new Map<string, number>();
for (const word of words) { counts.set(word, (counts.get(word) ?? 0) + 1); }
console.log(counts.get("red") ?? 0);
console.log(counts.get("blue") ?? 0);
console.log(counts.get("green") ?? 0);

package main

import (
	"fmt"
)

func main() {
	words := []string{"red", "blue", "red"}
	counts := make(map[string]int)
	for _, word := range words {
		counts[word] = counts[word] + 1
	}
	fmt.Println(counts["red"])
	fmt.Println(counts["blue"])
	fmt.Println(counts["green"])
}

서버 실행을 준비 중입니다.

Unibase 실행 결과

빌드·실행 메시지

출력 비교 기준

2
1
0

Unibase 소스 내려받기

검증 상태: 문법 검사 통과 · 실행 출력 일치 (2026-10-06)

읽기 기준 결과와 실제 실행 출력 비교

코드를 읽어 정한 비교 기준입니다. 실행 성공 결과로 대신 표시하지 않습니다.

2
1
0

실제 네이티브 실행: 빌드 passed, 실행 passed, 종료 코드 0

2
1
0

현재 실행 확인 범위

각 단어의 기존 횟수를 읽고 1을 더해 같은 키에 저장합니다. 처음 보는 단어는 기본값 0에서 시작합니다. 소스를 읽으면 red는 2, blue는 1이며 입력에 없는 green은 0입니다. 같은 키를 두 번 처리해도 키가 두 개 생기는 것이 아니라 값이 갱신됩니다.

키와 값을 따로 다루기

{"left": 10, "right": 20}처럼 키: 값 쌍으로 맵을 초기화합니다. keys()는 키의 Set, values()는 값의 List를 반환하는 선언입니다.

import unibase.collections.List;
import unibase.collections.Map;
import unibase.collections.Set;

class MapViews {
    static void main() {
        Map<string, int> values = {"left": 10, "right": 20};
        Set<string> keys = values.keys();
        List<int> numbers = values.values();
        int total = 0;
        for (int i = 0; i < numbers.size(); i = i + 1) {
            total = total + numbers.get(i);
        }
        print(keys.size());
        print(total);
    }
}

import java.util.*;

public class MapViews {
    public static void main(String[] args) throws Exception {
        Map<String, Integer> values = new HashMap<>();
        values.put("left", 10);
        values.put("right", 20);
        Set<String> keys = values.keySet();
        int total = 0;
        for (int value : values.values()) { total += value; }
        System.out.println(keys.size());
        System.out.println(total);
    }
}

values = {"left": 10, "right": 20}
keys = values.keys()
total = 0
for value in values.values():
    total += value
print(len(keys))
print(total)

using System;
using System.Collections.Generic;

class MapViews {
    static void Main() {
        var values = new Dictionary<string, int> { ["left"] = 10, ["right"] = 20 };
        var keys = values.Keys;
        int total = 0;
        foreach (int value in values.Values) { total += value; }
        Console.WriteLine(keys.Count);
        Console.WriteLine(total);
    }
}

const values = new Map<string, number>([["left", 10], ["right", 20]]);
const keys = new Set(values.keys());
let total = 0;
for (const value of values.values()) { total += value; }
console.log(keys.size);
console.log(total);

package main

import (
	"fmt"
)

func main() {
	values := map[string]int{"left": 10, "right": 20}
	total := 0
	for _, value := range values {
		total += value
	}
	fmt.Println(len(values))
	fmt.Println(total)
}

서버 실행을 준비 중입니다.

Unibase 실행 결과

빌드·실행 메시지

출력 비교 기준

2
30

Unibase 소스 내려받기

검증 상태: 문법 검사 통과 · 실행 출력 일치 (2026-10-06)

읽기 기준 결과와 실제 실행 출력 비교

코드를 읽어 정한 비교 기준입니다. 실행 성공 결과로 대신 표시하지 않습니다.

2
30

실제 네이티브 실행: 빌드 passed, 실행 passed, 종료 코드 0

2
30

현재 실행 확인 범위

키의 개수 2와 값의 합계 30을 함께 살펴보세요. 키·값 조회 결과의 순서는 보장하지 않으므로 이 예제는 합계만 계산합니다. Standard 라이브러리에서 추가 API를 찾을 수 있습니다.

컬렉션 API 참고

아래는 현재 Standard .uni에 선언된 형태입니다. 이름과 반환 타입을 확인할 수 있지만 범위 오류의 예외 타입, 동등성·hash 규칙, 원본과 결과의 공유 여부, 시간 복잡도까지 선언만으로 확정하지 않습니다.

List 메서드

선언 형태	용도와 읽는 기준
`List<T>()`	빈 목록 생성
`void add(T value)`	항목 추가
`void addAll(List<T> values)`	다른 목록의 항목 추가
`void insert(int index, T value)`	지정 위치에 추가하는 형태
`T get(int index)`	인덱스로 조회
`T first()`, `T last()`	첫 항목·마지막 항목 조회
`T set(int index, T value)`	위치를 지정한 변경; 반환 타입은 T
`T removeAt(int index)`	인덱스로 제거
`T removeFirst()`, `T removeLast()`	양끝 항목 제거
`bool remove(T value)`	값으로 제거; 반환 타입은 bool
`bool contains(T value)`, `bool containsAll(List<T>)`	값·목록 포함 여부
`int indexOf(T value)`	값의 위치 조회
`void removeAll(List<T>)`, `void retainAll(List<T>)`	다른 목록을 기준으로 제거·유지
`List<T> subList(int start, int end)`	부분 목록 조회
`Set<T> toSet()`	집합 형태로 변환
`void clear()`	전체 항목 제거
`int size()`, `bool isEmpty()`, `bool isNotEmpty()`	크기·비어 있는지 조회

현재 native 런타임에서 set()과 removeAt()은 변경·제거 전의 값을 반환합니다. indexOf()는 값을 찾지 못하면 -1을 반환합니다. subList(start, end)는 start를 포함하고 end를 제외한 새 목록을 만들며, subList(0, 0)은 빈 목록입니다. 범위는 0 <= start <= end <= size()여야 합니다. 범위 밖 조회와 빈 목록의 first()·last()는 실행 오류이므로 먼저 크기나 isEmpty()를 확인하세요.

Set 메서드

선언 형태	용도와 읽는 기준
`Set<T>()`	빈 집합 생성
`bool add(T value)`, `bool remove(T value)`	값 추가·제거
`void addAll(Set<T>)`	여러 값 추가
`bool contains(T)`, `bool containsAll(Set<T>)`	포함 여부 조회
`void removeAll(Set<T>)`, `void retainAll(Set<T>)`	다른 집합을 기준으로 제거·유지
`Set<T> union(Set<T>)`	합집합 반환 형태
`Set<T> intersection(Set<T>)`	교집합 반환 형태
`Set<T> difference(Set<T>)`	차집합 반환 형태
`List<T> toList()`	목록 형태로 변환
`void clear()`	전체 값 제거
`int size()`, `bool isEmpty()`, `bool isNotEmpty()`	크기·비어 있는지 조회

차집합은 방향이 있습니다. 왼쪽에만 있는 값과 오른쪽에만 있는 값은 서로 다를 수 있습니다. 중복 제거를 확인할 때는 집합의 크기와 포함 여부를 사용하고, 목록으로 변환한 뒤의 순서에 의존하지 마세요.

Map 메서드

선언 형태	용도와 읽는 기준
`Map<K, V>()`	빈 맵 생성
`V put(K key, V value)`	키에 값 저장
`void putAll(Map<K, V>)`	다른 맵의 값 저장
`V putIfAbsent(K key, V value)`	키가 없을 때 저장하는 형태
`V get(K key)`	키로 조회
`V getOrDefault(K key, V defaultValue)`	없는 키의 기본값을 지정한 조회
`V replace(K key, V value)`	키의 값 변경
`V remove(K key)`	키로 제거
`bool remove(K key, V value)`, `bool removeEntry(K key, V value)`	키·값 쌍을 지정한 제거
`bool containsKey(K key)`, `bool containsValue(V value)`	키·값 포함 여부
`Set<K> keys()`	키의 집합
`List<V> values()`	값의 목록
`List<MapEntry<K, V>> entries()`	키·값 항목 목록
`void clear()`	전체 쌍 제거
`int size()`, `bool isEmpty()`, `bool isNotEmpty()`	크기·비어 있는지 조회

MapEntry<K, V>는 public final key·value 필드를 선언합니다. 키와 값을 한 쌍으로 다룰 때 사용하는 형태입니다. keys()와 values()를 별도로 얻은 뒤 같은 인덱스로 짝이 맞는다고 가정하지 마세요.

현재 native 런타임의 put()·replace()·한 인수를 받는 remove()는 이전 값을 반환합니다. 이전 값이 없는 경우에는 null을 반환하므로 선언의 V를 보고 새 정수 값이라고 가정하지 마세요. 없는 키의 get()은 실행 오류입니다. 본문의 집계처럼 containsKey() 또는 getOrDefault()로 부재를 처리하면 처음 보는 키에도 같은 계산을 적용할 수 있습니다. 이 반환 동작은 현재 native 실행 경로의 계약이며 다른 생성 타겟까지 일반화하지 않습니다.

입력을 바꾸어 읽는 법

바꿀 입력	확인할 언어 요소
List를 빈 목록으로 초기화	루프가 0번 돌고 초기 합계를 사용하는지
같은 값을 여러 번 Set에 추가	서로 다른 값의 개수가 늘어나지 않는지
공통 항목이 없는 두 집합	교집합 크기가 0인지
한 단어를 세 번 Map 집계에 전달	동일 키의 값이 3으로 갱신되는지
맵에 없는 키로 기본값 조회	지정한 기본값을 사용하는지

페이지의 소스는 읽기 전용입니다. 내려받은 소스를 수정해 별도 지원 환경에서 확인할 때 위 입력을 비교할 수 있습니다. 현재 서버는 원본 ID·hash로 등록된 소스만 실행합니다.